DataTypes.h

Go to the documentation of this file.

 
#include <string>
#include <vector>
 
#include <stdint.h>
#include <map>
#include <deque>
#include <list>
 
#include <boost/array.hpp>
#include <boost/tuple/tuple.hpp>
 
#include "RobotRaconteur/RobotRaconteurConstants.h"
#include "RobotRaconteur/Error.h"
 
#include <stdexcept>
 
#include "RobotRaconteur/RobotRaconteurConfig.h"
 
#ifdef ROBOTRACONTEUR_USE_SMALL_VECTOR
#include <boost/container/small_vector.hpp>
#endif
 
#include <boost/asio/buffer.hpp>
 
#include <boost/utility/value_init.hpp>
#include <boost/container/static_vector.hpp>
#include <boost/foreach.hpp>
#include <boost/range/adaptor/map.hpp>
#include <boost/range/numeric.hpp>
 
#include <boost/smart_ptr/intrusive_ref_counter.hpp>
 
#include <boost/numeric/conversion/cast.hpp>
 
#include <boost/lexical_cast.hpp>
 
#include <boost/utility/string_ref.hpp>
 
#include <boost/variant.hpp>
 
#include <boost/date_time/posix_time/ptime.hpp>
#include "boost/date_time/posix_time/posix_time_types.hpp"
 
#pragma once
 
namespace RobotRaconteur
{
struct ROBOTRACONTEUR_CORE_API cdouble
{
    double real;
    double imag;
    cdouble() : real(0.0), imag(0.0) {}
    cdouble(double r, double i) : real(r), imag(i) {}
};

struct ROBOTRACONTEUR_CORE_API cfloat
{
    float real;
    float imag;
    cfloat() : real(0.0), imag(0.0) {}
    cfloat(float r, float i) : real(r), imag(i) {}
};

struct ROBOTRACONTEUR_CORE_API rr_bool
{
    uint8_t value;

    rr_bool() : value(0) {}
    rr_bool(uint8_t b) : value(b) {}
};
 
ROBOTRACONTEUR_CORE_API bool operator==(const cdouble& c1, const cdouble& c2);
ROBOTRACONTEUR_CORE_API bool operator!=(const cdouble& c1, const cdouble& c2);
ROBOTRACONTEUR_CORE_API bool operator==(const cfloat& c1, const cfloat& c2);
ROBOTRACONTEUR_CORE_API bool operator!=(const cfloat& c1, const cfloat& c2);
ROBOTRACONTEUR_CORE_API bool operator==(const rr_bool& c1, const rr_bool& c2);
ROBOTRACONTEUR_CORE_API bool operator!=(const rr_bool& c1, const rr_bool& c2);
 
template <typename T, typename U>
class rr_cast_support
{
  public:
    static RR_SHARED_PTR<T> rr_cast(const RR_SHARED_PTR<U>& objin)
    {
        if (!objin)
            return RR_SHARED_PTR<T>();
 
        RR_SHARED_PTR<T> c = RR_DYNAMIC_POINTER_CAST<T>(objin);
        if (!c)
        {
            throw DataTypeMismatchException("Data type cast error");
        }
 
        return c;
    }
 
    static RR_INTRUSIVE_PTR<T> rr_cast(const RR_INTRUSIVE_PTR<U>& objin)
    {
        if (!objin)
            return RR_INTRUSIVE_PTR<T>();
 
        RR_INTRUSIVE_PTR<T> c = RR_DYNAMIC_POINTER_CAST<T>(objin);
        if (!c)
        {
            throw DataTypeMismatchException("Data type cast error");
        }
 
        return c;
    }
};
 
template <typename T>
class rr_cast_support<T, T>
{
  public:
    static const RR_SHARED_PTR<T>& rr_cast(const RR_SHARED_PTR<T>& objin) { return objin; }
 
    static const RR_INTRUSIVE_PTR<T>& rr_cast(const RR_INTRUSIVE_PTR<T>& objin) { return objin; }
};

template <typename T, typename U>
static RR_SHARED_PTR<T> rr_cast(const RR_SHARED_PTR<U>& objin)
{
    return rr_cast_support<T, U>::rr_cast(objin);
}

template <typename T, typename U>
static RR_INTRUSIVE_PTR<T> rr_cast(const RR_INTRUSIVE_PTR<U>& objin)
{
    return rr_cast_support<T, U>::rr_cast(objin);
}

class ROBOTRACONTEUR_CORE_API RRObject : boost::noncopyable
{
  public:
    RRObject();
 
    virtual ~RRObject() {}

    virtual std::string RRType() = 0;
};

class ROBOTRACONTEUR_CORE_API RRValue : public boost::intrusive_ref_counter<RRValue>, boost::noncopyable
{
  public:
    RRValue();
 
    virtual ~RRValue() {}
 
    virtual std::string RRType() = 0;
};
 
namespace detail
{
class ROBOTRACONTEUR_CORE_API MessageStringData
{
  public:
    std::string str;
};
 
class ROBOTRACONTEUR_CORE_API MessageStringData_string_ref
{
  public:
    boost::string_ref ref;
    MessageStringData_string_ref(const boost::string_ref& r) : ref(r) {}
};
class ROBOTRACONTEUR_CORE_API MessageStringData_static_string
{
  public:
    boost::string_ref ref;
    MessageStringData_static_string(const boost::string_ref& r) : ref(r) {}
};
 
} // namespace detail
 
class ROBOTRACONTEUR_CORE_API MessageStringRef;
 
class ROBOTRACONTEUR_CORE_API MessageStringPtr
{
  private:
    boost::variant<detail::MessageStringData, detail::MessageStringData_static_string> _str_ptr;
 
  public:
    friend class MessageStringRef;
 
    MessageStringPtr();
 
    MessageStringPtr(const std::string& str);
    MessageStringPtr(boost::string_ref str, bool is_static = false);
    MessageStringPtr(const MessageStringPtr& str_ptr);
    MessageStringPtr(const MessageStringRef& str_ref);
#ifndef ROBOTRACONTEUR_NO_CXX11
    MessageStringPtr(std::string&& str);
#endif
    // WARNING: ONLY USE WITH STRING LITERALS OR STATIC STRINGS!
    template <size_t N>
    inline MessageStringPtr(const char (&str)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays)
    {
        init_literal(str, strlen(str));
    }
 
    boost::string_ref str() const;
    void reset();
 
    bool operator==(MessageStringRef b) const;
    bool operator!=(MessageStringRef b) const;
    bool operator<(MessageStringRef b) const;
 
  private:
    void init_literal(const char* str, size_t len);
};
 
class ROBOTRACONTEUR_CORE_API MessageStringRef
{
  private:
    boost::variant<const detail::MessageStringData*, detail::MessageStringData_static_string,
                   detail::MessageStringData_string_ref>
        _str;
 
  public:
    friend class MessageStringPtr;
 
    MessageStringRef(const std::string& str);
    MessageStringRef(boost::string_ref str, bool is_static = false);
    MessageStringRef(const MessageStringPtr& str_ptr);
    MessageStringRef(const MessageStringRef& str_ref);
 
    // WARNING: ONLY USE WITH STRING LITERALS OR STATIC STRINGS!
    template <size_t N>
    inline MessageStringRef(const char (&str)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays)
    {
        init_literal(str, strlen(str));
    }
 
    bool operator==(MessageStringRef b) const;
    bool operator!=(MessageStringRef b) const;
 
    boost::string_ref str() const;
 
  private:
    void init_literal(const char* str, size_t len);
};
 
std::size_t hash_value(const RobotRaconteur::MessageStringPtr& k);
 
ROBOTRACONTEUR_CORE_API std::ostream& operator<<(std::ostream& out, const MessageStringPtr& str);
ROBOTRACONTEUR_CORE_API std::ostream& operator<<(std::ostream& out, const MessageStringRef& str);
 
// boost::string_ref operations
inline boost::iterator_range<boost::string_ref::const_iterator> to_range(const boost::string_ref& str)
{
    return boost::iterator_range<boost::string_ref::const_iterator>(str.cbegin(), str.cend());
}
 
inline std::string operator+(const char* lhs, boost::string_ref rhs) { return lhs + rhs.to_string(); }
 
inline std::string operator+(const std::string& lhs, boost::string_ref rhs) { return lhs + rhs.to_string(); }
 
inline std::string operator+(boost::string_ref lhs, const char* rhs) { return lhs.to_string() + rhs; }

class ROBOTRACONTEUR_CORE_API MessageElementData : public RRValue
{
  public:
    virtual MessageStringPtr GetTypeString() = 0;
    virtual DataTypes GetTypeID() = 0;
};
 
template <typename T>
class RRArray;

template <typename T>
static RR_INTRUSIVE_PTR<RRArray<T> > ScalarToRRArray(T value);

template <typename T>
static T RRArrayToScalar(const RR_INTRUSIVE_PTR<RRArray<T> >& value);

ROBOTRACONTEUR_CORE_API RR_INTRUSIVE_PTR<RRArray<char> > stringToRRArray(boost::string_ref str);

ROBOTRACONTEUR_CORE_API std::string RRArrayToString(const RR_INTRUSIVE_PTR<RRArray<char> >& arr);
 
template <typename T>
class RRPrimUtil
{
  public:
    static DataTypes GetTypeID() { return DataTypes_void_t; }
 
    static RR_INTRUSIVE_PTR<T> PrePack(const T& val) { return val; }
 
    template <typename U>
    static T PreUnpack(U& val)
    {
        return rr_cast<T>(val);
    }
 
    virtual ~RRPrimUtil(){};
 
    typedef RR_INTRUSIVE_PTR<RRValue> BoxedType;
};
 
template <typename T>
class RRPrimUtil<RR_INTRUSIVE_PTR<T> >
{
  public:
    static DataTypes GetTypeID() { return DataTypes_void_t; }
    static MessageStringPtr GetElementTypeString() { return MessageStringPtr(""); }
 
    static boost::string_ref GetRRElementTypeString() { return ""; }
 
    static RR_INTRUSIVE_PTR<RRValue> PrePack(const RR_INTRUSIVE_PTR<T>& val) { return rr_cast<RRValue>(val); }
 
    template <typename U>
    static RR_INTRUSIVE_PTR<T> PreUnpack(const U& val)
    {
        return rr_cast<T>(val);
    }
 
    virtual ~RRPrimUtil(){};
 
    typedef RR_INTRUSIVE_PTR<T> BoxedType;
};
 
template <>
class RRPrimUtil<std::string>
{
  public:
    static DataTypes GetTypeID() { return DataTypes_string_t; }
    static MessageStringPtr GetElementTypeString() { return MessageStringPtr(""); }
    static boost::string_ref GetRRElementTypeString() { return ""; }
    static RR_INTRUSIVE_PTR<RRValue> PrePack(boost::string_ref val) { return rr_cast<RRValue>(stringToRRArray(val)); }
    static std::string PreUnpack(const RR_INTRUSIVE_PTR<RRValue>& val)
    {
        return RRArrayToString(rr_cast<RRArray<char> >(val));
    }
 
    virtual ~RRPrimUtil(){};
 
    typedef RR_INTRUSIVE_PTR<RRArray<char> > BoxedType;
};
 
#define RRPrimUtilNumeric(x, code)                                                                                     \
    template <>                                                                                                        \
    class RRPrimUtil<x>                                                                                                \
    {                                                                                                                  \
      public:                                                                                                          \
        static DataTypes GetTypeID() { return code; }                                                                  \
        static MessageStringPtr GetElementTypeString() { return MessageStringPtr(""); }                                \
        static boost::string_ref GetRRElementTypeString() { return ""; }                                               \
        static RR_INTRUSIVE_PTR<RRArray<x> > PrePack(const x& val) { return ScalarToRRArray(val); }                    \
        template <typename U>                                                                                          \
        static x PreUnpack(const U& val)                                                                               \
        {                                                                                                              \
            return RRArrayToScalar(rr_cast<RRArray<x> >(val));                                                         \
        }                                                                                                              \
        typedef RR_INTRUSIVE_PTR<RRArray<x> > BoxedType;                                                               \
    };
 
RRPrimUtilNumeric(double, DataTypes_double_t);
RRPrimUtilNumeric(float, DataTypes_single_t);
 
RRPrimUtilNumeric(int8_t, DataTypes_int8_t);
RRPrimUtilNumeric(uint8_t, DataTypes_uint8_t);
RRPrimUtilNumeric(int16_t, DataTypes_int16_t);
RRPrimUtilNumeric(uint16_t, DataTypes_uint16_t);
RRPrimUtilNumeric(int32_t, DataTypes_int32_t);
RRPrimUtilNumeric(uint32_t, DataTypes_uint32_t);
RRPrimUtilNumeric(int64_t, DataTypes_int64_t);
RRPrimUtilNumeric(uint64_t, DataTypes_uint64_t);
RRPrimUtilNumeric(char, DataTypes_string_t);
RRPrimUtilNumeric(cdouble, DataTypes_cdouble_t);
RRPrimUtilNumeric(cfloat, DataTypes_csingle_t);
RRPrimUtilNumeric(rr_bool, DataTypes_bool_t);
 
ROBOTRACONTEUR_CORE_API std::string GetRRDataTypeString(DataTypes type);
ROBOTRACONTEUR_CORE_API bool IsTypeRRArray(DataTypes type);
ROBOTRACONTEUR_CORE_API bool IsTypeNumeric(DataTypes type);

class ROBOTRACONTEUR_CORE_API RRBaseArray : public MessageElementData
{
  public:
    RR_OVIRTUAL MessageStringPtr GetTypeString() RR_OVERRIDE
    {
        std::string type = GetRRDataTypeString(GetTypeID());
        return type + "[]";
    }
 
    RR_OVIRTUAL ~RRBaseArray() RR_OVERRIDE {}

    virtual size_t size() = 0;
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE;

    virtual void* void_ptr() = 0;

    virtual size_t ElementSize() = 0;
};

template <typename T>
class RRArray : public RRBaseArray
{
  public:
    RR_OVIRTUAL DataTypes GetTypeID() RR_OVERRIDE { return RRPrimUtil<T>::GetTypeID(); }
 
    RRArray(T* data, size_t length, bool owned) : data_(data), element_count(length), owned(owned) {}
 
    RR_OVIRTUAL ~RRArray() RR_OVERRIDE
    {
        if (owned)
            delete[] data_;
    }
 
    RR_OVIRTUAL void* void_ptr() RR_OVERRIDE { return data(); }
 
    T* operator->() const { return data; }
 
    RR_OVIRTUAL size_t size() RR_OVERRIDE { return element_count; }
 
    RR_OVIRTUAL size_t ElementSize() RR_OVERRIDE { return sizeof(T); }
 
    // C++ container support functions based on boost::array
 
    // type definitions
    typedef T value_type;
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef T& reference;
    typedef const T& const_reference;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
 
    // iterator support

    iterator begin() { return data_; }
    const_iterator begin() const { return data_; }
    const_iterator cbegin() const { return data_; }

    iterator end() { return data_ + element_count; }
    const_iterator end() const { return data_ + element_count; }
    const_iterator cend() const { return data_ + element_count; }

    typedef boost::reverse_iterator<iterator> reverse_iterator;
    typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;

    reverse_iterator rbegin() { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }

    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }

    reference operator[](size_type i)
    {
        BOOST_ASSERT_MSG(i < element_count, "out of range");
        return data_[i];
    }

    const_reference operator[](size_type i) const
    {
        BOOST_ASSERT_MSG(i < element_count, "out of range");
        return data_[i];
    }

    reference at(size_type i)
    {
        rangecheck(i);
        return data_[i];
    }

    const_reference at(size_type i) const
    {
        rangecheck(i);
        return data_[i];
    }

    reference front() { return data_[0]; }

    const_reference front() const { return data_[0]; }

    reference back() { return data_[element_count - 1]; }

    const_reference back() const { return data_[element_count - 1]; }

    bool empty() { return false; }
    size_type max_size() { return element_count; }

    const T* data() const { return data_; }
    T* data() { return data_; }
 
    T* c_array() { return data_; }

    template <typename T2>
    RRArray<T>& operator=(const RRArray<T2>& rhs)
    {
        std::copy(rhs.begin(), rhs.end(), begin());
        return *this;
    }

    void assign(const T& value) { fill(value); }
    void fill(const T& value) { std::fill_n(begin(), size(), value); }
 
    void rangecheck(size_type i)
    {
        if (i >= size())
        {
            std::out_of_range e("array<>: index out of range");
            boost::throw_exception(e);
        }
    }
 
  private:
    T* data_;
    size_t element_count;
    bool owned;
};
 
template <typename T>
class RRMap_keytype
{
  public:
    static boost::string_ref get()
    {
        BOOST_STATIC_ASSERT_MSG(sizeof(T) == 0, "Invalid key type for Robot Raconteur map");
        throw DataTypeException("Unknown data type");
    }
 
    static std::string get_map_rrtype()
    {
        BOOST_STATIC_ASSERT_MSG(sizeof(T) == 0, "Invalid key type for Robot Raconteur map");
        throw DataTypeException("Unknown data type");
    }
};
 
template <>
class RRMap_keytype<int32_t>
{
  public:
    static boost::string_ref get() { return "int32_t"; }
 
    static std::string get_map_rrtype() { return "RobotRaconteur.RRMap<int32_t>"; }
};
 
template <>
class RRMap_keytype<std::string>
{
  public:
    static boost::string_ref get() { return "string"; }
 
    static std::string get_map_rrtype() { return "RobotRaconteur.RRMap<string>"; }
};

template <typename K, typename T>
class RRMap : public RRValue
{
  protected:
    std::map<K, RR_INTRUSIVE_PTR<T> > map;
 
  public:
    RRMap() {}
 
    RRMap(const std::map<K, RR_INTRUSIVE_PTR<T> >& mapin) : map(mapin) {}
 
    RR_OVIRTUAL ~RRMap() RR_OVERRIDE {}
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE { return RRMap_keytype<K>::get_map_rrtype(); }
 
    // C++ container support based on boost::container::map

    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::key_type key_type;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::mapped_type mapped_type;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::value_type value_type;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::pointer pointer;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::const_pointer const_pointer;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::reference reference;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::const_reference const_reference;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::size_type size_type;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::iterator iterator;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::const_iterator const_iterator;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::reverse_iterator reverse_iterator;
    typedef typename std::map<K, RR_INTRUSIVE_PTR<T> >::const_reverse_iterator const_reverse_iterator;

    iterator begin() { return map.begin(); }
    const_iterator cbegin() const { return map.cbegin(); }
    const_iterator begin() const { return map.begin(); }
    iterator end() { return map.end(); }
    const_iterator cend() const { return map.end(); }
    const_iterator end() const { return map.end(); }
    reverse_iterator rbegin() { return map.rbegin(); };
    const_reverse_iterator crbegin() const { return map.crbegin(); };
    const_reverse_iterator rbegin() const { return map.rbegin(); };
    reverse_iterator rend() { return map.rend(); }
    const_reverse_iterator crend() const { return map.rend(); }
    const_reverse_iterator rend() const { return map.rend(); }
    bool empty() const { return map.empty(); }
    size_type size() const { return map.size(); }
    size_type max_size() const { return map.max_size(); };
    mapped_type& operator[](const key_type& k) { return map[k]; }
    mapped_type& at(const key_type& k) { return map.at(k); }
    const mapped_type& at(const key_type& k) const { return map.at(k); }
    std::pair<iterator, bool> insert(const value_type& x) { return map.insert(x); }
    iterator insert(const_iterator p, const value_type& x)
    {
        RR_UNUSED(p);
        return map.insert(x);
    }

    template <class InputIterator>
    void insert(InputIterator first, InputIterator last)
    {
        map.insert(first, last);
    }

    void erase(iterator p) { map.erase(p); }
    size_type erase(const key_type& x) { return map.erase(x); }
    void erase(iterator first, iterator last) { map.erase(first, last); }
    void clear() { map.clear(); }
    iterator find(const key_type& x) { return map.find(x); }
    const_iterator find(const key_type& x) const { return map.find(x); }
    size_type count(const key_type& x) const { return map.count(x); }

    typename std::map<K, RR_INTRUSIVE_PTR<T> >& GetStorageContainer() { return map; }
};

template <typename T>
class RRList : public RRValue
{
  protected:
    std::list<RR_INTRUSIVE_PTR<T> > list;
 
  public:
    RRList() {}
 
    RRList(std::list<RR_INTRUSIVE_PTR<T> > listin) { list = listin; }
 
    RR_OVIRTUAL ~RRList() RR_OVERRIDE {}
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE { return "RobotRaconteur.RRList"; }
 
    // C++ container support based on boost::container::list

    typedef RR_INTRUSIVE_PTR<T> value_type;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::pointer pointer;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::const_pointer const_pointer;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::reference reference;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::const_reference const_reference;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::size_type size_type;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::difference_type difference_type;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::iterator iterator;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::const_iterator const_iterator;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::reverse_iterator reverse_iterator;
    typedef typename std::list<RR_INTRUSIVE_PTR<T> >::const_reverse_iterator const_reverse_iterator;

    iterator begin() { return list.begin(); }
    const_iterator begin() const { return list.begin(); }
    iterator end() { return list.end(); }
    const_iterator end() const { return list.end(); }
    reverse_iterator rbegin() { return list.rbegin(); }
    const_reverse_iterator rbegin() const { return list.rbegin(); }
    reverse_iterator rend() { return list.rend(); }
    const_reverse_iterator crend() const { return list.crend(); }
    const_reverse_iterator rend() const { return list.rend(); }
    const_iterator cbegin() const { return list.cbegin(); }
    const_iterator cend() const { return list.cend(); }
    const_reverse_iterator const crbegin() { return list.crbegin(); }
    const_reverse_iterator const crend() { return list.crend(); }
    bool empty() const { return list.empty(); }
    virtual size_type size() const { return list.size(); }
    size_type max_size() const { return list.max_size(); }
    reference front() { return list.front(); }
    const_reference front() const { return list.front(); }
    reference back() { return list.back(); }
    const_reference back() const { return list.back(); }
    void push_front(const RR_INTRUSIVE_PTR<T>& x) { list.push_front(x); }
    void push_back(const RR_INTRUSIVE_PTR<T>& x) { list.push_back(x); }
    void pop_front() { list.pop_front(); }
    void pop_back() { list.pop_back(); }
    iterator insert(const_iterator p, const RR_INTRUSIVE_PTR<T>& x) { list.insert(p, x); }
    iterator erase(const_iterator p) { list.erase(p); }
    iterator erase(const_iterator first, const_iterator last) { list.erase(first, last); }
    void clear() { list.clear(); }
    void remove(const RR_INTRUSIVE_PTR<T>& value) { list.remove(value); }

    typename std::list<RR_INTRUSIVE_PTR<T> >& GetStorageContainer() { return list; }
};

class ROBOTRACONTEUR_CORE_API RRStructure : public RRValue
{
  public:
    RR_OVIRTUAL ~RRStructure() RR_OVERRIDE {}
};

template <typename T>
static RR_INTRUSIVE_PTR<RRArray<T> > AllocateRRArray(size_t length)
{
    return RR_INTRUSIVE_PTR<RRArray<T> >(new RRArray<T>(new T[length], length, true));
}

template <typename T>
static RR_INTRUSIVE_PTR<RRArray<T> > AttachRRArray(T* data, size_t length, bool owned)
{
    return RR_INTRUSIVE_PTR<RRArray<T> >(new RRArray<T>(data, length, owned));
}

template <typename T>
static RR_INTRUSIVE_PTR<RRArray<T> > AttachRRArrayCopy(const T* data, const size_t length)
{
    RR_INTRUSIVE_PTR<RRArray<T> > ret(new RRArray<T>(new T[length], length, true));
    memcpy(ret->void_ptr(), data, length * sizeof(T));
    return ret;
}

ROBOTRACONTEUR_CORE_API RR_INTRUSIVE_PTR<RRBaseArray> AllocateRRArrayByType(DataTypes type, size_t length);

template <typename T>
static RR_INTRUSIVE_PTR<RRArray<T> > AllocateEmptyRRArray(size_t length)
{
    RR_INTRUSIVE_PTR<RRArray<T> > o = AllocateRRArray<T>(length);
    if (length > 0)
    {
        memset(static_cast<void*>(o->data()), 0, length * sizeof(T));
    }
    return o;
}

ROBOTRACONTEUR_CORE_API size_t RRArrayElementSize(DataTypes type);

template <typename T>
static RR_INTRUSIVE_PTR<RRArray<T> > ScalarToRRArray(T value)
{
    return AttachRRArrayCopy(&value, 1);
}

template <typename T>
static T RRArrayToScalar(const RR_INTRUSIVE_PTR<RRArray<T> >& value)
{
    if (!value)
    {
        throw NullValueException("Null pointer");
    }
 
    if (value->size() == 0)
        throw OutOfRangeException("Index out of range");
 
    return (*value)[0];
}

template <typename Y, typename U>
static std::vector<Y> RRArrayToVector(const RR_INTRUSIVE_PTR<RRArray<U> >& in)
{
    if (!in)
        throw NullValueException("Unexpected null array");
    std::vector<Y> out(in->size());
    for (size_t i = 0; i < in->size(); i++)
        out[i] = boost::numeric_cast<Y>((*in)[i]);
    return out;
}

template <typename Y, typename U>
static RR_INTRUSIVE_PTR<RRArray<Y> > VectorToRRArray(const std::vector<U>& in)
{
    RR_INTRUSIVE_PTR<RRArray<Y> > out = AllocateRRArray<Y>(in.size());
    for (size_t i = 0; i < in.size(); i++)
        (*out)[i] = boost::numeric_cast<Y>(in[i]);
    return out;
}

template <typename Y, std::size_t N, typename U>
static boost::array<Y, N> RRArrayToArray(const RR_INTRUSIVE_PTR<RRArray<U> >& in)
{
    if (!in)
        throw NullValueException("Unexpected null array");
    if (in->size() != N)
        throw OutOfRangeException("Array is incorrect size");
    boost::array<Y, N> out = {};
    for (size_t i = 0; i < N; i++)
        out[i] = boost::numeric_cast<Y>((*in)[i]);
    return out;
}

template <typename Y, std::size_t N, typename U>
static void RRArrayToArray(boost::array<Y, N>& out, const RR_INTRUSIVE_PTR<RRArray<U> >& in)
{
    if (!in)
        throw NullValueException("Unexpected null array");
    if (in->size() != N)
        throw OutOfRangeException("Array is incorrect size");
    for (size_t i = 0; i < N; i++)
        out[i] = boost::numeric_cast<Y>((*in)[i]);
}

template <typename Y, typename U, std::size_t N>
static RR_INTRUSIVE_PTR<RRArray<Y> > ArrayToRRArray(boost::array<U, N> in)
{
    RR_INTRUSIVE_PTR<RRArray<Y> > out = AllocateRRArray<Y>(N);
    for (size_t i = 0; i < N; i++)
        (*out)[i] = boost::numeric_cast<Y>(in[i]);
    return out;
}

template <typename Y, std::size_t N, typename U>
static boost::container::static_vector<Y, N> RRArrayToStaticVector(const RR_INTRUSIVE_PTR<RRArray<U> >& in)
{
    if (!in)
        throw NullValueException("Unexpected null array");
    if (in->size() > N)
        throw OutOfRangeException("Array is too large for static vector size");
    boost::container::static_vector<Y, N> out(in->size());
    for (size_t i = 0; i < in->size(); i++)
        out[i] = boost::numeric_cast<Y>((*in)[i]);
    return out;
}

template <typename Y, std::size_t N, typename U>
static void RRArrayToStaticVector(boost::container::static_vector<Y, N>& out, const RR_INTRUSIVE_PTR<RRArray<U> >& in)
{
    if (!in)
        throw NullValueException("Unexpected null array");
    if (in->size() > N)
        throw OutOfRangeException("Array is too large for static vector size");
    out.resize(in->size());
    for (size_t i = 0; i < in->size(); i++)
        out[i] = boost::numeric_cast<Y>((*in)[i]);
}

template <typename Y, typename U, std::size_t N>
static RR_INTRUSIVE_PTR<RRArray<Y> > StaticVectorToRRArray(boost::container::static_vector<U, N> in)
{
    RR_INTRUSIVE_PTR<RRArray<Y> > out = AllocateRRArray<Y>(in.size());
    for (size_t i = 0; i < in.size(); i++)
        (*out)[i] = boost::numeric_cast<Y>(in[i]);
    return out;
}

ROBOTRACONTEUR_CORE_API RR_INTRUSIVE_PTR<RRList<RRArray<char> > > stringVectorToRRList(
    const std::vector<std::string>& string_vector);

ROBOTRACONTEUR_CORE_API std::vector<std::string> RRListToStringVector(
    const RR_INTRUSIVE_PTR<RRList<RRArray<char> > >& list);

template <typename T>
RR_INTRUSIVE_PTR<T>& rr_null_check(RR_INTRUSIVE_PTR<T>& ptr)
{
    if (!ptr)
    {
        throw NullValueException("Unexpected null value");
    }
    return ptr;
}

template <typename T>
RR_INTRUSIVE_PTR<T>& rr_null_check(RR_INTRUSIVE_PTR<T>& ptr, const char* msg)
{
    if (!ptr)
    {
        throw NullValueException(msg);
    }
    return ptr;
}

template <typename T>
const RR_INTRUSIVE_PTR<T>& rr_null_check(const RR_INTRUSIVE_PTR<T>& ptr)
{
    if (!ptr)
    {
        throw NullValueException("Unexpected null value");
    }
    return ptr;
}

template <typename T>
const RR_INTRUSIVE_PTR<T>& rr_null_check(const RR_INTRUSIVE_PTR<T>& ptr, const char* msg)
{
    if (!ptr)
    {
        throw NullValueException(msg);
    }
    return ptr;
}
 
#define RR_NULL_CHECK rr_null_check
 
template <typename T>
static RR_INTRUSIVE_PTR<RRArray<T> > VerifyRRArrayLength(const RR_INTRUSIVE_PTR<RRArray<T> >& a, size_t len,
                                                         bool varlength)
{
    if (!a)
        throw NullValueException("Arrays must not be null");
    if (len != 0)
    {
        if (varlength && (a->size() > len))
        {
            throw DataTypeException("Array dimension mismatch");
        }
        if (!varlength && (a->size() != len))
        {
            throw DataTypeException("Array dimension mismatch");
        }
    }
    return a;
}
 
template <typename T>
static RR_INTRUSIVE_PTR<RRList<T> > VerifyRRArrayLength(const RR_INTRUSIVE_PTR<RRList<T> >& a, size_t len,
                                                        bool varlength)
{
    if (!a)
        return a;
    BOOST_FOREACH (RR_INTRUSIVE_PTR<T>& aa, (*a))
    {
        VerifyRRArrayLength(aa, len, varlength);
    }
    return a;
}
 
template <typename K, typename T>
static RR_INTRUSIVE_PTR<RRMap<K, T> > VerifyRRArrayLength(const RR_INTRUSIVE_PTR<RRMap<K, T> >& a, size_t len,
                                                          bool varlength)
{
    if (!a)
        return a;
    BOOST_FOREACH (const RR_INTRUSIVE_PTR<T>& aa, *a | boost::adaptors::map_values)
    {
        VerifyRRArrayLength(aa, len, varlength);
    }
    return a;
}

class ROBOTRACONTEUR_CORE_API RRMultiDimBaseArray : public RRValue
{
  public:
    RR_OVIRTUAL ~RRMultiDimBaseArray() RR_OVERRIDE {}
 
    virtual DataTypes GetElementTypeID() = 0;
};
 
namespace detail
{
ROBOTRACONTEUR_CORE_API class MultiDimArray_CalculateCopyIndicesIter
{
  public:
    virtual bool Next(uint32_t& indexa, uint32_t& indexb, uint32_t& len) = 0;
 
    virtual ~MultiDimArray_CalculateCopyIndicesIter();
};
 
// cSpell: ignore mema, memb
ROBOTRACONTEUR_CORE_API RR_SHARED_PTR<MultiDimArray_CalculateCopyIndicesIter>
MultiDimArray_CalculateCopyIndicesBeginIter(const std::vector<uint32_t>& mema_dims,
                                            const std::vector<uint32_t>& mema_pos,
                                            const std::vector<uint32_t>& memb_dims,
                                            const std::vector<uint32_t>& memb_pos, const std::vector<uint32_t>& count);
} // namespace detail

template <typename T>
class RRMultiDimArray : public RRMultiDimBaseArray
{
  public:
    RR_INTRUSIVE_PTR<RRArray<uint32_t> > Dims;
 
    RR_INTRUSIVE_PTR<RRArray<T> > Array;
 
    RRMultiDimArray(){};
 
    RRMultiDimArray(const RR_INTRUSIVE_PTR<RRArray<uint32_t> >& Dims, const RR_INTRUSIVE_PTR<RRArray<T> >& Array)
    {
        this->Dims = Dims;
        this->Array = Array;
    }
 
    RR_OVIRTUAL ~RRMultiDimArray() RR_OVERRIDE {}
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE { return "RobotRaconteur.RRMultiDimArray"; }
 
    RR_OVIRTUAL DataTypes GetElementTypeID() RR_OVERRIDE { return RRPrimUtil<T>::GetTypeID(); }

    virtual void RetrieveSubArray(const std::vector<uint32_t>& memorypos,
                                  const RR_INTRUSIVE_PTR<RRMultiDimArray<T> >& buffer,
                                  const std::vector<uint32_t>& bufferpos, const std::vector<uint32_t>& count)
    {
 
        std::vector<uint32_t> mema_dims = RRArrayToVector<uint32_t>(Dims);
        std::vector<uint32_t> memb_dims = RRArrayToVector<uint32_t>(buffer->Dims);
        RR_SHARED_PTR<detail::MultiDimArray_CalculateCopyIndicesIter> iter =
            detail::MultiDimArray_CalculateCopyIndicesBeginIter(mema_dims, memorypos, memb_dims, bufferpos, count);
 
        uint32_t len = 0;
        uint32_t indexa = 0;
        uint32_t indexb = 0;
 
        while (iter->Next(indexa, indexb, len))
        {
            memcpy((buffer->Array->data() + indexb), (Array->data()) + indexa, len * sizeof(T));
        }
    }

    virtual void AssignSubArray(const std::vector<uint32_t>& memorypos,
                                const RR_INTRUSIVE_PTR<RRMultiDimArray<T> >& buffer,
                                const std::vector<uint32_t>& bufferpos, const std::vector<uint32_t>& count)
    {
 
        std::vector<uint32_t> mema_dims = RRArrayToVector<uint32_t>(Dims);
        std::vector<uint32_t> memb_dims = RRArrayToVector<uint32_t>(buffer->Dims);
        RR_SHARED_PTR<detail::MultiDimArray_CalculateCopyIndicesIter> iter =
            detail::MultiDimArray_CalculateCopyIndicesBeginIter(mema_dims, memorypos, memb_dims, bufferpos, count);
 
        uint32_t len = 0;
        uint32_t indexa = 0;
        uint32_t indexb = 0;
 
        while (iter->Next(indexa, indexb, len))
        {
            memcpy((Array->data() + indexa), (buffer->Array->data() + indexb), len * sizeof(T));
        }
    }
};
 
template <size_t Ndims, typename T>
static RR_INTRUSIVE_PTR<RRMultiDimArray<T> > VerifyRRMultiDimArrayLength(const RR_INTRUSIVE_PTR<RRMultiDimArray<T> >& a,
                                                                         size_t n_elems,
                                                                         const boost::array<uint32_t, Ndims>& dims)
{
    if (!a)
        throw NullValueException("Arrays must not be null");
 
    if (a->Dims->size() != Ndims)
    {
        throw DataTypeException("Array dimension mismatch");
    }
 
    if (a->Array->size() != n_elems)
    {
        throw DataTypeException("Array dimension mismatch");
    }
 
    for (size_t i = 0; i < Ndims; i++)
    {
        if ((*a->Dims)[i] != dims[i])
        {
            throw DataTypeException("Array dimension mismatch");
        }
    }
 
    return a;
}
 
template <size_t Ndims, typename T>
static RR_INTRUSIVE_PTR<RRList<T> > VerifyRRMultiDimArrayLength(const RR_INTRUSIVE_PTR<RRList<T> >& a, size_t n_elems,
                                                                const boost::array<uint32_t, Ndims>& dims)
{
    if (!a)
    {
        // Containers can be null
        return a;
    }
    else
    {
        BOOST_FOREACH (const RR_INTRUSIVE_PTR<T>& aa, (*a))
        {
            VerifyRRMultiDimArrayLength<Ndims>(aa, n_elems, dims);
        }
    }
    return a;
}
 
template <size_t Ndims, typename K, typename T>
static RR_INTRUSIVE_PTR<RRMap<K, T> > VerifyRRMultiDimArrayLength(const RR_INTRUSIVE_PTR<RRMap<K, T> >& a,
                                                                  size_t n_elems,
                                                                  const boost::array<uint32_t, Ndims>& dims)
{
    if (!a)
    {
        // Containers can be null
        return a;
    }
    else
    {
        BOOST_FOREACH (const RR_INTRUSIVE_PTR<T>& aa, *a | boost::adaptors::map_values)
        {
            VerifyRRMultiDimArrayLength<Ndims>(aa, n_elems, dims);
        }
        return a;
    }
}

template <typename T>
static RR_INTRUSIVE_PTR<RRMultiDimArray<T> > AllocateEmptyRRMultiDimArray(const std::vector<uint32_t>& dims)
{
    uint32_t n_elems = boost::accumulate(dims, 1, std::multiplies<uint32_t>());
    return new RRMultiDimArray<T>(VectorToRRArray<uint32_t>(dims), AllocateEmptyRRArray<T>(n_elems));
}

template <typename T>
static RR_INTRUSIVE_PTR<RRMultiDimArray<T> > AllocateEmptyRRMultiDimArray()
{
    std::vector<uint32_t> length;
    length.push_back(0);
    return new RRMultiDimArray<T>(VectorToRRArray<uint32_t>(length), AllocateEmptyRRArray<T>(0));
}

template <typename T>
static RR_INTRUSIVE_PTR<RRMultiDimArray<T> > AllocateRRMultiDimArray(const RR_INTRUSIVE_PTR<RRArray<uint32_t> >& dims,
                                                                     const RR_INTRUSIVE_PTR<RRArray<T> >& array_)
{
    return new RRMultiDimArray<T>(dims, array_); // NOLINT(cppcoreguidelines-owning-memory)
}

template <typename T>
RR_INTRUSIVE_PTR<RRList<T> > AllocateEmptyRRList()
{
    return new RRList<T>(); // NOLINT(cppcoreguidelines-owning-memory)
}

template <typename T, typename U>
RR_INTRUSIVE_PTR<RRList<T> > AllocateRRList(const U& c)
{
    return new RRList<T>(c); // NOLINT(cppcoreguidelines-owning-memory)
}

template <typename K, typename T>
RR_INTRUSIVE_PTR<RRMap<K, T> > AllocateEmptyRRMap()
{
    return new RRMap<K, T>(); // NOLINT(cppcoreguidelines-owning-memory)
}

template <typename K, typename T, typename U>
RR_INTRUSIVE_PTR<RRMap<K, T> > AllocateRRMap(const U& c)
{
    return new RRMap<K, T>(c); // NOLINT(cppcoreguidelines-owning-memory)
}

class ROBOTRACONTEUR_CORE_API RRPod
{
  public:
};

class RRPodBaseArray : public RRValue
{
  public:
    virtual boost::string_ref RRElementTypeString() = 0;
};

template <typename T>
class RRPodArray : public RRPodBaseArray
{
  protected:
    typename std::vector<T> pod_array;
 
  public:
    RRPodArray(size_t n) { pod_array.resize(n); }
 
    RRPodArray(typename std::vector<T>& array_in) : pod_array(array_in) {}
 
    RRPodArray(const T& value_in) { pod_array.push_back(value_in); }
 
    RR_OVIRTUAL ~RRPodArray() RR_OVERRIDE {}
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE { return "RobotRaconteur.RRPodArray"; }
 
    RR_OVIRTUAL boost::string_ref RRElementTypeString() RR_OVERRIDE { return RRPrimUtil<T>::GetRRElementTypeString(); }
 
    // C++ container support based on boost::container::vector

    typedef T value_type;
    typedef typename std::vector<T>::pointer pointer;
    typedef typename std::vector<T>::const_pointer const_pointer;
    typedef typename std::vector<T>::reference reference;
    typedef typename std::vector<T>::const_reference const_reference;
    typedef typename std::vector<T>::size_type size_type;
    typedef typename std::vector<T>::iterator iterator;
    typedef typename std::vector<T>::const_iterator const_iterator;
    typedef typename std::vector<T>::reverse_iterator reverse_iterator;
    typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;

    iterator begin() { return pod_array.begin(); }
    const_iterator begin() const { return pod_array.begin(); }
    iterator end() { return pod_array.end(); }
    const_iterator end() const { return pod_array.end(); }
    reverse_iterator rbegin() { return pod_array.rbegin(); }
    const_reverse_iterator rbegin() const { return pod_array.rbegin(); }
    reverse_iterator rend() { return pod_array.rend(); }
    const_reverse_iterator rend() const { return pod_array.rend(); }
    const_iterator cbegin() const { return pod_array.cbegin(); }
    const_iterator cend() const { return pod_array.cend(); }
    const_reverse_iterator const crbegin() { return pod_array.crbegin(); }
    const_reverse_iterator const crend() { return pod_array.crend(); }
    bool empty() const { return pod_array.empty(); }
    virtual size_type size() const { return pod_array.size(); }
    size_type max_size() const { return size(); }
    reference front() { return pod_array.front(); }
    const_reference front() const { return pod_array.front(); }
    reference back() { return pod_array.back(); }
    const_reference back() const { return pod_array.back(); }
    reference operator[](size_type i) { return pod_array[i]; }
    const_reference operator[](size_type i) const { return pod_array[i]; }
    reference at(size_type i) { return pod_array.at(i); }
    const_reference at(size_type i) const { return pod_array.at(i); }
    T* data() { return pod_array.data(); }
    const T* data() const { return pod_array.data(); }

    typename std::vector<T>& GetStorageContainer() { return pod_array; }
};
 
#define RRPrimUtilPod(x, type_string)                                                                                  \
    template <>                                                                                                        \
    class RRPrimUtil<x>                                                                                                \
    {                                                                                                                  \
      public:                                                                                                          \
        static DataTypes GetTypeID() { return DataTypes_pod_t; }                                                       \
        static MessageStringPtr GetElementTypeString() { return MessageStringPtr(type_string); }                       \
        static boost::string_ref GetRRElementTypeString() { return type_string; }                                      \
        static RR_INTRUSIVE_PTR<RRPodArray<x> > PrePack(const x& val) { return ScalarToRRPodArray(val); }              \
        template <typename U>                                                                                          \
        static x PreUnpack(const U& val)                                                                               \
        {                                                                                                              \
            return RRPodArrayToScalar(rr_cast<RRPodArray<x> >(val));                                                   \
        }                                                                                                              \
        typedef RR_INTRUSIVE_PTR<RRPodArray<x> > BoxedType;                                                            \
    };

class RRPodBaseMultiDimArray : public RRValue
{
  public:
    RR_INTRUSIVE_PTR<RRArray<uint32_t> > Dims;
    virtual boost::string_ref RRElementTypeString() = 0;
};

template <typename T>
class RRPodMultiDimArray : public RRPodBaseMultiDimArray
{
  public:
    typename RR_INTRUSIVE_PTR<RRPodArray<T> > PodArray;
 
    RRPodMultiDimArray() {}
 
    RRPodMultiDimArray(const RR_INTRUSIVE_PTR<RRArray<uint32_t> >& dims, const RR_INTRUSIVE_PTR<RRPodArray<T> >& a)
    {
        this->Dims = dims;
        this->PodArray = a;
    }
 
    RR_OVIRTUAL ~RRPodMultiDimArray() RR_OVERRIDE {}
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE { return "RobotRaconteur.RRPodMultiDimArray"; }
 
    RR_OVIRTUAL boost::string_ref RRElementTypeString() RR_OVERRIDE { return RRPrimUtil<T>::GetRRElementTypeString(); }

    virtual void RetrieveSubArray(const std::vector<uint32_t>& memorypos,
                                  const RR_INTRUSIVE_PTR<RRPodMultiDimArray<T> >& buffer,
                                  const std::vector<uint32_t>& bufferpos, const std::vector<uint32_t>& count)
    {
 
        std::vector<uint32_t> mema_dims = RRArrayToVector<uint32_t>(Dims);
        std::vector<uint32_t> memb_dims = RRArrayToVector<uint32_t>(buffer->Dims);
        RR_SHARED_PTR<detail::MultiDimArray_CalculateCopyIndicesIter> iter =
            detail::MultiDimArray_CalculateCopyIndicesBeginIter(mema_dims, memorypos, memb_dims, bufferpos, count);
 
        uint32_t len = 0;
        uint32_t indexa = 0;
        uint32_t indexb = 0;
 
        while (iter->Next(indexa, indexb, len))
        {
            for (size_t i = 0; i < len; i++)
            {
                buffer->PodArray->at(indexb + i) = PodArray->at(indexa + i);
            }
        }
    }

    virtual void AssignSubArray(const std::vector<uint32_t>& memorypos,
                                const RR_INTRUSIVE_PTR<RRPodMultiDimArray<T> >& buffer,
                                const std::vector<uint32_t>& bufferpos, const std::vector<uint32_t>& count)
    {
 
        std::vector<uint32_t> mema_dims = RRArrayToVector<uint32_t>(Dims);
        std::vector<uint32_t> memb_dims = RRArrayToVector<uint32_t>(buffer->Dims);
        RR_SHARED_PTR<detail::MultiDimArray_CalculateCopyIndicesIter> iter =
            detail::MultiDimArray_CalculateCopyIndicesBeginIter(mema_dims, memorypos, memb_dims, bufferpos, count);
 
        uint32_t len = 0;
        uint32_t indexa = 0;
        uint32_t indexb = 0;
 
        while (iter->Next(indexa, indexb, len))
        {
            for (size_t i = 0; i < len; i++)
            {
                PodArray->at(indexa + i) = buffer->PodArray->at(indexb + i);
            }
        }
    }
};

template <typename T>
static RR_INTRUSIVE_PTR<RRPodArray<T> > ScalarToRRPodArray(const T& value)
{
    return new RRPodArray<T>(value); // NOLINT(cppcoreguidelines-owning-memory)
}

template <typename T>
static T RRPodArrayToScalar(const RR_INTRUSIVE_PTR<RRPodArray<T> >& value)
{
    if (!value)
    {
        throw NullValueException("Null pointer");
    }
 
    if (value->size() == 0)
        throw OutOfRangeException("Index out of range");
 
    return value->at(0);
}

template <typename T>
static RR_INTRUSIVE_PTR<RRPodArray<T> > AllocateEmptyRRPodArray(size_t length)
{
    return new RRPodArray<T>(length); // NOLINT(cppcoreguidelines-owning-memory)
}

template <typename T>
static RR_INTRUSIVE_PTR<RRPodMultiDimArray<T> > AllocateEmptyRRPodMultiDimArray(const std::vector<uint32_t>& dims)
{
    uint32_t n_elems = boost::accumulate(dims, 1, std::multiplies<uint32_t>());
    return new RRPodMultiDimArray<T>(VectorToRRArray<uint32_t>(dims), AllocateEmptyRRPodArray<T>(n_elems));
}

template <typename T>
static RR_INTRUSIVE_PTR<RRPodMultiDimArray<T> > AllocateEmptyRRPodMultiDimArray()
{
    std::vector<uint32_t> length;
    length.push_back(0);
    return new RRPodMultiDimArray<T>(VectorToRRArray<uint32_t>(length), AllocateEmptyRRPodArray<T>(0));
}
 
#define RRPrimUtilNamedArray(x, type_string, array_type)                                                               \
    template <>                                                                                                        \
    class RRPrimUtil<x>                                                                                                \
    {                                                                                                                  \
      public:                                                                                                          \
        static DataTypes GetTypeID() { return DataTypes_pod_t; }                                                       \
        static MessageStringPtr GetElementTypeString() { return MessageStringPtr(type_string); }                       \
        static boost::string_ref GetRRElementTypeString() { return type_string; }                                      \
        static RR_INTRUSIVE_PTR<RRNamedArray<x> > PrePack(const x& val) { return ScalarToRRNamedArray(val); }          \
        template <typename U>                                                                                          \
        static x PreUnpack(const U& val)                                                                               \
        {                                                                                                              \
            return RRNamedArrayToScalar(rr_cast<RRNamedArray<x> >(val));                                               \
        }                                                                                                              \
        typedef RR_INTRUSIVE_PTR<RRNamedArray<x> > BoxedType;                                                          \
        typedef array_type ElementArrayType;                                                                           \
        static const size_t ElementArrayCount = sizeof(x) / sizeof(array_type);                                        \
        static size_t GetElementArrayCount() { return ElementArrayCount; }                                             \
        static DataTypes GetElementArrayTypeID() { return RRPrimUtil<array_type>::GetTypeID(); }                       \
    };

class ROBOTRACONTEUR_CORE_API RRNamedBaseArray : public RRValue
{
  public:
    virtual DataTypes ElementArrayType() = 0;
 
    virtual size_t ElementSize() = 0;
 
    virtual size_t ElementArrayCount() = 0;
 
    virtual RR_INTRUSIVE_PTR<RRBaseArray> GetNumericBaseArray() = 0;
 
    virtual boost::string_ref RRElementTypeString() = 0;
};

template <typename T>
class RRNamedArray : public RRNamedBaseArray
{
  protected:
    RR_INTRUSIVE_PTR<RRArray<typename RRPrimUtil<T>::ElementArrayType> > rr_array;
 
  public:
    RRNamedArray(const RR_INTRUSIVE_PTR<RRArray<typename RRPrimUtil<T>::ElementArrayType> >& rr_array)
    {
        if (!rr_array)
            throw NullValueException("Numeric array for namedarray must not be null");
        this->rr_array = rr_array;
    }
 
    virtual DataTypes GetTypeID() { return RRPrimUtil<T>::GetTypeID(); }
    virtual size_t size() const { return rr_array->size() / (RRPrimUtil<T>::ElementArrayCount); }
    virtual size_t size() { return rr_array->size() / (RRPrimUtil<T>::ElementArrayCount); }
    virtual void* void_ptr() { return rr_array->void_ptr(); }
    RR_OVIRTUAL size_t ElementSize() RR_OVERRIDE { return sizeof(T); }
    RR_OVIRTUAL DataTypes ElementArrayType() RR_OVERRIDE { return RRPrimUtil<T>::GetElementArrayTypeID(); }
    RR_OVIRTUAL size_t ElementArrayCount() RR_OVERRIDE { return RRPrimUtil<T>::ElementArrayCount; }
    virtual RR_INTRUSIVE_PTR<RRArray<typename RRPrimUtil<T>::ElementArrayType> > GetNumericArray() { return rr_array; }
    RR_OVIRTUAL RR_INTRUSIVE_PTR<RRBaseArray> GetNumericBaseArray() RR_OVERRIDE { return rr_array; }
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE { return "RobotRaconteur.RRNamedArray"; }
 
    RR_OVIRTUAL boost::string_ref RRElementTypeString() RR_OVERRIDE { return RRPrimUtil<T>::GetRRElementTypeString(); }
 
    // C++ container support functions based on boost::array
 
    // type definitions
    typedef T value_type;
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef T& reference;
    typedef const T& const_reference;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
 
    // iterator support

    iterator begin() { return static_cast<T*>(rr_array->begin()); }
    const_iterator begin() const { return static_cast<const T*>(rr_array->begin()); }
    const_iterator cbegin() const { return static_cast<const T*>(rr_array->begin()); }

    iterator end() { return static_cast<T*>(rr_array->end()); }
    const_iterator end() const { return static_cast<T*>(rr_array->end()); }
    const_iterator cend() const { return static_cast<T*>(rr_array->end()); }

    typedef boost::reverse_iterator<iterator> reverse_iterator;
    typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;

    reverse_iterator rbegin() { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }

    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }

    reference operator[](size_type i)
    {
        BOOST_ASSERT_MSG(i < size(), "out of range");
        return (static_cast<T*>(rr_array->void_ptr())[i]);
    }

    const_reference operator[](size_type i) const
    {
        BOOST_ASSERT_MSG(i < size(), "out of range");
        return (static_cast<T*>(rr_array->void_ptr())[i]);
    }

    reference at(size_type i)
    {
        rangecheck(i);
        return (static_cast<T*>(rr_array->void_ptr())[i]);
    }

    const_reference at(size_type i) const
    {
        rangecheck(i);
        (static_cast<T*>(rr_array->void_ptr())[i]);
    }

    reference front() { return this->at(0); }
    const_reference front() const { return this->at(0); }

    reference back() { return this->at(size() - 1); }
    const_reference back() const { return this->at(size() - 1); }

    bool empty() { return rr_array->empty(); }
    size_type max_size() { return size(); }
 
    void rangecheck(size_type i)
    {
        if (i >= size())
        {
            std::out_of_range e("array<>: index out of range");
            boost::throw_exception(e);
        }
    }
};

class RRNamedBaseMultiDimArray : public RRValue
{
  public:
    RR_INTRUSIVE_PTR<RRArray<uint32_t> > Dims;
    virtual boost::string_ref RRElementTypeString() = 0;
};

template <typename T>
class RRNamedMultiDimArray : public RRNamedBaseMultiDimArray
{
  public:
    typename RR_INTRUSIVE_PTR<RRNamedArray<T> > NamedArray;
 
    RRNamedMultiDimArray() {}
 
    RRNamedMultiDimArray(const RR_INTRUSIVE_PTR<RRArray<uint32_t> >& dims, const RR_INTRUSIVE_PTR<RRNamedArray<T> >& a)
    {
        this->Dims = dims;
        this->NamedArray = a;
    }
 
    RR_OVIRTUAL ~RRNamedMultiDimArray() RR_OVERRIDE {}
 
    RR_OVIRTUAL std::string RRType() RR_OVERRIDE { return "RobotRaconteur.RRNamedMultiDimArray"; }
 
    RR_OVIRTUAL boost::string_ref RRElementTypeString() RR_OVERRIDE { return RRPrimUtil<T>::GetRRElementTypeString(); }

    virtual void RetrieveSubArray(const std::vector<uint32_t>& memorypos,
                                  const RR_INTRUSIVE_PTR<RRNamedMultiDimArray<T> >& buffer,
                                  const std::vector<uint32_t>& bufferpos, const std::vector<uint32_t>& count)
    {
 
        std::vector<uint32_t> mema_dims = RRArrayToVector<uint32_t>(Dims);
        std::vector<uint32_t> memb_dims = RRArrayToVector<uint32_t>(buffer->Dims);
        RR_SHARED_PTR<detail::MultiDimArray_CalculateCopyIndicesIter> iter =
            detail::MultiDimArray_CalculateCopyIndicesBeginIter(mema_dims, memorypos, memb_dims, bufferpos, count);
 
        uint32_t len = 0;
        uint32_t indexa = 0;
        uint32_t indexb = 0;
 
        while (iter->Next(indexa, indexb, len))
        {
            for (size_t i = 0; i < len; i++)
            {
                (*buffer->NamedArray)[(indexb + i)] = (*NamedArray)[(indexa + i)];
            }
        }
    }

    virtual void AssignSubArray(const std::vector<uint32_t>& memorypos,
                                const RR_INTRUSIVE_PTR<RRNamedMultiDimArray<T> >& buffer,
                                const std::vector<uint32_t>& bufferpos, const std::vector<uint32_t>& count)
    {
 
        std::vector<uint32_t> mema_dims = RRArrayToVector<uint32_t>(Dims);
        std::vector<uint32_t> memb_dims = RRArrayToVector<uint32_t>(buffer->Dims);
        RR_SHARED_PTR<detail::MultiDimArray_CalculateCopyIndicesIter> iter =
            detail::MultiDimArray_CalculateCopyIndicesBeginIter(mema_dims, memorypos, memb_dims, bufferpos, count);
 
        uint32_t len = 0;
        uint32_t indexa = 0;
        uint32_t indexb = 0;
 
        while (iter->Next(indexa, indexb, len))
        {
            for (size_t i = 0; i < len; i++)
            {
                (*NamedArray)[(indexa + i)] = (*buffer->NamedArray)[(indexb + i)];
            }
        }
    }
};

template <typename T>
static RR_INTRUSIVE_PTR<RRNamedArray<T> > AllocateEmptyRRNamedArray(size_t length)
{
    typedef typename RRPrimUtil<T>::ElementArrayType a_type;
    RR_INTRUSIVE_PTR<RRArray<a_type> > a = AllocateEmptyRRArray<a_type>(length * RRPrimUtil<T>::GetElementArrayCount());
    return new RRNamedArray<T>(a); // NOLINT(cppcoreguidelines-owning-memory)
}

template <typename T>
static RR_INTRUSIVE_PTR<RRNamedMultiDimArray<T> > AllocateEmptyRRNamedMultiDimArray(const std::vector<uint32_t>& dims)
{
    uint32_t n_elems = boost::accumulate(dims, 1, std::multiplies<uint32_t>());
    return new RRNamedMultiDimArray<T>(VectorToRRArray<uint32_t>(dims), AllocateEmptyRRNamedArray<T>(n_elems));
}

template <typename T>
static RR_INTRUSIVE_PTR<RRNamedMultiDimArray<T> > AllocateEmptyRRNamedMultiDimArray()
{
    std::vector<uint32_t> length;
    length.push_back(0);
    return new RRNamedMultiDimArray<T>(VectorToRRArray<uint32_t>(length), AllocateEmptyRRNamedArray<T>(0));
}

template <typename T>
static RR_INTRUSIVE_PTR<RRNamedArray<T> > ScalarToRRNamedArray(const T& value)
{
    RR_INTRUSIVE_PTR<RRNamedArray<T> > a = AllocateEmptyRRNamedArray<T>(1);
    (*a)[0] = value;
    return a;
}

template <typename T>
static T RRNamedArrayToScalar(const RR_INTRUSIVE_PTR<RRNamedArray<T> >& value)
{
    if (!value)
    {
        throw NullValueException("Null pointer");
    }
 
    if (value->size() == 0)
        throw OutOfRangeException("Index out of range");
 
    return (*value)[0];
}
 
#define RRPrimUtilEnum(x)                                                                                              \
    template <>                                                                                                        \
    class RRPrimUtil<x>                                                                                                \
    {                                                                                                                  \
      public:                                                                                                          \
        static DataTypes GetTypeID() { return DataTypes_enum_t; }                                                      \
        static MessageStringPtr GetElementTypeString() { return MessageStringPtr(""); }                                \
        static boost::string_ref GetRRElementTypeString() { return ""; }                                               \
        static RR_INTRUSIVE_PTR<RRArray<int32_t> > PrePack(const x& val) { return ScalarToRRArray((int32_t)val); }     \
        template <typename U>                                                                                          \
        static x PreUnpack(const U& val)                                                                               \
        {                                                                                                              \
            return (x)RRArrayToScalar(rr_cast<RRArray<int32_t> >(val));                                                \
        }                                                                                                              \
        typedef RR_INTRUSIVE_PTR<RRArray<int32_t> > BoxedType;                                                         \
    };
 
class ROBOTRACONTEUR_CORE_API RobotRaconteurNode;

class ROBOTRACONTEUR_CORE_API TimeSpec
{
  public:
    int64_t seconds;
    int32_t nanoseconds;

    TimeSpec();

    TimeSpec(int64_t seconds, int32_t nanoseconds);

    bool operator==(const TimeSpec& t2) const;
    bool operator!=(const TimeSpec& t2) const;
    TimeSpec operator-(const TimeSpec& t2) const;
    TimeSpec operator+(const TimeSpec& t2) const;
    bool operator>(const TimeSpec& t2) const;
    bool operator>=(const TimeSpec& t2) const;
    bool operator<(const TimeSpec& t2) const;
    bool operator<=(const TimeSpec& t2) const;

    void cleanup_nanosecs();
};

 
boost::posix_time::ptime ROBOTRACONTEUR_CORE_API TimeSpecToPTime(const TimeSpec& ts);
TimeSpec ROBOTRACONTEUR_CORE_API ptimeToTimeSpec(const boost::posix_time::ptime& t);
 
#ifdef ROBOTRACONTEUR_USE_SMALL_VECTOR
typedef boost::container::small_vector<boost::asio::const_buffer, 4> const_buffers;
typedef boost::container::small_vector<boost::asio::mutable_buffer, 4> mutable_buffers;
#else
typedef std::vector<boost::asio::const_buffer> const_buffers;
typedef std::vector<boost::asio::mutable_buffer> mutable_buffers;
#endif
 
template <typename BufferSequence>
void buffers_consume(BufferSequence& b, size_t count)
{
    typename BufferSequence::iterator e = b.begin();
    ;
    typename BufferSequence::iterator end = b.end();
    for (; e != end;)
    {
        if (count > 0)
        {
            if (count > boost::asio::buffer_size(*e))
            {
                count -= boost::asio::buffer_size(*e);
                e = b.erase(e);
            }
            else
            {
                *e = *e + count;
                count = 0;
                ++e;
            }
        }
        else
        {
            break;
        }
    }
}
 
template <typename BufferSequence>
BufferSequence buffers_consume_copy(BufferSequence& b, size_t count)
{
    BufferSequence o;
    typename BufferSequence::iterator e = b.begin();
    ;
    typename BufferSequence::iterator end = b.end();
    for (; e != end; e++)
    {
        if (count > 0)
        {
            if (count > boost::asio::buffer_size(*e))
            {
                count -= boost::asio::buffer_size(*e);
            }
            else
            {
                o.push_back(*e + count);
                count = 0;
            }
        }
        else
        {
            o.push_back(*e);
        }
    }
 
    return o;
}
 
template <typename BufferSequence>
BufferSequence buffers_consume_copy(const BufferSequence& b, size_t count)
{
    BufferSequence o;
    typename BufferSequence::const_iterator e = b.begin();
    ;
    typename BufferSequence::const_iterator end = b.end();
    for (; e != end; e++)
    {
        if (count > 0)
        {
            if (count > boost::asio::buffer_size(*e))
            {
                count -= boost::asio::buffer_size(*e);
            }
            else
            {
                o.push_back(*e + count);
                count = 0;
            }
        }
        else
        {
            o.push_back(*e);
        }
    }
 
    return o;
}
 
template <typename BufferSequence>
BufferSequence buffers_truncate(BufferSequence& b, size_t count)
{
    BufferSequence o;
    typename BufferSequence::iterator e = b.begin();
    ;
    typename BufferSequence::iterator end = b.end();
    size_t p = 0;
    for (; e != end; e++)
    {
        if (p + boost::asio::buffer_size(*e) <= count)
        {
            o.push_back(*e);
            p += boost::asio::buffer_size(*e);
        }
        else
        {
            o.push_back(boost::asio::buffer(*e, count - p));
            break;
        }
    }
 
    return o;
}
 
template <typename BufferSequence>
BufferSequence buffers_truncate(const BufferSequence& b, size_t count)
{
    BufferSequence o;
    typename BufferSequence::const_iterator e = b.begin();
    ;
    typename BufferSequence::const_iterator end = b.end();
    size_t p = 0;
    for (; e != end; e++)
    {
        if (p + boost::asio::buffer_size(*e) <= count)
        {
            o.push_back(*e);
            p += boost::asio::buffer_size(*e);
        }
        else
        {
            o.push_back(boost::asio::buffer(*e, count - p));
            break;
        }
    }
 
    return o;
}
 
/***
 * @brief Service path segment containing a name and an optional index
 */
struct ROBOTRACONTEUR_CORE_API ServicePathSegment
{
 
    ServicePathSegment();
 
    ServicePathSegment(const std::string& name,
                       const boost::optional<std::string>& index = boost::optional<std::string>());

    std::string name;
    boost::optional<std::string> index;
};
 
ROBOTRACONTEUR_CORE_API bool operator==(const ServicePathSegment& lhs, const ServicePathSegment& rhs);
 
ROBOTRACONTEUR_CORE_API bool operator!=(const ServicePathSegment& lhs, const ServicePathSegment& rhs);

ROBOTRACONTEUR_CORE_API std::string EncodeServicePathIndex(const std::string& index);

ROBOTRACONTEUR_CORE_API std::string DecodeServicePathIndex(const std::string& index);

ROBOTRACONTEUR_CORE_API std::vector<ServicePathSegment> ParseServicePath(const std::string& path);

ROBOTRACONTEUR_CORE_API std::string BuildServicePath(const std::vector<ServicePathSegment>& segments);

ROBOTRACONTEUR_CORE_API bool IsStringName(boost::string_ref str);
ROBOTRACONTEUR_CORE_API bool IsStringScopedName(boost::string_ref str);
ROBOTRACONTEUR_CORE_API bool IsStringUUID(boost::string_ref str);
ROBOTRACONTEUR_CORE_API bool IsStringIdentifier(boost::string_ref str);
 
namespace detail
{
ROBOTRACONTEUR_CORE_API std::string encode_index(boost::string_ref index);
 
ROBOTRACONTEUR_CORE_API std::string decode_index(boost::string_ref index);
 
template <typename T, typename U>
bool try_convert_string_to_number(const U& arg, T& result)
{
    if (boost::conversion::try_lexical_convert(arg, result))
    {
        return true;
    }
 
    if (!boost::is_integral<T>::value)
    {
        return false;
    }
 
    boost::regex hex_regex("^[+\\-]?0x[\\da-fA-F]+$");
    if (!boost::regex_match(arg.begin(), arg.end(), hex_regex))
    {
        return false;
    }
 
    std::stringstream ss;
    ss << std::hex << arg;
    T v;
    ss >> v;
    if (ss.fail() || !ss.eof())
    {
        return false;
    }
 
    result = v;
 
    return true;
}
 
} // namespace detail
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
using RRObjectPtr = RR_SHARED_PTR<RRObject>;
using RRObjectConstPtr = RR_SHARED_PTR<const RRObject>;
using RRValuePtr = RR_INTRUSIVE_PTR<RRValue>;
using RRValueConstPtr = RR_INTRUSIVE_PTR<const RRValue>;
using MessageElementDataPtr = RR_INTRUSIVE_PTR<MessageElementData>;
using MessageElementDataConstPtr = RR_INTRUSIVE_PTR<const MessageElementData>;
using RRBaseArrayPtr = RR_INTRUSIVE_PTR<RRBaseArray>;
using RRBaseArrayConstPtr = RR_INTRUSIVE_PTR<const RRBaseArray>;
template <typename T>
using RRArrayPtr = RR_INTRUSIVE_PTR<RRArray<T> >;
template <typename T>
using RRArrayConstPtr = RR_INTRUSIVE_PTR<const RRArray<T> >;
template <typename K, typename T>
using RRMapPtr = RR_INTRUSIVE_PTR<RRMap<K, T> >;
template <typename K, typename T>
using RRMapConstPtr = RR_INTRUSIVE_PTR<const RRMap<K, T> >;
template <typename T>
using RRListPtr = RR_INTRUSIVE_PTR<RRList<T> >;
template <typename T>
using RRListConstPtr = RR_INTRUSIVE_PTR<const RRList<T> >;
using RRStructurePtr = RR_INTRUSIVE_PTR<RRStructure>;
using RRStructureConstPtr = RR_INTRUSIVE_PTR<const RRStructure>;
using RRMultiDimBaseArrayPtr = RR_INTRUSIVE_PTR<RRMultiDimBaseArray>;
using RRMultiDimBaseArrayConstPtr = RR_INTRUSIVE_PTR<const RRMultiDimBaseArray>;
template <typename T>
using RRMultiDimArrayPtr = RR_INTRUSIVE_PTR<RRMultiDimArray<T> >;
template <typename T>
using RRMultiDimArrayConstPtr = RR_INTRUSIVE_PTR<const RRMultiDimArray<T> >;
using RRPodBaseArrayPtr = RR_INTRUSIVE_PTR<RRPodBaseArray>;
using RRPodBaseArrayConstPtr = RR_INTRUSIVE_PTR<const RRPodBaseArray>;
template <typename T>
using RRPodArrayPtr = RR_INTRUSIVE_PTR<RRPodArray<T> >;
template <typename T>
using RRPodArrayConstPtr = RR_INTRUSIVE_PTR<const RRPodArray<T> >;
using RRPodBaseMultiDimArrayPtr = RR_INTRUSIVE_PTR<RRPodBaseMultiDimArray>;
using RRPodBaseMultiDimBaseArrayConstPtr = RR_INTRUSIVE_PTR<const RRPodBaseMultiDimArray>;
template <typename T>
using RRPodMultiDimArrayPtr = RR_INTRUSIVE_PTR<RRPodMultiDimArray<T> >;
template <typename T>
using RRPodMultiDimArrayConstPtr = RR_INTRUSIVE_PTR<const RRPodMultiDimArray<T> >;
using RRNamedBaseArrayPtr = RR_INTRUSIVE_PTR<RRNamedBaseArray>;
using RRNamedBaseArrayConstPtr = RR_INTRUSIVE_PTR<const RRNamedBaseArray>;
template <typename T>
using RRNamedArrayPtr = RR_INTRUSIVE_PTR<RRNamedArray<T> >;
template <typename T>
using RRNamedArrayConstPtr = RR_INTRUSIVE_PTR<const RRNamedArray<T> >;
using RRNamedBaseMultiDimArrayPtr = RR_INTRUSIVE_PTR<RRNamedBaseMultiDimArray>;
using RRNamedBaseMultiDimBaseArrayConstPtr = RR_INTRUSIVE_PTR<const RRNamedBaseMultiDimArray>;
template <typename T>
using RRNamedMultiDimArrayPtr = RR_INTRUSIVE_PTR<RRNamedMultiDimArray<T> >;
template <typename T>
using RRNamedMultiDimArrayConstPtr = RR_INTRUSIVE_PTR<const RRNamedMultiDimArray<T> >;
#endif
} // namespace RobotRaconteur