src/app/clusters/service-area-server/service-area-cluster-objects.h - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 2024 Project CHIP Authors
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 #pragma once

 #include <app-common/zap-generated/cluster-objects.h>
 #include <lib/support/CommonIterator.h>

 namespace chip {
 namespace app {
 namespace Clusters {
 namespace ServiceArea {

 // These limits are defined in the spec.
 inline constexpr size_t kMaxNumSupportedAreas   = 255;
 inline constexpr size_t kMaxNumSupportedMaps    = 255;
 inline constexpr size_t kMaxNumSelectedAreas    = 255;
 inline constexpr size_t kMaxNumProgressElements = 255;
 inline constexpr size_t kMaxSizeStatusText      = 256;
 inline constexpr size_t kAreaNameMaxSize        = 128u;
 inline constexpr size_t kMapNameMaxSize         = 64u;

 /**
  * This class is used to wrap the AreaStruct object and provide a more user-friendly interface for the data.
  * It provides a way to store the location name in a buffer, and provides a way to compare the location name with a given string.
  */
 struct AreaStructureWrapper : public chip::app::Clusters::ServiceArea::Structs::AreaStruct::Type
 {
     /**
      * @brief This is a default constructor that initializes the location object with the following
      * values: areaID = 0, mapID = null, locationInfo = null, landmarkInfo = null.
      */
     AreaStructureWrapper()
     {
         areaID = 0;
         mapID  = DataModel::NullNullable;
         SetLocationInfoNull();
         SetLandmarkInfoNull();
     }

     /**
      * @brief This is a copy constructor that initializes the location object with the values from another location object. All
      * values are deep copied.
      * @param[in] aOther The location object to copy.
      *
      * @note If the locationName is empty string and aFloorNumber and aAreaTypeTag are null, locationInfo will be set to null.
      */
     AreaStructureWrapper(const AreaStructureWrapper & aOther) { *this = aOther; }

     /**
      * @brief This is an assignment operator that initializes the location object with the values from another location object. All
      * values are deep copied.
      * @param[in] aOther The location object to copy.
      *
      * @note If the locationName is empty string and aFloorNumber and aAreaTypeTag are null, locationInfo will be set to null.
      */
     AreaStructureWrapper & operator=(const AreaStructureWrapper & aOther)
     {
         areaID = aOther.areaID;
         mapID  = aOther.mapID;
         SetLocationInfo(aOther.areaInfo.locationInfo);
         SetLandmarkInfo(aOther.areaInfo.landmarkInfo);

         return *this;
     }

     bool operator==(const AreaStructureWrapper & aOther) const
     {
         BitMask<IsEqualConfig> config = 0; // Do not ignore the AreaID or the MapID.

         return IsEqual(aOther, config);
     }

     AreaStructureWrapper & SetAreaId(uint32_t aAreaID)
     {
         areaID = aAreaID;
         return *this;
     }

     AreaStructureWrapper & SetMapId(const DataModel::Nullable<uint32_t> & aMapId)
     {
         mapID = aMapId;
         return *this;
     }

     AreaStructureWrapper & SetLocationInfoNull()
     {
         areaInfo.locationInfo.SetNull();
         return *this;
     }

     /**
      * @brief Set the location information.
      * @param[in] locationName The name of the location. If the name is larger than kAreaNameMaxSize, it will be truncated.
      * @param[in] floorNumber The floor number of the location.
      * @param[in] areaType The type of the area.
      */
     AreaStructureWrapper & SetLocationInfo(const CharSpan & locationName, const DataModel::Nullable<int16_t> & floorNumber,
                                            const DataModel::Nullable<Globals::AreaTypeTag> & areaType)
     {
         areaInfo.locationInfo.SetNonNull();

         // Copy the name. If the name is larger than kAreaNameMaxSize, truncate it to fit.
         auto sizeToCopy = std::min(kAreaNameMaxSize, locationName.size());
         memcpy(mAreaNameBuffer, locationName.data(), sizeToCopy);
         areaInfo.locationInfo.Value().locationName = CharSpan(mAreaNameBuffer, sizeToCopy);

         areaInfo.locationInfo.Value().floorNumber = floorNumber;
         areaInfo.locationInfo.Value().areaType    = areaType;

         return *this;
     }

     /**
      * @brief Set the location information form a LocationDescriptorStruct object.
      *
      * @note If the locationName is larger than kAreaNameMaxSize, it will be truncated.
      */
     AreaStructureWrapper & SetLocationInfo(DataModel::Nullable<Globals::Structs::LocationDescriptorStruct::Type> locationInfo)
     {
         if (locationInfo.IsNull())
         {
             return SetLocationInfoNull();
         }

         return SetLocationInfo(locationInfo.Value().locationName, locationInfo.Value().floorNumber, locationInfo.Value().areaType);
     }

     AreaStructureWrapper & SetLandmarkInfoNull()
     {
         areaInfo.landmarkInfo.SetNull();
         return *this;
     }

     /**
      * @brief Set the landmark information.
      * @param[in] landmarkTag The landmark tag.
      * @param[in] relativePositionTag The relative position tag.
      */
     AreaStructureWrapper & SetLandmarkInfo(const Globals::LandmarkTag & landmarkTag,
                                            const DataModel::Nullable<Globals::RelativePositionTag> & relativePositionTag)
     {
         areaInfo.landmarkInfo.SetNonNull();
         areaInfo.landmarkInfo.Value().landmarkTag         = landmarkTag;
         areaInfo.landmarkInfo.Value().relativePositionTag = relativePositionTag;

         return *this;
     }

     /**
      * @brief Set the landmark information from a LandmarkInfoStruct object.
      */
     AreaStructureWrapper & SetLandmarkInfo(DataModel::Nullable<Structs::LandmarkInfoStruct::Type> landmarkInfo)
     {
         if (landmarkInfo.IsNull())
         {
             return SetLandmarkInfoNull();
         }

         return SetLandmarkInfo(landmarkInfo.Value().landmarkTag, landmarkInfo.Value().relativePositionTag);
     }

     /**
      * @brief Compare the area's name with the given text.
      * @param[in] aAreaName The name to compare.
      * @return true if the area structure's name field matches aAreaName.
      * False otherwise, including if the location structure's LocationInfo structure is null.
      */
     bool IsNameEqual(const CharSpan & aAreaName) const
     {
         if (!areaInfo.locationInfo.IsNull())
         {
             return areaInfo.locationInfo.Value().locationName.data_equal(aAreaName);
         }

         return false;
     }

     /**
      * This is used for configuring the IsEqual method.
      * If kIgnoreAreaID is set, the area IDs are ignored when checking for equality.
      * If kIgnoreMapId is set, the map IDs are ignored when checking for equality.
      */
     enum class IsEqualConfig : uint8_t
     {
         kIgnoreAreaID = 0x1,
         kIgnoreMapId  = 0x2,
     };

     /**
      * @brief Checks if the given AreaStructureWrapper is equal to this one.
      * @param aOther The location to compare with.
      * @param aConfig Set if the area IDs and/or the map IDs should be ignored when checking for equality.
      * @return True if both locations are equal. False otherwise.
      */
     bool IsEqual(const AreaStructureWrapper & aOther, BitMask<IsEqualConfig> aConfig) const
     {
         if (!aConfig.Has(IsEqualConfig::kIgnoreAreaID) && (areaID != aOther.areaID))
         {
             return false;
         }

         if (!aConfig.Has(IsEqualConfig::kIgnoreMapId) && (mapID != aOther.mapID))
         {
             return false;
         }

         if (areaInfo.locationInfo.IsNull() != aOther.areaInfo.locationInfo.IsNull())
         {
             return false;
         }

         if (!areaInfo.locationInfo.IsNull())
         {

             if (!IsNameEqual(aOther.areaInfo.locationInfo.Value().locationName))
             {
                 return false;
             }

             if (areaInfo.locationInfo.Value().floorNumber != aOther.areaInfo.locationInfo.Value().floorNumber)
             {
                 return false;
             }

             if (areaInfo.locationInfo.Value().areaType != aOther.areaInfo.locationInfo.Value().areaType)
             {
                 return false;
             }
         }

         if (areaInfo.landmarkInfo.IsNull() != aOther.areaInfo.landmarkInfo.IsNull())
         {
             return false;
         }

         if (!areaInfo.landmarkInfo.IsNull())
         {
             if (areaInfo.landmarkInfo.Value().landmarkTag != aOther.areaInfo.landmarkInfo.Value().landmarkTag)
             {
                 return false;
             }

             if (areaInfo.landmarkInfo.Value().relativePositionTag != aOther.areaInfo.landmarkInfo.Value().relativePositionTag)
             {
                 return false;
             }
         }

         return true;
     }

     /**
      * @return The location name.
      */
     CharSpan GetName()
     {
         if (areaInfo.locationInfo.IsNull())
         {
             return { mAreaNameBuffer, 0 };
         }

         return areaInfo.locationInfo.Value().locationName;
     }

 private:
     char mAreaNameBuffer[kAreaNameMaxSize] = { 0 };
 };

 /**
  * This class wraps the MapStruct object and provides a more user-friendly interface for the data.
  */
 struct MapStructureWrapper : public chip::app::Clusters::ServiceArea::Structs::MapStruct::Type
 {
     MapStructureWrapper() { Set(0, CharSpan()); }

     /**
      * @brief This is a full constructor that initializes the map object with the given values. All values are deep copied.
      * @param[in] aMapId The identifier of this map.
      * @param[in] aMapName A human readable name (should not be empty string).
      *
      * @note Requirements regarding what combinations of fields and values are 'valid' are not checked by this class.
      * @note If aMapName is larger than kMapNameMaxSize, it will be truncated.
      */
     MapStructureWrapper(uint32_t aMapId, const CharSpan & aMapName) { Set(aMapId, aMapName); }

     /**
      * @brief This is a copy constructor that initializes the map object with the values from another map object. All values are
      * deep copied.
      * @param[in] aOther The map object to copy.
      */
     MapStructureWrapper(const MapStructureWrapper & aOther) { *this = aOther; }

     /**
      * @brief This is an assignment operator that initializes the map object with the values from another map object. All values are
      * deep copied.
      * @param[in] aOther The map object to copy.
      */
     MapStructureWrapper & operator=(const MapStructureWrapper & aOther)
     {
         Set(aOther.mapID, aOther.name);
         return *this;
     }

     /**
      * @brief Set all fields of the map object. All values are deep copied.
      * @param[in] aMapId The identifier of this map.
      * @param[in] aMapName A human readable name (should not be empty string).
      *
      * @note Requirements regarding what combinations of fields and values are 'valid' are not checked by this class.
      * @note if aMapName is larger than kMapNameMaxSize, it will be truncated.
      */
     void Set(uint32_t aMapId, const CharSpan & aMapName)
     {
         mapID = aMapId;
         // Copy the name. If the name is larger than kMapNameMaxSize, truncate it to fit.
         auto sizeToCopy = std::min(kMapNameMaxSize, aMapName.size());
         memcpy(mMapNameBuffer, aMapName.data(), sizeToCopy);
         name = CharSpan(mMapNameBuffer, sizeToCopy);
     }

     /**
      * @brief Compare the map's name with given text.
      * @param[in] aMapName The name to compare.
      * @return true if the map structure's name field matches aMapName.
      */
     bool IsNameEqual(const CharSpan & aMapName) const { return name.data_equal(aMapName); }

     /**
      * @return The map name.
      */
     CharSpan GetName() const { return name; }

 private:
     char mMapNameBuffer[kMapNameMaxSize] = { 0 };
 };

 } // namespace ServiceArea
 } // namespace Clusters
 } // namespace app
 } // namespace chip
	/*
	*
	* Copyright (c) 2024 Project CHIP Authors
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#pragma once

	#include <app-common/zap-generated/cluster-objects.h>
	#include <lib/support/CommonIterator.h>

	namespace chip {
	namespace app {
	namespace Clusters {
	namespace ServiceArea {

	// These limits are defined in the spec.
	inline constexpr size_t kMaxNumSupportedAreas = 255;
	inline constexpr size_t kMaxNumSupportedMaps = 255;
	inline constexpr size_t kMaxNumSelectedAreas = 255;
	inline constexpr size_t kMaxNumProgressElements = 255;
	inline constexpr size_t kMaxSizeStatusText = 256;
	inline constexpr size_t kAreaNameMaxSize = 128u;
	inline constexpr size_t kMapNameMaxSize = 64u;

	/**
	* This class is used to wrap the AreaStruct object and provide a more user-friendly interface for the data.
	* It provides a way to store the location name in a buffer, and provides a way to compare the location name with a given string.
	*/
	struct AreaStructureWrapper : public chip::app::Clusters::ServiceArea::Structs::AreaStruct::Type
	{
	/**
	* @brief This is a default constructor that initializes the location object with the following
	* values: areaID = 0, mapID = null, locationInfo = null, landmarkInfo = null.
	*/
	AreaStructureWrapper()
	{
	areaID = 0;
	mapID = DataModel::NullNullable;
	SetLocationInfoNull();
	SetLandmarkInfoNull();
	}

	/**
	* @brief This is a copy constructor that initializes the location object with the values from another location object. All
	* values are deep copied.
	* @param[in] aOther The location object to copy.
	*
	* @note If the locationName is empty string and aFloorNumber and aAreaTypeTag are null, locationInfo will be set to null.
	*/
	AreaStructureWrapper(const AreaStructureWrapper & aOther) { *this = aOther; }

	/**
	* @brief This is an assignment operator that initializes the location object with the values from another location object. All
	* values are deep copied.
	* @param[in] aOther The location object to copy.
	*
	* @note If the locationName is empty string and aFloorNumber and aAreaTypeTag are null, locationInfo will be set to null.
	*/
	AreaStructureWrapper & operator=(const AreaStructureWrapper & aOther)
	{
	areaID = aOther.areaID;
	mapID = aOther.mapID;
	SetLocationInfo(aOther.areaInfo.locationInfo);
	SetLandmarkInfo(aOther.areaInfo.landmarkInfo);

	return *this;
	}

	bool operator==(const AreaStructureWrapper & aOther) const
	{
	BitMask<IsEqualConfig> config = 0; // Do not ignore the AreaID or the MapID.

	return IsEqual(aOther, config);
	}

	AreaStructureWrapper & SetAreaId(uint32_t aAreaID)
	{
	areaID = aAreaID;
	return *this;
	}

	AreaStructureWrapper & SetMapId(const DataModel::Nullable<uint32_t> & aMapId)
	{
	mapID = aMapId;
	return *this;
	}

	AreaStructureWrapper & SetLocationInfoNull()
	{
	areaInfo.locationInfo.SetNull();
	return *this;
	}

	/**
	* @brief Set the location information.
	* @param[in] locationName The name of the location. If the name is larger than kAreaNameMaxSize, it will be truncated.
	* @param[in] floorNumber The floor number of the location.
	* @param[in] areaType The type of the area.
	*/
	AreaStructureWrapper & SetLocationInfo(const CharSpan & locationName, const DataModel::Nullable<int16_t> & floorNumber,
	const DataModel::Nullable<Globals::AreaTypeTag> & areaType)
	{
	areaInfo.locationInfo.SetNonNull();

	// Copy the name. If the name is larger than kAreaNameMaxSize, truncate it to fit.
	auto sizeToCopy = std::min(kAreaNameMaxSize, locationName.size());
	memcpy(mAreaNameBuffer, locationName.data(), sizeToCopy);
	areaInfo.locationInfo.Value().locationName = CharSpan(mAreaNameBuffer, sizeToCopy);

	areaInfo.locationInfo.Value().floorNumber = floorNumber;
	areaInfo.locationInfo.Value().areaType = areaType;

	return *this;
	}

	/**
	* @brief Set the location information form a LocationDescriptorStruct object.
	*
	* @note If the locationName is larger than kAreaNameMaxSize, it will be truncated.
	*/
	AreaStructureWrapper & SetLocationInfo(DataModel::Nullable<Globals::Structs::LocationDescriptorStruct::Type> locationInfo)
	{
	if (locationInfo.IsNull())
	{
	return SetLocationInfoNull();
	}

	return SetLocationInfo(locationInfo.Value().locationName, locationInfo.Value().floorNumber, locationInfo.Value().areaType);
	}

	AreaStructureWrapper & SetLandmarkInfoNull()
	{
	areaInfo.landmarkInfo.SetNull();
	return *this;
	}

	/**
	* @brief Set the landmark information.
	* @param[in] landmarkTag The landmark tag.
	* @param[in] relativePositionTag The relative position tag.
	*/
	AreaStructureWrapper & SetLandmarkInfo(const Globals::LandmarkTag & landmarkTag,
	const DataModel::Nullable<Globals::RelativePositionTag> & relativePositionTag)
	{
	areaInfo.landmarkInfo.SetNonNull();
	areaInfo.landmarkInfo.Value().landmarkTag = landmarkTag;
	areaInfo.landmarkInfo.Value().relativePositionTag = relativePositionTag;

	return *this;
	}

	/**
	* @brief Set the landmark information from a LandmarkInfoStruct object.
	*/
	AreaStructureWrapper & SetLandmarkInfo(DataModel::Nullable<Structs::LandmarkInfoStruct::Type> landmarkInfo)
	{
	if (landmarkInfo.IsNull())
	{
	return SetLandmarkInfoNull();
	}

	return SetLandmarkInfo(landmarkInfo.Value().landmarkTag, landmarkInfo.Value().relativePositionTag);
	}

	/**
	* @brief Compare the area's name with the given text.
	* @param[in] aAreaName The name to compare.
	* @return true if the area structure's name field matches aAreaName.
	* False otherwise, including if the location structure's LocationInfo structure is null.
	*/
	bool IsNameEqual(const CharSpan & aAreaName) const
	{
	if (!areaInfo.locationInfo.IsNull())
	{
	return areaInfo.locationInfo.Value().locationName.data_equal(aAreaName);
	}

	return false;
	}

	/**
	* This is used for configuring the IsEqual method.
	* If kIgnoreAreaID is set, the area IDs are ignored when checking for equality.
	* If kIgnoreMapId is set, the map IDs are ignored when checking for equality.
	*/
	enum class IsEqualConfig : uint8_t
	{
	kIgnoreAreaID = 0x1,
	kIgnoreMapId = 0x2,
	};

	/**
	* @brief Checks if the given AreaStructureWrapper is equal to this one.
	* @param aOther The location to compare with.
	* @param aConfig Set if the area IDs and/or the map IDs should be ignored when checking for equality.
	* @return True if both locations are equal. False otherwise.
	*/
	bool IsEqual(const AreaStructureWrapper & aOther, BitMask<IsEqualConfig> aConfig) const
	{
	if (!aConfig.Has(IsEqualConfig::kIgnoreAreaID) && (areaID != aOther.areaID))
	{
	return false;
	}

	if (!aConfig.Has(IsEqualConfig::kIgnoreMapId) && (mapID != aOther.mapID))
	{
	return false;
	}

	if (areaInfo.locationInfo.IsNull() != aOther.areaInfo.locationInfo.IsNull())
	{
	return false;
	}

	if (!areaInfo.locationInfo.IsNull())
	{

	if (!IsNameEqual(aOther.areaInfo.locationInfo.Value().locationName))
	{
	return false;
	}

	if (areaInfo.locationInfo.Value().floorNumber != aOther.areaInfo.locationInfo.Value().floorNumber)
	{
	return false;
	}

	if (areaInfo.locationInfo.Value().areaType != aOther.areaInfo.locationInfo.Value().areaType)
	{
	return false;
	}
	}

	if (areaInfo.landmarkInfo.IsNull() != aOther.areaInfo.landmarkInfo.IsNull())
	{
	return false;
	}

	if (!areaInfo.landmarkInfo.IsNull())
	{
	if (areaInfo.landmarkInfo.Value().landmarkTag != aOther.areaInfo.landmarkInfo.Value().landmarkTag)
	{
	return false;
	}

	if (areaInfo.landmarkInfo.Value().relativePositionTag != aOther.areaInfo.landmarkInfo.Value().relativePositionTag)
	{
	return false;
	}
	}

	return true;
	}

	/**
	* @return The location name.
	*/
	CharSpan GetName()
	{
	if (areaInfo.locationInfo.IsNull())
	{
	return { mAreaNameBuffer, 0 };
	}

	return areaInfo.locationInfo.Value().locationName;
	}

	private:
	char mAreaNameBuffer[kAreaNameMaxSize] = { 0 };
	};

	/**
	* This class wraps the MapStruct object and provides a more user-friendly interface for the data.
	*/
	struct MapStructureWrapper : public chip::app::Clusters::ServiceArea::Structs::MapStruct::Type
	{
	MapStructureWrapper() { Set(0, CharSpan()); }

	/**
	* @brief This is a full constructor that initializes the map object with the given values. All values are deep copied.
	* @param[in] aMapId The identifier of this map.
	* @param[in] aMapName A human readable name (should not be empty string).
	*
	* @note Requirements regarding what combinations of fields and values are 'valid' are not checked by this class.
	* @note If aMapName is larger than kMapNameMaxSize, it will be truncated.
	*/
	MapStructureWrapper(uint32_t aMapId, const CharSpan & aMapName) { Set(aMapId, aMapName); }

	/**
	* @brief This is a copy constructor that initializes the map object with the values from another map object. All values are
	* deep copied.
	* @param[in] aOther The map object to copy.
	*/
	MapStructureWrapper(const MapStructureWrapper & aOther) { *this = aOther; }

	/**
	* @brief This is an assignment operator that initializes the map object with the values from another map object. All values are
	* deep copied.
	* @param[in] aOther The map object to copy.
	*/
	MapStructureWrapper & operator=(const MapStructureWrapper & aOther)
	{
	Set(aOther.mapID, aOther.name);
	return *this;
	}

	/**
	* @brief Set all fields of the map object. All values are deep copied.
	* @param[in] aMapId The identifier of this map.
	* @param[in] aMapName A human readable name (should not be empty string).
	*
	* @note Requirements regarding what combinations of fields and values are 'valid' are not checked by this class.
	* @note if aMapName is larger than kMapNameMaxSize, it will be truncated.
	*/
	void Set(uint32_t aMapId, const CharSpan & aMapName)
	{
	mapID = aMapId;
	// Copy the name. If the name is larger than kMapNameMaxSize, truncate it to fit.
	auto sizeToCopy = std::min(kMapNameMaxSize, aMapName.size());
	memcpy(mMapNameBuffer, aMapName.data(), sizeToCopy);
	name = CharSpan(mMapNameBuffer, sizeToCopy);
	}

	/**
	* @brief Compare the map's name with given text.
	* @param[in] aMapName The name to compare.
	* @return true if the map structure's name field matches aMapName.
	*/
	bool IsNameEqual(const CharSpan & aMapName) const { return name.data_equal(aMapName); }

	/**
	* @return The map name.
	*/
	CharSpan GetName() const { return name; }

	private:
	char mMapNameBuffer[kMapNameMaxSize] = { 0 };
	};

	} // namespace ServiceArea
	} // namespace Clusters
	} // namespace app
	} // namespace chip