Vector.h

/* Copyright (c) 2015-2016, Human Brain Project
 *                          Stefan.Eilemann@epfl.ch
 */

#ifndef ZEROBUF_VECTOR_H
#define ZEROBUF_VECTOR_H

#include <zerobuf/DynamicSubAllocator.h> // used inline
#include <zerobuf/Zerobuf.h>             // sfinae type
#include <zerobuf/json.h>                // used inline

#include <cstring>   // memcmp
#include <stdexcept> // std::runtime_error
#include <typeinfo>  // typeid

namespace zerobuf
{
template <class T>
class Vector
{
public:
    template <class U>
    class Iterator : public std::iterator<std::forward_iterator_tag, U>
    {
    public:
        Iterator(U& vector, const size_t index)
            : _vector(vector)
            , _index(index)
        {
        }

        bool operator==(const Iterator& rhs) const
        {
            return _index == rhs._index;
        }
        bool operator!=(const Iterator& rhs) const
        {
            return _index != rhs._index;
        }

        Iterator& operator++()
        {
            ++_index;
            return *this;
        }

        const typename U::element_type& operator*() const
        {
            return _vector[_index];
        }

        template <class Q = U, typename = typename std::enable_if<
                                   !std::is_const<Q>::value>::type>
        typename U::element_type& operator*()
        {
            return _vector[_index];
        }

    private:
        U& _vector;
        size_t _index;
    };

    using element_type = T;
    using iterator = Iterator<Vector<T>>;
    using const_iterator = Iterator<const Vector<T>>;

    Vector(Allocator& alloc, size_t index);
    ~Vector() {}
    bool empty() const { return _getSize() == 0; }
    uint64_t size() const { return _getSize() / _getElementSize<T>(); }
    void clear();

    T* data() { return _alloc->template getDynamic<T>(_index); }
    const T* data() const
    {
        return const_cast<const Allocator*>(_alloc)->template getDynamic<T>(
            _index);
    }

    void resize(size_t size);

    bool operator==(const Vector& rhs) const;
    bool operator!=(const Vector& rhs) const;

    const_iterator begin() const;

    const_iterator end() const;

    iterator begin();

    iterator end();

    template <class Q = T>
    const typename std::enable_if<!std::is_base_of<Zerobuf, Q>::value, Q>::type&
        operator[](const size_t index) const;

    template <class Q = T>
    typename std::enable_if<!std::is_base_of<Zerobuf, Q>::value, Q>::type&
        operator[](const size_t index);

    template <class Q = T>
    const typename std::enable_if<std::is_base_of<Zerobuf, Q>::value, Q>::type&
        operator[](const size_t index) const;

    template <class Q = T>
    typename std::enable_if<std::is_base_of<Zerobuf, Q>::value, Q>::type&
        operator[](const size_t index);

    template <class Q = T>
    void push_back(const typename std::enable_if<
                   !std::is_base_of<Zerobuf, Q>::value, Q>::type&);

    template <class Q = T>
    void push_back(const typename std::enable_if<
                   std::is_base_of<Zerobuf, Q>::value, Q>::type&);

    void reset(Allocator& alloc)
    {
        _alloc = &alloc;
        _zerobufs.clear();
    }

    void compact(float) { /* NOP: elements are static and clear frees */}

    template <class Q = T>
    void fromJSON(const Json::Value& json,
                  const typename std::enable_if<
                      std::is_base_of<Zerobuf, Q>::value, Q>::type* = nullptr);

    template <class Q = T>
    void fromJSON(const Json::Value& json,
                  const typename std::enable_if<std::is_enum<Q>::value,
                                                Q>::type* = nullptr);

    template <class Q = T>
    void fromJSON(const Json::Value& json,
                  const typename std::enable_if<std::is_arithmetic<Q>::value,
                                                Q>::type* = nullptr);

    template <class Q = T>
    void fromJSON(
        const Json::Value& json,
        const typename std::enable_if<std::is_same<Q, servus::uint128_t>::value,
                                      Q>::type* = nullptr);

    template <class Q = T>
    void toJSON(
        Json::Value& json,
        const typename std::enable_if<std::is_base_of<Zerobuf, Q>::value,
                                      Q>::type* = nullptr) const;

    template <class Q = T>
    void toJSON(Json::Value& json,
                const typename std::enable_if<std::is_enum<Q>::value,
                                              Q>::type* = nullptr) const;

    template <class Q = T>
    void toJSON(Json::Value& json,
                const typename std::enable_if<std::is_arithmetic<Q>::value,
                                              Q>::type* = nullptr) const;

    template <class Q = T>
    void toJSON(
        Json::Value& json,
        const typename std::enable_if<std::is_same<Q, servus::uint128_t>::value,
                                      Q>::type* = nullptr) const;

    template <class Q = T>
    void fromJSONBinary(const Json::Value& json,
                        const typename std::enable_if<std::is_pod<Q>::value,
                                                      Q>::type* = nullptr);

    template <class Q = T>
    void toJSONBinary(Json::Value& json,
                      const typename std::enable_if<std::is_pod<Q>::value,
                                                    Q>::type* = nullptr) const;

private:
    Allocator* _alloc;
    const size_t _index;
    mutable std::vector<T> _zerobufs;

    Vector() = delete;
    Vector(const Vector& rhs) = delete;
    Vector(const Vector&& rhs) = delete;

    size_t _getSize() const { return _alloc->getDynamicSize(_index); }
    void copyBuffer(uint8_t* data, size_t size);

    template <class Q = T>
    size_t _getElementSize(
        typename std::enable_if<std::is_base_of<Zerobuf, Q>::value, Q>::type* =
            0) const
    {
        return Q::ZEROBUF_STATIC_SIZE();
    }

    template <class Q = T>
    size_t _getElementSize(
        typename std::enable_if<!std::is_base_of<Zerobuf, Q>::value, Q>::type* =
            0) const
    {
        return sizeof(Q);
    }
};

// Implementation
template <class T>
inline Vector<T>::Vector(Allocator& alloc, const size_t index)
    : _alloc(&alloc)
    , _index(index)
{
}

template <class T>
inline void Vector<T>::clear()
{
    _alloc->updateAllocation(_index, false, 0);
    _zerobufs.clear();
}

template <class T>
inline void Vector<T>::resize(const size_t size_)
{
    _alloc->updateAllocation(_index, true /*copy*/,
                             size_ * _getElementSize<T>());
}

template <class T>
inline typename Vector<T>::const_iterator Vector<T>::begin() const
{
    return const_iterator(*this, 0);
}

template <class T>
inline typename Vector<T>::const_iterator Vector<T>::end() const
{
    return const_iterator(*this, size());
}

template <class T>
inline typename Vector<T>::iterator Vector<T>::begin()
{
    return iterator(*this, 0);
}

template <class T>
inline typename Vector<T>::iterator Vector<T>::end()
{
    return iterator(*this, size());
}

template <class T>
inline bool Vector<T>::operator==(const Vector& rhs) const
{
    if (this == &rhs)
        return true;
    const size_t size_ = _getSize();
    if (size_ != rhs._getSize())
        return false;
    if (size_ == 0)
        return true;

    // memory compare is valid for Zerobufs as well since they are right now
    // static and therefore will have the same layout
    return ::memcmp(static_cast<const void*>(data()),
                    static_cast<const void*>(rhs.data()), size_) == 0;
}

template <class T>
inline bool Vector<T>::operator!=(const Vector& rhs) const
{
    return !(operator==(rhs));
}

template <class T>
template <class Q>
inline const typename std::enable_if<!std::is_base_of<Zerobuf, Q>::value,
                                     Q>::type& Vector<T>::
    operator[](const size_t index) const
{
    if (index >= size())
        throw std::runtime_error("Vector out of bounds read");

    return data()[index];
}

template <class T>
template <class Q>
inline typename std::enable_if<!std::is_base_of<Zerobuf, Q>::value, Q>::type&
    Vector<T>::operator[](const size_t index)
{
    if (index >= size())
        throw std::runtime_error("Vector out of bounds read");

    return data()[index];
}

template <class T>
template <class Q>
inline const typename std::enable_if<std::is_base_of<Zerobuf, Q>::value,
                                     Q>::type& Vector<T>::
    operator[](const size_t index) const
{
    if (index >= size())
        throw std::runtime_error("Vector out of bounds read");

    while (_zerobufs.size() < index + 1)
        _zerobufs.emplace_back(AllocatorPtr(
            new DynamicSubAllocator(*_alloc, _index, _zerobufs.size(),
                                    _getElementSize<T>())));
    return _zerobufs[index];
}

template <class T>
template <class Q>
inline typename std::enable_if<std::is_base_of<Zerobuf, Q>::value, Q>::type&
    Vector<T>::operator[](const size_t index)
{
    if (index >= size())
        throw std::runtime_error("Vector out of bounds read");

    while (_zerobufs.size() < index + 1)
        _zerobufs.emplace_back(AllocatorPtr(
            new DynamicSubAllocator(*_alloc, _index, _zerobufs.size(),
                                    _getElementSize<T>())));
    return _zerobufs[index];
}

template <class T>
template <class Q>
inline void Vector<T>::push_back(
    const typename std::enable_if<!std::is_base_of<Zerobuf, Q>::value, Q>::type&
        value)
{
    const size_t size_ = _getSize();
    T* newPtr = reinterpret_cast<T*>(
        _alloc->updateAllocation(_index, true /*copy*/, size_ + sizeof(T)));
    newPtr[size_ / _getElementSize<T>()] = value;
}

template <class T>
template <class Q>
inline void Vector<T>::push_back(
    const typename std::enable_if<std::is_base_of<Zerobuf, Q>::value, Q>::type&
        value)
{
    const size_t size_ = _getSize();
    const zerobuf::Data& zerobuf = value.toBinary();
    uint8_t* newPtr =
        _alloc->updateAllocation(_index, true /*copy*/, size_ + zerobuf.size);
    ::memcpy(newPtr + size_, zerobuf.ptr.get(), zerobuf.size);
}

template <class T>
template <class Q>
inline void Vector<T>::fromJSON(
    const Json::Value& json,
    const typename std::enable_if<std::is_base_of<Zerobuf, Q>::value, Q>::type*)
{
    const size_t size_ = getJSONSize(json);
    _alloc->updateAllocation(_index, false, size_ * _getElementSize<T>());
    for (size_t i = 0; i < size_; ++i)
        zerobuf::fromJSON(getJSONField(json, i), (*this)[i]);
}

template <class T>
template <class Q>
inline void Vector<T>::fromJSON(
    const Json::Value& json,
    const typename std::enable_if<std::is_enum<Q>::value, Q>::type*)
{
    const size_t size_ = getJSONSize(json);
    T* array = reinterpret_cast<T*>(
        _alloc->updateAllocation(_index, false /*no copy*/, size_ * sizeof(T)));

    for (size_t i = 0; i < size_; ++i)
        array[i] = string_to_enum<T>(
            zerobuf::fromJSON<std::string>(getJSONField(json, i)));
}

template <class T>
template <class Q>
inline void Vector<T>::fromJSON(
    const Json::Value& json,
    const typename std::enable_if<std::is_arithmetic<Q>::value, Q>::type*)
{
    const size_t size_ = getJSONSize(json);
    T* array = reinterpret_cast<T*>(
        _alloc->updateAllocation(_index, false /*no copy*/, size_ * sizeof(T)));

    for (size_t i = 0; i < size_; ++i)
        array[i] = zerobuf::fromJSON<T>(getJSONField(json, i));
}

template <class T>
template <class Q>
inline void Vector<T>::fromJSON(
    const Json::Value& json,
    const typename std::enable_if<std::is_same<Q, servus::uint128_t>::value,
                                  Q>::type*)
{
    const size_t size_ = getJSONSize(json);
    T* array = reinterpret_cast<T*>(
        _alloc->updateAllocation(_index, false /*no copy*/, size_ * sizeof(T)));

    for (size_t i = 0; i < size_; ++i)
        array[i] = zerobuf::fromJSON<T>(getJSONField(json, i));
}

template <class T>
template <class Q>
inline void Vector<T>::toJSON(
    Json::Value& json,
    const typename std::enable_if<std::is_base_of<Zerobuf, Q>::value, Q>::type*)
    const
{
    const size_t size_ = size();
    zerobuf::emptyJSONArray(
        json); // return [] instead of null if array is empty
    for (size_t i = 0; i < size_; ++i)
        zerobuf::toJSON(static_cast<const Zerobuf&>((*this)[i]),
                        getJSONField(json, i));
}

template <class T>
template <class Q>
inline void Vector<T>::toJSON(
    Json::Value& json,
    const typename std::enable_if<std::is_enum<Q>::value, Q>::type*) const
{
    const size_t size_ = size();
    zerobuf::emptyJSONArray(
        json); // return [] instead of null if array is empty
    for (size_t i = 0; i < size_; ++i)
        zerobuf::toJSON(enum_to_string<T>((*this)[i]), getJSONField(json, i));
}

template <class T>
template <class Q>
inline void Vector<T>::toJSON(
    Json::Value& json,
    const typename std::enable_if<std::is_arithmetic<Q>::value, Q>::type*) const
{
    const size_t size_ = size();
    zerobuf::emptyJSONArray(
        json); // return [] instead of null if array is empty
    for (size_t i = 0; i < size_; ++i)
        zerobuf::toJSON((*this)[i], getJSONField(json, i));
}

template <class T>
template <class Q>
inline void Vector<T>::toJSON(
    Json::Value& json,
    const typename std::enable_if<std::is_same<Q, servus::uint128_t>::value,
                                  Q>::type*) const
{
    const size_t size_ = size();
    zerobuf::emptyJSONArray(
        json); // return [] instead of null if array is empty
    for (size_t i = 0; i < size_; ++i)
        zerobuf::toJSON((*this)[i], getJSONField(json, i));
}

template <class T>
template <class Q>
inline void Vector<T>::fromJSONBinary(
    const Json::Value& json,
    const typename std::enable_if<std::is_pod<Q>::value, Q>::type*)
{
    const std::string& decoded = zerobuf::fromJSONBinary(json);
    copyBuffer((uint8_t*)decoded.data(), decoded.length());
}

template <class T>
template <class Q>
inline void Vector<T>::toJSONBinary(
    Json::Value& json,
    const typename std::enable_if<std::is_pod<Q>::value, Q>::type*) const
{
    zerobuf::toJSONBinary(data(), _getSize(), json);
}

template <class T>
inline void Vector<T>::copyBuffer(uint8_t* data_, size_t size_)
{
    void* to = _alloc->updateAllocation(_index, false /*no copy*/, size_);
    ::memcpy(to, data_, size_);
}

template <class T>
inline std::ostream& operator<<(std::ostream& os, const Vector<T>& vector)
{
    return os << typeid(vector).name() << " of size " << vector.size();
}

template <>
inline std::ostream& operator<<(std::ostream& os, const Vector<char>& string)
{
    return os << string.data();
}
}

#endif