tree 510c9a7996092ad2b632e4a078adf9244ba65416
parent e1b5fbe283ad3879033e3bb2067004b6dfd45845
author Andrei Litvin <andy314@gmail.com> 1718060342 -0400
committer GitHub <noreply@github.com> 1718060342 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJmZ4U2CRC1aQ7uu5UhlAAAXDMQAFiVbL4p0pni4PDSBwLvPWVl
 6O6lRcTWabSWHLNdMxSsYsSYwA2mK+a+3zNsBub2F//UwKGTr9zq7HJjeZWg+NwE
 eW+NFSrN70JpbAafIBVKq7JRWSFQdpwYPCpsOmOhGnn6dfviSOoS9neUcbLPO5wA
 ug8enFuf7Dt/H/4ZQxTI7eNniL6e3O8Guw6rjk3MKnO6CxAb9aZh3LtC3KFbe6Lv
 dAIjsiYWodrKh5r7q3E+Omky8jo0HJ/04APaUHPMROc8seVo0Ej8ZfIQd9BuFTbg
 UogjMQlh1gPz+n4EQiMd8mH0N8EfqzouI0mMC9qe37m2zKUMEKt5es0qdFsJqSB2
 0J1z6YqcMoLWxVpfB2z/tiZNVFUmrj4eAaHFOVIw4v2XIhDtTVnJQihoUXbqzEdr
 EIrpvKtDkYCxgedbJG6my/MoOi65G4PnHv0nbKNO1j2L7F5ro9r9LslFnyvBzM8v
 uErAQdbWtXehgr2TiZ50K+rG4bP3xp6/SGiOSxsm7ynsPTSUg+BXGhfF4tBokCf9
 XjJfa4b5+dofUGw/9Flx6GwuPZGP9s63cAB+WfhJsYdluZEbuZpyZgeiFY7y4/7i
 ylEm29cQxHPwlGjmyvqldTwnrg34QataVHSZPi/t69j17M3cXHme4jbgyCl3EjOE
 J9YeUs5HKklDWXlaO0/R
 =ULE4
 -----END PGP SIGNATURE-----
 

cluster model decoupling - declare the codegen (ember) version and implement iteration (#33345)

* Initial copy with a clean history

* make linter happy

* Restyle

* Fix typo

* Add nolint: assert will return before we use the underlying value

* 2 more fixes regarding unchecked access

* Switch some asserts to expects, for better test logic

* Model renames

* Add renamed files

* Add some attribute iteration hint

* Make use of the attribute cache

* Restyle

* Add a cluster iteration hint

* Add a few more hints. Ember code still contains loops though, so this may not be ideal still

* Add some TODO items for using faster iterations for data. Ember index vs value duality still needs some work

* Add a cluster type cache as well. This relies on ember being reasonably static

* Add global attribute handling

* Fix typing u16 vs unsigned

* Fix auto-added include names

* Remove back the initialization and make the comment more obvious

* Update src/app/codegen-interaction-model/model.gni

Co-authored-by: Karsten Sperling <113487422+ksperling-apple@users.noreply.github.com>

* Code review feedback: added comments

* Update src/app/codegen-interaction-model/CodegenDataModel.h

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Update src/app/codegen-interaction-model/CodegenDataModel.cpp

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Update src/app/codegen-interaction-model/BUILD.gn

Co-authored-by: Tennessee Carmel-Veilleux <tennessee.carmelveilleux@gmail.com>

* Some cleanup logic for event generation - naming and return values as eventid is not the same as event number

* Comment fix

* More naming updates

* Several comment updates and renamed RequestContext to ActionContext

* Restyle

* Rename to InteractionModelContext

* one more rename

* Fix typo

* Fix tests to compile

* More renames of actions to context

* One more comment added

* Restyle

* Address review comments

* Restyle

* make clang-tidy happy

* Operator== exists on optional ... make use of that directly

* Started renaming things

* Use the right types in Model.h

* Make things compile

* Skip global attribute handling, add TODOs for reading extra bits from ember

* Typo fix

* Several flags and correct loading of privileges for attributes

* Start implementing command iteration ... still feels awkward and caching will be a pain

* We seem to also support fabric scoping detection

* implementation is in theory done, need unit tests

* Fix iterator name

* Mock support for accepted/generated commands, start having unit tests

* Better iteration tests on accepted commands

* More unit tests and fix bugs

* Restyle

* More tests, one iteration bug fix

* Slight update again

* Aiming for more test coverage

* More test coverage for edge cases in iteration

* Fix code review comment

* Restyle

* Update src/app/interaction-model/Events.h

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Update src/app/interaction-model/IterationTypes.h

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Update src/app/interaction-model/Paths.h

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Fix comment about validity

* Some kListBegin/End comment updates

* Drop kListBegin/End alltogether

* Drop groupId

* Comment update

* Update for data version to be mandatory, add more error reporting and logging

* Update to use kInvalid instead of Invalid method

* Update flags.set

* Use IsServerMask on clusterr class

* Use a struct instead of a typedef

* Fix compile without error logging

* Restyle

* Remove command quality that is not supported

* Restyle

* Rename IsServerMask to IsServer

---------

Co-authored-by: Andrei Litvin <andreilitvin@google.com>
Co-authored-by: Karsten Sperling <113487422+ksperling-apple@users.noreply.github.com>
Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>
Co-authored-by: Tennessee Carmel-Veilleux <tennessee.carmelveilleux@gmail.com>