/*

 *

 *    Copyright (c) 2022 Project CHIP Authors

 *

 *    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.

 */

// THIS FILE IS GENERATED BY ZAP

// This file is generated from clusters-Structs.ipp.zapt

#include <clusters/ProximityRanging/Structs.h>

#include <app/data-model/StructDecodeIterator.h>

#include <app/data-model/WrappedStructEncoder.h>

namespace chip {

namespace app {

namespace Clusters {

namespace ProximityRanging {

namespace Structs {

namespace RDRStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kAzimuth), azimuth);

    encoder.Encode(to_underlying(Fields::kElevation), elevation);

    encoder.Encode(to_underlying(Fields::kAzimuthAccuracy), azimuthAccuracy);

    encoder.Encode(to_underlying(Fields::kElevationAccuracy), elevationAccuracy);

    encoder.Encode(to_underlying(Fields::kReference), reference);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kAzimuth))

        {

            err = DataModel::Decode(reader, azimuth);

        }

        else if (__context_tag == to_underlying(Fields::kElevation))

        {

            err = DataModel::Decode(reader, elevation);

        }

        else if (__context_tag == to_underlying(Fields::kAzimuthAccuracy))

        {

            err = DataModel::Decode(reader, azimuthAccuracy);

        }

        else if (__context_tag == to_underlying(Fields::kElevationAccuracy))

        {

            err = DataModel::Decode(reader, elevationAccuracy);

        }

        else if (__context_tag == to_underlying(Fields::kReference))

        {

            err = DataModel::Decode(reader, reference);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace RDRStruct

namespace RangingMeasurementDataStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kWiFiDevIK), wiFiDevIK);

    encoder.Encode(to_underlying(Fields::kBLEDeviceID), BLEDeviceID);

    encoder.Encode(to_underlying(Fields::kBLTDevIK), BLTDevIK);

    encoder.Encode(to_underlying(Fields::kTimeOfMeasurement), timeOfMeasurement);

    encoder.Encode(to_underlying(Fields::kTimeOfMeasurementOffset), timeOfMeasurementOffset);

    encoder.Encode(to_underlying(Fields::kDistance), distance);

    encoder.Encode(to_underlying(Fields::kErrorMargin), errorMargin);

    encoder.Encode(to_underlying(Fields::kRdr), rdr);

    encoder.Encode(to_underlying(Fields::kDetectedAttackLevel), detectedAttackLevel);

    encoder.Encode(to_underlying(Fields::kRssi), rssi);

    encoder.Encode(to_underlying(Fields::kTxPower), txPower);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kWiFiDevIK))

        {

            err = DataModel::Decode(reader, wiFiDevIK);

        }

        else if (__context_tag == to_underlying(Fields::kBLEDeviceID))

        {

            err = DataModel::Decode(reader, BLEDeviceID);

        }

        else if (__context_tag == to_underlying(Fields::kBLTDevIK))

        {

            err = DataModel::Decode(reader, BLTDevIK);

        }

        else if (__context_tag == to_underlying(Fields::kTimeOfMeasurement))

        {

            err = DataModel::Decode(reader, timeOfMeasurement);

        }

        else if (__context_tag == to_underlying(Fields::kTimeOfMeasurementOffset))

        {

            err = DataModel::Decode(reader, timeOfMeasurementOffset);

        }

        else if (__context_tag == to_underlying(Fields::kDistance))

        {

            err = DataModel::Decode(reader, distance);

        }

        else if (__context_tag == to_underlying(Fields::kErrorMargin))

        {

            err = DataModel::Decode(reader, errorMargin);

        }

        else if (__context_tag == to_underlying(Fields::kRdr))

        {

            err = DataModel::Decode(reader, rdr);

        }

        else if (__context_tag == to_underlying(Fields::kDetectedAttackLevel))

        {

            err = DataModel::Decode(reader, detectedAttackLevel);

        }

        else if (__context_tag == to_underlying(Fields::kRssi))

        {

            err = DataModel::Decode(reader, rssi);

        }

        else if (__context_tag == to_underlying(Fields::kTxPower))

        {

            err = DataModel::Decode(reader, txPower);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace RangingMeasurementDataStruct

namespace BLERangingDeviceRoleConfigStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kRole), role);

    encoder.Encode(to_underlying(Fields::kPeerBLEDeviceID), peerBLEDeviceID);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kRole))

        {

            err = DataModel::Decode(reader, role);

        }

        else if (__context_tag == to_underlying(Fields::kPeerBLEDeviceID))

        {

            err = DataModel::Decode(reader, peerBLEDeviceID);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace BLERangingDeviceRoleConfigStruct

namespace BLTChannelSoundingDeviceRoleConfigStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kRole), role);

    encoder.Encode(to_underlying(Fields::kPeerBLTDevIK), peerBLTDevIK);

    encoder.Encode(to_underlying(Fields::kBLTCSMode), BLTCSMode);

    encoder.Encode(to_underlying(Fields::kBLTCSSecurityLevel), BLTCSSecurityLevel);

    encoder.Encode(to_underlying(Fields::kLtk), ltk);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kRole))

        {

            err = DataModel::Decode(reader, role);

        }

        else if (__context_tag == to_underlying(Fields::kPeerBLTDevIK))

        {

            err = DataModel::Decode(reader, peerBLTDevIK);

        }

        else if (__context_tag == to_underlying(Fields::kBLTCSMode))

        {

            err = DataModel::Decode(reader, BLTCSMode);

        }

        else if (__context_tag == to_underlying(Fields::kBLTCSSecurityLevel))

        {

            err = DataModel::Decode(reader, BLTCSSecurityLevel);

        }

        else if (__context_tag == to_underlying(Fields::kLtk))

        {

            err = DataModel::Decode(reader, ltk);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace BLTChannelSoundingDeviceRoleConfigStruct

namespace RangingCapabilitiesStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kTechnology), technology);

    encoder.Encode(to_underlying(Fields::kFrequencyBand), frequencyBand);

    encoder.Encode(to_underlying(Fields::kPeriodicRangingSupport), periodicRangingSupport);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kTechnology))

        {

            err = DataModel::Decode(reader, technology);

        }

        else if (__context_tag == to_underlying(Fields::kFrequencyBand))

        {

            err = DataModel::Decode(reader, frequencyBand);

        }

        else if (__context_tag == to_underlying(Fields::kPeriodicRangingSupport))

        {

            err = DataModel::Decode(reader, periodicRangingSupport);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace RangingCapabilitiesStruct

namespace RangingTriggerConditionStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kStartTime), startTime);

    encoder.Encode(to_underlying(Fields::kEndTime), endTime);

    encoder.Encode(to_underlying(Fields::kRangingInstanceInterval), rangingInstanceInterval);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kStartTime))

        {

            err = DataModel::Decode(reader, startTime);

        }

        else if (__context_tag == to_underlying(Fields::kEndTime))

        {

            err = DataModel::Decode(reader, endTime);

        }

        else if (__context_tag == to_underlying(Fields::kRangingInstanceInterval))

        {

            err = DataModel::Decode(reader, rangingInstanceInterval);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace RangingTriggerConditionStruct

namespace ReportingConditionStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kMinDistanceCondition), minDistanceCondition);

    encoder.Encode(to_underlying(Fields::kMaxDistanceCondition), maxDistanceCondition);

    encoder.Encode(to_underlying(Fields::kErrorMarginCondition), errorMarginCondition);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kMinDistanceCondition))

        {

            err = DataModel::Decode(reader, minDistanceCondition);

        }

        else if (__context_tag == to_underlying(Fields::kMaxDistanceCondition))

        {

            err = DataModel::Decode(reader, maxDistanceCondition);

        }

        else if (__context_tag == to_underlying(Fields::kErrorMarginCondition))

        {

            err = DataModel::Decode(reader, errorMarginCondition);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace ReportingConditionStruct

namespace WiFiRangingDeviceRoleConfigStruct {

CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const

{

    DataModel::WrappedStructEncoder encoder{ aWriter, aTag };

    encoder.Encode(to_underlying(Fields::kRole), role);

    encoder.Encode(to_underlying(Fields::kPeerWiFiDevIK), peerWiFiDevIK);

    encoder.Encode(to_underlying(Fields::kPmk), pmk);

    return encoder.Finalize();

}

CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)

{

    detail::StructDecodeIterator __iterator(reader);

    while (true)

    {

        uint8_t __context_tag = 0;

        CHIP_ERROR err        = __iterator.Next(__context_tag);

        VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);

        ReturnErrorOnFailure(err);

        if (__context_tag == to_underlying(Fields::kRole))

        {

            err = DataModel::Decode(reader, role);

        }

        else if (__context_tag == to_underlying(Fields::kPeerWiFiDevIK))

        {

            err = DataModel::Decode(reader, peerWiFiDevIK);

        }

        else if (__context_tag == to_underlying(Fields::kPmk))

        {

            err = DataModel::Decode(reader, pmk);

        }

        ReturnErrorOnFailure(err);

    }

}

} // namespace WiFiRangingDeviceRoleConfigStruct

} // namespace Structs

} // namespace ProximityRanging

} // namespace Clusters

} // namespace app

} // namespace chip