Line data    Source code

       1              : /*
       2              :  *
       3              :  *    Copyright (c) 2020-2021 Project CHIP Authors
       4              :  *    All rights reserved.
       5              :  *
       6              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7              :  *    you may not use this file except in compliance with the License.
       8              :  *    You may obtain a copy of the License at
       9              :  *
      10              :  *        http://www.apache.org/licenses/LICENSE-2.0
      11              :  *
      12              :  *    Unless required by applicable law or agreed to in writing, software
      13              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15              :  *    See the License for the specific language governing permissions and
      16              :  *    limitations under the License.
      17              :  */
      18              : 
      19              : #pragma once
      20              : 
      21              : #include <app/data-model/Decode.h>
      22              : #include <app/data-model/Encode.h>
      23              : #include <app/data-model/FabricScoped.h>
      24              : #include <lib/core/TLV.h>
      25              : 
      26              : namespace chip {
      27              : namespace app {
      28              : namespace DataModel {
      29              : 
      30              : /*
      31              :  * Dedicated type for list<T> that is at its base, just a Span.
      32              :  *
      33              :  * Motivated by the need to create distinction between Lists that use Spans
      34              :  * vs. other data model types that use Spans (like octetstr). These have different
      35              :  * encodings. Consequently, there needs to be an actual C++ type distinction to ensure
      36              :  * correct specialization of the Encode/Decode methods.
      37              :  *
      38              :  */
      39              : template <typename T>
      40              : struct List : public Span<T>
      41              : {
      42              :     //
      43              :     // The following 'using' statements are needed to make visible
      44              :     // all constructors of the base class within this derived class,
      45              :     // as well as introduce functions in the base class into the
      46              :     // derived class.
      47              :     //
      48              :     // This is needed to make it seamless to initialize and interact with
      49              :     // List<T> instances as though they were just Spans.
      50              :     //
      51              :     using Span<T>::Span;
      52              : 
      53              :     // Inherited copy constructors are _not_ imported by the using statement
      54              :     // above, though, so we need to implement that ourselves.  This is templated
      55              :     // on the span's type to allow us to init a List<const Foo> from Span<Foo>.
      56              :     // Span's constructor handles the checks on the types for us.
      57              :     template <class U>
      58            0 :     constexpr List(const Span<U> & other) : Span<T>(other)
      59            0 :     {}
      60              : 
      61              :     template <size_t N>
      62              :     constexpr List & operator=(T (&databuf)[N])
      63              :     {
      64              :         Span<T>::operator=(databuf);
      65              :         return (*this);
      66              :     }
      67              : 
      68              :     //
      69              :     // A list is deemed fabric scoped if the type of its elements is as well.
      70              :     //
      71              :     static constexpr bool kIsFabricScoped = DataModel::IsFabricScoped<T>::value;
      72              : };
      73              : 
      74              : template <typename X>
      75            0 : inline CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag, List<X> list)
      76              : {
      77              :     TLV::TLVType type;
      78              : 
      79            0 :     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Array, type));
      80            0 :     for (auto & item : list)
      81              :     {
      82            0 :         ReturnErrorOnFailure(Encode(writer, TLV::AnonymousTag(), item));
      83              :     }
      84            0 :     ReturnErrorOnFailure(writer.EndContainer(type));
      85              : 
      86            0 :     return CHIP_NO_ERROR;
      87              : }
      88              : 
      89              : template <typename X, std::enable_if_t<DataModel::IsFabricScoped<X>::value, bool> = true>
      90              : inline CHIP_ERROR EncodeForWrite(TLV::TLVWriter & writer, TLV::Tag tag, List<X> list)
      91              : {
      92              :     TLV::TLVType type;
      93              : 
      94              :     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Array, type));
      95              :     for (auto & item : list)
      96              :     {
      97              :         ReturnErrorOnFailure(EncodeForWrite(writer, TLV::AnonymousTag(), item));
      98              :     }
      99              :     ReturnErrorOnFailure(writer.EndContainer(type));
     100              : 
     101              :     return CHIP_NO_ERROR;
     102              : }
     103              : 
     104              : template <typename X, std::enable_if_t<DataModel::IsFabricScoped<X>::value, bool> = true>
     105              : inline CHIP_ERROR EncodeForRead(TLV::TLVWriter & writer, TLV::Tag tag, FabricIndex accessingFabricIndex, List<X> list)
     106              : {
     107              :     TLV::TLVType type;
     108              : 
     109              :     ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Array, type));
     110              :     for (auto & item : list)
     111              :     {
     112              :         ReturnErrorOnFailure(EncodeForRead(writer, TLV::AnonymousTag(), accessingFabricIndex, item));
     113              :     }
     114              :     ReturnErrorOnFailure(writer.EndContainer(type));
     115              : 
     116              :     return CHIP_NO_ERROR;
     117              : }
     118              : 
     119              : } // namespace DataModel
     120              : } // namespace app
     121              : } // namespace chip