RepeatedField.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2020 Embedded AMS B.V. - All Rights Reserved
 *
 *  This file is part of Embedded Proto.
 *
 *  Embedded Proto is open source software: you can redistribute it and/or 
 *  modify it under the terms of the GNU General Public License as published 
 *  by the Free Software Foundation, version 3 of the license.
 *
 *  Embedded Proto  is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Embedded Proto. If not, see <https://www.gnu.org/licenses/>.
 *
 *  For commercial and closed source application please visit:
 *  <https://EmbeddedProto.com/license/>.
 *
 *  Embedded AMS B.V.
 *  Info:
 *    info at EmbeddedProto dot com
 *
 *  Postal address:
 *    Johan Huizingalaan 763a
 *    1066 VH, Amsterdam
 *    the Netherlands
 */
 
#ifndef _REPEATED_FIELD_H_
#define _REPEATED_FIELD_H_
 
#include "Fields.h"
#include "MessageInterface.h"
#include "MessageSizeCalculator.h"
#include "ReadBufferSection.h"
#include "FieldStringBytes.h"
#include "Errors.h"
 
#include <cstdint>
#include <type_traits>
 
 
namespace EmbeddedProto
{
 
  template<class DATA_TYPE>
  class RepeatedField : public Field
  {
    static_assert(std::is_base_of<::EmbeddedProto::Field, DATA_TYPE>::value, "A Field can only be used as template paramter.");
 
    static constexpr bool REPEATED_FIELD_IS_PACKED = 
          !(std::is_base_of<MessageInterface, DATA_TYPE>::value 
            || std::is_base_of<internal::BaseStringBytes, DATA_TYPE>::value);
 
    public:
 
      RepeatedField() = default;
      virtual ~RepeatedField() = default;
 
      virtual uint32_t get_length() const = 0;
 
      virtual uint32_t get_max_length() const = 0;
      
      virtual uint32_t get_size() const = 0;
 
      virtual uint32_t get_max_size() const = 0;
 
 
      virtual DATA_TYPE& get(uint32_t index) = 0;
 
 
      virtual const DATA_TYPE& get_const(uint32_t index) const = 0;
 
 
      DATA_TYPE& operator[](uint32_t index) { return this->get(index); }
 
 
      const DATA_TYPE& operator[](uint32_t index) const { return this->get_const(index); }
 
 
      virtual void set(uint32_t index, const DATA_TYPE& value) = 0;
 
 
      virtual Error set_data(const DATA_TYPE* data, const uint32_t length) = 0;
 
 
      virtual Error add(const DATA_TYPE& value) = 0;
 
      virtual void clear() = 0;
 
      Error serialize(WriteBufferInterface& buffer) const
      {
        // This function should not be called on a repeated field.
        return Error::BUFFER_FULL;
      };
 
      Error serialize_with_id(uint32_t field_number, WriteBufferInterface& buffer) const final
      {
        Error return_value = Error::NO_ERRORS;
 
        if(REPEATED_FIELD_IS_PACKED)
        {
          const uint32_t size_x = this->serialized_size_packed(field_number);
 
          // Use the packed way of serialization for base fields.
          if(size_x <= buffer.get_available_size())
          {
            if(0 < size_x)
            {          
              uint32_t tag = WireFormatter::MakeTag(field_number, 
                                          WireFormatter::WireType::LENGTH_DELIMITED);
              return_value = WireFormatter::SerializeVarint(tag, buffer);
              if(Error::NO_ERRORS == return_value) 
              {
                return_value = WireFormatter::SerializeVarint(size_x, buffer);
                if(Error::NO_ERRORS == return_value) 
                {
                  return_value = serialize_packed(buffer);
                }
              }
            }
          }
          else
          {
            return_value = Error::BUFFER_FULL;
          }
        }
        else 
        {
          const uint32_t size_x = this->serialized_size_unpacked(field_number);
          if(size_x <= buffer.get_available_size()) 
          {
            return_value = serialize_unpacked(field_number, buffer);
          }
          else 
          {
            return_value = Error::BUFFER_FULL;
          }
        }
 
        return return_value;
      }
 
 
      Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) final
      {
        Error return_value = Error::NO_ERRORS;
        if(REPEATED_FIELD_IS_PACKED)
        {              
          return_value = deserialize_packed(buffer);
        }
        else 
        {
          return_value = deserialize_unpacked(buffer);
        }
        return return_value;
      }
 
 
      uint32_t serialized_size_packed(int32_t field_number) const 
      {
        ::EmbeddedProto::MessageSizeCalculator calcBuffer;
        serialize_packed(calcBuffer);
        return calcBuffer.get_size();
      }
 
 
      uint32_t serialized_size_unpacked(int32_t field_number) const 
      {
        ::EmbeddedProto::MessageSizeCalculator calcBuffer;
        serialize_unpacked(field_number, calcBuffer);
        return calcBuffer.get_size();
      }
 
    private:
 
      Error serialize_packed(WriteBufferInterface& buffer) const
      {
        Error return_value = Error::NO_ERRORS;
        for(uint32_t i = 0; (i < this->get_length()) && (Error::NO_ERRORS == return_value); ++i)
        {
          return_value = this->get_const(i).serialize(buffer);
        }
        return return_value;
      }
 
      Error serialize_unpacked(uint32_t field_number, WriteBufferInterface& buffer) const
      {
        Error return_value = Error::NO_ERRORS;
        for(uint32_t i = 0; (i < this->get_length()) && (Error::NO_ERRORS == return_value); ++i)
        {
          const uint32_t size_x = this->get_const(i).serialized_size();
          uint32_t tag = WireFormatter::MakeTag(field_number, 
                                    WireFormatter::WireType::LENGTH_DELIMITED);
          return_value = WireFormatter::SerializeVarint(tag, buffer);
          if(Error::NO_ERRORS == return_value)
          {
            return_value = WireFormatter::SerializeVarint(size_x, buffer);
            if((Error::NO_ERRORS == return_value) && (0 < size_x)) 
            {
              return_value = this->get_const(i).serialize(buffer);
            }
          }
        }
        return return_value;
      }
 
      Error deserialize_packed(ReadBufferInterface& buffer)
      {
        uint32_t size;
        Error return_value = WireFormatter::DeserializeVarint(buffer, size);
        ReadBufferSection bufferSection(buffer, size);
        DATA_TYPE x;
        
        return_value = x.deserialize(bufferSection);
        while(Error::NO_ERRORS == return_value)
        {
          return_value = this->add(x);
          if(Error::NO_ERRORS == return_value)
          {
            return_value = x.deserialize(bufferSection);
          }
        }
 
        // We expect the buffersection to be empty, in that case everything is fine..
        if(Error::END_OF_BUFFER == return_value)
        {
          return_value = Error::NO_ERRORS;
        }
 
        return return_value;
      }
 
      Error deserialize_unpacked(ReadBufferInterface& buffer)
      {
        Error return_value = Error::NO_ERRORS;
 
        // For repeated messages, strings or bytes
        // First allocate an element in the array.
        const uint32_t index = this->get_length();
        if(this->get_max_length() > index)
        {
          // For messages read the size here, with strings and byte arrays this is include in 
          // deserialize.
          if(std::is_base_of<MessageInterface, DATA_TYPE>::value)
          {
            uint32_t size;
            return_value = WireFormatter::DeserializeVarint(buffer, size);
            if(Error::NO_ERRORS == return_value) 
            {
              ReadBufferSection bufferSection(buffer, size);
              return_value = this->get(index).deserialize(bufferSection);
            }
          }
          else 
          {
            return_value = this->get(index).deserialize(buffer);
          }
        }
        else 
        {
          return_value = Error::ARRAY_FULL;
        }
 
        return return_value;
      }
 
  };
 
 
} // End of namespace EmbeddedProto
 
#endif // End of _REPEATED_FIELD_H_