tree 0249f31d5060ae638a4a708774ad6cea27abebb8
parent 0388636344460fb7af99e9d4839bd22f06876560
author William <hicklin@users.noreply.github.com> 1692108747 +0100
committer GitHub <noreply@github.com> 1692108747 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJk24fLCRBK7hj4Ov3rIwAA4/AIAEj9scQtkkBZa3WKL7ocXeH9
 MVPRil6M/I3jsgs75EOZ9WXBSPhcRXkSTzJc9sP7MtbgatiMj4vA+znF1Qg4xTbF
 RUUv8mjSYsg0OJIpTvkel9fSQOeuF140GA1wYVALzKAaCXjiRbH9lZytGTJHqSu1
 xiaz9H+9tgopu/UC29lD62M1Yc09e2LLqw70oCoEJCnrVrTAIuYxM7fSaubOEiBV
 mZ6ygwoB0/WYCRdW8zwGhuuV5XxK2krlrdwRXe6QsfSnWakKNBMyjd1VGkoRE87N
 nt3ssPS+DixBsSEQMayyHb5ieJVKtW2oT68rrE6V4RFKqVDIOdfLI/IWjyU9A7E=
 =8foG
 -----END PGP SIGNATURE-----
 

Update operational state server and related examples (#28577)

* Reordered Mode Base functions.

* Moved generic OpState cluster objects into one header file.

* Reordered OperationalStateServer functions.

* Moved OpState delegate in the server header file.

* Updated the TestOperationalStateDelegate inctludes following the operational state delegate change in location.

* Renamed TestOperationalStateDelegate.cpp -> src/app/tests/TestOperationalStateClusterObjects.cpp

* Restyled by clang-format

* Minor corrections following revision.

* Refactored the OperationalState server code to match with other derived cluters. Updated the examples to work with this change.

* Explicitly initialised the edpoint ID in the operational state examples to improve readability.

* OpState: Made OpState getters return const.

* Restyled by clang-format

* Moved the responsibility of storing and managing the countdown time attribute to the delegate.

* Applied minor review changes.

* OpState: Made the improved the relationship between the Delegate and Instance classes.

* OpState: Removed the ability to set the OperationalState to the Error state and the ability to set the OperationalError. These can only be set via the ErrorDetected event.

* OpState: Fixed GetCurrentOperationalError

* Restyled by clang-format

* Added checks to the phase and operational state setters to ensure that the value given is valid.

* Added a safe method to check if two GenericOperationalError objects are equal.

* GetInstance returns a const pointer.

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

* Restyled by clang-format

---------

Co-authored-by: Restyled.io <commits@restyled.io>
Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>