ArrayVariant.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (C) 2014 by Ralf Kaestner                                        *
 * ralf.kaestner@gmail.com                                                    *
 *                                                                            *
 * This program is free software; you can redistribute it and/or modify       *
 * it under the terms of the Lesser GNU General Public License as published by*
 * the Free Software Foundation; either version 3 of the License, or          *
 * (at your option) any later version.                                        *
 *                                                                            *
 * This program 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               *
 * Lesser GNU General Public License for more details.                        *
 *                                                                            *
 * You should have received a copy of the Lesser GNU General Public License   *
 * along with this program. If not, see <http://www.gnu.org/licenses/>.       *
 ******************************************************************************/

#ifndef VARIANT_TOPIC_TOOLS_ARRAY_VARIANT_H
#define VARIANT_TOPIC_TOOLS_ARRAY_VARIANT_H

#include <vector>

#include <variant_topic_tools/ArrayTypeTraits.h>
#include <variant_topic_tools/CollectionVariant.h>

namespace variant_topic_tools {
  class ArrayVariant :
    public CollectionVariant {
  friend class ArrayDataType;
  friend class Variant;
  public:
    ArrayVariant();

    ArrayVariant(const ArrayVariant& src);

    ArrayVariant(const Variant& src);

    ~ArrayVariant();

    void addMember(const Variant& member);

    void resize(size_t numMembers);

    void clear();

    ArrayVariant& operator+=(const Variant& member);

    using Variant::operator=;

  protected:
    class Value :
      public CollectionVariant::Value {
    public:
      Value();

      virtual ~Value();

      void setValue(const Variant::Value& value);

      void setMember(const std::string& name, const Variant& member);

      using CollectionVariant::Value::setMember;

      Variant getMember(const std::string& name) const;

      using CollectionVariant::Value::getMember;

      bool hasMember(const std::string& name) const;

      void writeMember(std::ostream& stream, int index) const;

      virtual void addMember(const Variant& member) = 0;

      virtual void resize(size_t numMembers) = 0;

      virtual void clear() = 0;
    };

    class ValueImplV :
      public Value {
    public:
      ValueImplV(const DataType& memberType = DataType(), size_t
        numMembers = 0);

      ValueImplV(const ValueImplV& src);

      virtual ~ValueImplV();

      size_t getNumMembers() const;

      void setMember(int index, const Variant& member);

      Variant getMember(int index) const;

      void addMember(const Variant& member);

      void resize(size_t numMembers);

      void clear();

      ValuePtr clone() const;

      Serializer createSerializer(const DataType& type) const;

      DataType memberType;

      size_t numMembers;

      std::vector<Variant> members;
    };

    template <typename T> class ValueImplT :
      public Variant::ValueT<typename type_traits::ArrayType<T>::ValueType>,
      public Value {
    public:
      BOOST_STATIC_ASSERT(type_traits::IsArray<T>::value);

      typedef typename type_traits::ArrayType<T>::ValueType ValueType;

      typedef typename type_traits::ArrayType<T>::MemberType MemberType;

      static const size_t NumMembers = type_traits::ArrayType<T>::NumMembers;

      ValueImplT(const DataType& memberType = DataType(), const
        Pointer<ValueType>& array = Pointer<ValueType>());

      ValueImplT(const ValueImplT<T>& src);

      virtual ~ValueImplT();

      void set(const Pointer<ValueType>& value);

      ValueType& getValue();

      const ValueType& getValue() const;

      size_t getNumMembers() const;

      void setMember(int index, const Variant& member);

      Variant getMember(int index) const;

      void addMember(const Variant& member);

      void resize(size_t numMembers);

      void clear();

      ValuePtr clone() const;

      Serializer createSerializer(const DataType& type) const;

      DataType memberType;

      mutable Pointer<ValueType> array;
    };

    ArrayVariant(const DataType& type, const DataType& memberType,
      size_t numMembers);

    template <typename T> static ArrayVariant create(const DataType& type,
      const DataType& memberType);

    template <typename T> static void initialize(typename type_traits::
      ArrayType<T>::ValueType& array, typename boost::enable_if<typename
      type_traits::ArrayType<T>::IsDynamic>::type* = 0);

    template <typename T> static void initialize(typename type_traits::
      ArrayType<T>::ValueType& array, typename boost::disable_if<typename
      type_traits::ArrayType<T>::IsDynamic>::type* = 0);

    template <typename T> static void add(typename type_traits::ArrayType<T>::
      ValueType& array, const typename type_traits::ArrayType<T>::MemberType&
      member, typename boost::enable_if<typename type_traits::ArrayType<T>::
      IsDynamic>::type* = 0);

    template <typename T> static void add(typename type_traits::ArrayType<T>::
      ValueType& array, const typename type_traits::ArrayType<T>::MemberType&
      member, typename boost::disable_if<typename type_traits::ArrayType<T>::
      IsDynamic>::type* = 0);

    template <typename T> static void resize(typename type_traits::
      ArrayType<T>::ValueType& array, size_t numMembers, typename
      boost::enable_if<typename type_traits::ArrayType<T>::IsDynamic>::
      type* = 0);

    template <typename T> static void resize(typename type_traits::
      ArrayType<T>::ValueType& array, size_t numMembers, typename
      boost::disable_if<typename type_traits::ArrayType<T>::IsDynamic>::
      type* = 0);

    template <typename T> static void clear(typename type_traits::
      ArrayType<T>::ValueType& array, typename boost::enable_if<typename
      type_traits::ArrayType<T>::IsDynamic>::type* = 0);

    template <typename T> static void clear(typename type_traits::
      ArrayType<T>::ValueType& array, typename boost::disable_if<typename
      type_traits::ArrayType<T>::IsDynamic>::type* = 0);
  };
};

#include <variant_topic_tools/ArrayVariant.tpp>

#endif