/src/connectedhomeip/zzz_generated/app-common/clusters/EnergyEvse/Events.ipp

Source (jump to first uncovered line)
/*
 *
 *    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-Events.ipp.zapt

#include <clusters/EnergyEvse/Events.h>

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

namespace chip {
namespace app {
namespace Clusters {
namespace EnergyEvse {
namespace Events {
namespace EVConnected {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    return aWriter.EndContainer(outer);
}

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::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EVConnected.
namespace EVNotDetected {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionDuration), sessionDuration));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyCharged), sessionEnergyCharged));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyDischarged), sessionEnergyDischarged));
    return aWriter.EndContainer(outer);
}

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::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kSessionDuration))
        {
            err = DataModel::Decode(reader, sessionDuration);
        }
        else if (__context_tag == to_underlying(Fields::kSessionEnergyCharged))
        {
            err = DataModel::Decode(reader, sessionEnergyCharged);
        }
        else if (__context_tag == to_underlying(Fields::kSessionEnergyDischarged))
        {
            err = DataModel::Decode(reader, sessionEnergyDischarged);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EVNotDetected.
namespace EnergyTransferStarted {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumCurrent), maximumCurrent));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumDischargeCurrent), maximumDischargeCurrent));
    return aWriter.EndContainer(outer);
}

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::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kMaximumCurrent))
        {
            err = DataModel::Decode(reader, maximumCurrent);
        }
        else if (__context_tag == to_underlying(Fields::kMaximumDischargeCurrent))
        {
            err = DataModel::Decode(reader, maximumDischargeCurrent);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnergyTransferStarted.
namespace EnergyTransferStopped {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyTransferred), energyTransferred));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyDischarged), energyDischarged));
    return aWriter.EndContainer(outer);
}

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::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kReason))
        {
            err = DataModel::Decode(reader, reason);
        }
        else if (__context_tag == to_underlying(Fields::kEnergyTransferred))
        {
            err = DataModel::Decode(reader, energyTransferred);
        }
        else if (__context_tag == to_underlying(Fields::kEnergyDischarged))
        {
            err = DataModel::Decode(reader, energyDischarged);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace EnergyTransferStopped.
namespace Fault {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStatePreviousState), faultStatePreviousState));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStateCurrentState), faultStateCurrentState));
    return aWriter.EndContainer(outer);
}

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::kSessionID))
        {
            err = DataModel::Decode(reader, sessionID);
        }
        else if (__context_tag == to_underlying(Fields::kState))
        {
            err = DataModel::Decode(reader, state);
        }
        else if (__context_tag == to_underlying(Fields::kFaultStatePreviousState))
        {
            err = DataModel::Decode(reader, faultStatePreviousState);
        }
        else if (__context_tag == to_underlying(Fields::kFaultStateCurrentState))
        {
            err = DataModel::Decode(reader, faultStateCurrentState);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Fault.
namespace Rfid {
CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
{
    TLV::TLVType outer;
    ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
    ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUid), uid));
    return aWriter.EndContainer(outer);
}

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::kUid))
        {
            err = DataModel::Decode(reader, uid);
        }
        else
        {
        }

        ReturnErrorOnFailure(err);
    }
}
} // namespace Rfid.
} // namespace Events
} // namespace EnergyEvse
} // namespace Clusters
} // namespace app
} // namespace chip

Coverage Report

Created: 2025-09-02 06:46

Line	Count	Source (jump to first uncovered line)
1		/*
2		*
3		* Copyright (c) 2022 Project CHIP Authors
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		// THIS FILE IS GENERATED BY ZAP
19		// This file is generated from clusters-Events.ipp.zapt
20
21		#include <clusters/EnergyEvse/Events.h>
22
23		#include <app/data-model/Decode.h>
24		#include <app/data-model/Encode.h>
25		#include <app/data-model/StructDecodeIterator.h>
26		#include <app/data-model/WrappedStructEncoder.h>
27
28		namespace chip {
29		namespace app {
30		namespace Clusters {
31		namespace EnergyEvse {
32		namespace Events {
33		namespace EVConnected {
34		CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
35	0	{
36	0	TLV::TLVType outer;
37	0	ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
38	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
39	0	return aWriter.EndContainer(outer);
40	0	}
41
42		CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
43	0	{
44	0	detail::StructDecodeIterator __iterator(reader);
45	0	while (true)
46	0	{
47	0	uint8_t __context_tag = 0;
48	0	CHIP_ERROR err = __iterator.Next(__context_tag);
49	0	VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
50	0	ReturnErrorOnFailure(err);
51
52	0	if (__context_tag == to_underlying(Fields::kSessionID))
53	0	{
54	0	err = DataModel::Decode(reader, sessionID);
55	0	}
56	0	else
57	0	{
58	0	}
59
60	0	ReturnErrorOnFailure(err);
61	0	}
62	0	}
63		} // namespace EVConnected.
64		namespace EVNotDetected {
65		CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
66	0	{
67	0	TLV::TLVType outer;
68	0	ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
69	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
70	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
71	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionDuration), sessionDuration));
72	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyCharged), sessionEnergyCharged));
73	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionEnergyDischarged), sessionEnergyDischarged));
74	0	return aWriter.EndContainer(outer);
75	0	}
76
77		CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
78	0	{
79	0	detail::StructDecodeIterator __iterator(reader);
80	0	while (true)
81	0	{
82	0	uint8_t __context_tag = 0;
83	0	CHIP_ERROR err = __iterator.Next(__context_tag);
84	0	VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
85	0	ReturnErrorOnFailure(err);
86
87	0	if (__context_tag == to_underlying(Fields::kSessionID))
88	0	{
89	0	err = DataModel::Decode(reader, sessionID);
90	0	}
91	0	else if (__context_tag == to_underlying(Fields::kState))
92	0	{
93	0	err = DataModel::Decode(reader, state);
94	0	}
95	0	else if (__context_tag == to_underlying(Fields::kSessionDuration))
96	0	{
97	0	err = DataModel::Decode(reader, sessionDuration);
98	0	}
99	0	else if (__context_tag == to_underlying(Fields::kSessionEnergyCharged))
100	0	{
101	0	err = DataModel::Decode(reader, sessionEnergyCharged);
102	0	}
103	0	else if (__context_tag == to_underlying(Fields::kSessionEnergyDischarged))
104	0	{
105	0	err = DataModel::Decode(reader, sessionEnergyDischarged);
106	0	}
107	0	else
108	0	{
109	0	}
110
111	0	ReturnErrorOnFailure(err);
112	0	}
113	0	}
114		} // namespace EVNotDetected.
115		namespace EnergyTransferStarted {
116		CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
117	0	{
118	0	TLV::TLVType outer;
119	0	ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
120	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
121	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
122	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumCurrent), maximumCurrent));
123	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kMaximumDischargeCurrent), maximumDischargeCurrent));
124	0	return aWriter.EndContainer(outer);
125	0	}
126
127		CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
128	0	{
129	0	detail::StructDecodeIterator __iterator(reader);
130	0	while (true)
131	0	{
132	0	uint8_t __context_tag = 0;
133	0	CHIP_ERROR err = __iterator.Next(__context_tag);
134	0	VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
135	0	ReturnErrorOnFailure(err);
136
137	0	if (__context_tag == to_underlying(Fields::kSessionID))
138	0	{
139	0	err = DataModel::Decode(reader, sessionID);
140	0	}
141	0	else if (__context_tag == to_underlying(Fields::kState))
142	0	{
143	0	err = DataModel::Decode(reader, state);
144	0	}
145	0	else if (__context_tag == to_underlying(Fields::kMaximumCurrent))
146	0	{
147	0	err = DataModel::Decode(reader, maximumCurrent);
148	0	}
149	0	else if (__context_tag == to_underlying(Fields::kMaximumDischargeCurrent))
150	0	{
151	0	err = DataModel::Decode(reader, maximumDischargeCurrent);
152	0	}
153	0	else
154	0	{
155	0	}
156
157	0	ReturnErrorOnFailure(err);
158	0	}
159	0	}
160		} // namespace EnergyTransferStarted.
161		namespace EnergyTransferStopped {
162		CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
163	0	{
164	0	TLV::TLVType outer;
165	0	ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
166	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
167	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
168	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kReason), reason));
169	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyTransferred), energyTransferred));
170	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kEnergyDischarged), energyDischarged));
171	0	return aWriter.EndContainer(outer);
172	0	}
173
174		CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
175	0	{
176	0	detail::StructDecodeIterator __iterator(reader);
177	0	while (true)
178	0	{
179	0	uint8_t __context_tag = 0;
180	0	CHIP_ERROR err = __iterator.Next(__context_tag);
181	0	VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
182	0	ReturnErrorOnFailure(err);
183
184	0	if (__context_tag == to_underlying(Fields::kSessionID))
185	0	{
186	0	err = DataModel::Decode(reader, sessionID);
187	0	}
188	0	else if (__context_tag == to_underlying(Fields::kState))
189	0	{
190	0	err = DataModel::Decode(reader, state);
191	0	}
192	0	else if (__context_tag == to_underlying(Fields::kReason))
193	0	{
194	0	err = DataModel::Decode(reader, reason);
195	0	}
196	0	else if (__context_tag == to_underlying(Fields::kEnergyTransferred))
197	0	{
198	0	err = DataModel::Decode(reader, energyTransferred);
199	0	}
200	0	else if (__context_tag == to_underlying(Fields::kEnergyDischarged))
201	0	{
202	0	err = DataModel::Decode(reader, energyDischarged);
203	0	}
204	0	else
205	0	{
206	0	}
207
208	0	ReturnErrorOnFailure(err);
209	0	}
210	0	}
211		} // namespace EnergyTransferStopped.
212		namespace Fault {
213		CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
214	0	{
215	0	TLV::TLVType outer;
216	0	ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
217	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSessionID), sessionID));
218	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kState), state));
219	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStatePreviousState), faultStatePreviousState));
220	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kFaultStateCurrentState), faultStateCurrentState));
221	0	return aWriter.EndContainer(outer);
222	0	}
223
224		CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
225	0	{
226	0	detail::StructDecodeIterator __iterator(reader);
227	0	while (true)
228	0	{
229	0	uint8_t __context_tag = 0;
230	0	CHIP_ERROR err = __iterator.Next(__context_tag);
231	0	VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
232	0	ReturnErrorOnFailure(err);
233
234	0	if (__context_tag == to_underlying(Fields::kSessionID))
235	0	{
236	0	err = DataModel::Decode(reader, sessionID);
237	0	}
238	0	else if (__context_tag == to_underlying(Fields::kState))
239	0	{
240	0	err = DataModel::Decode(reader, state);
241	0	}
242	0	else if (__context_tag == to_underlying(Fields::kFaultStatePreviousState))
243	0	{
244	0	err = DataModel::Decode(reader, faultStatePreviousState);
245	0	}
246	0	else if (__context_tag == to_underlying(Fields::kFaultStateCurrentState))
247	0	{
248	0	err = DataModel::Decode(reader, faultStateCurrentState);
249	0	}
250	0	else
251	0	{
252	0	}
253
254	0	ReturnErrorOnFailure(err);
255	0	}
256	0	}
257		} // namespace Fault.
258		namespace Rfid {
259		CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const
260	0	{
261	0	TLV::TLVType outer;
262	0	ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer));
263	0	ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kUid), uid));
264	0	return aWriter.EndContainer(outer);
265	0	}
266
267		CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader)
268	0	{
269	0	detail::StructDecodeIterator __iterator(reader);
270	0	while (true)
271	0	{
272	0	uint8_t __context_tag = 0;
273	0	CHIP_ERROR err = __iterator.Next(__context_tag);
274	0	VerifyOrReturnError(err != CHIP_ERROR_END_OF_TLV, CHIP_NO_ERROR);
275	0	ReturnErrorOnFailure(err);
276
277	0	if (__context_tag == to_underlying(Fields::kUid))
278	0	{
279	0	err = DataModel::Decode(reader, uid);
280	0	}
281	0	else
282	0	{
283	0	}
284
285	0	ReturnErrorOnFailure(err);
286	0	}
287	0	}
288		} // namespace Rfid.
289		} // namespace Events
290		} // namespace EnergyEvse
291		} // namespace Clusters
292		} // namespace app
293		} // namespace chip