container.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/util/memory_pool.hpp>
#include <kernel/lafem/base.hpp>
#include <kernel/util/type_traits.hpp>
#include <kernel/util/random.hpp>
#include <kernel/util/pack.hpp>
 
 
#include <vector>
#include <limits>
#include <cmath>
#include <typeinfo>
#include <string>
#include <type_traits>
#include <cstdlib>
#include <stdint.h>
 
namespace FEAT
{
  namespace LAFEM
  {
    class SerialConfig
    {
    private:
      CompressionModes elements_compression, indices_compression;
      FEAT::Real tolerance;
    public:
#ifdef FEAT_HAVE_ZLIB
      explicit SerialConfig() :
      elements_compression(CompressionModes::elements_zlib),
      indices_compression(CompressionModes::indices_zlib),
      tolerance(FEAT::Real(-1.))
#else
      explicit SerialConfig() :
      elements_compression(CompressionModes::elements_off),
      indices_compression(CompressionModes::indices_off),
      tolerance(FEAT::Real(-1.))
#endif
      {
      }
      explicit SerialConfig(bool zlib_compression, bool zfp_compression, FEAT::Real tol = FEAT::Real(-1.))
      {
        set_elements_compression(CompressionModes::elements_off);
        set_indices_compression(CompressionModes::indices_off);
        if(zlib_compression)
        {
          set_elements_compression(CompressionModes::elements_zlib);
          set_indices_compression(CompressionModes::indices_zlib);
        }
        if(zfp_compression)
        {
          set_tolerance(tol);
          set_elements_compression(CompressionModes::elements_zfp);
        }
      }
 
      void set_elements_compression(CompressionModes comp)
      {
        CompressionModes temp = comp & CompressionModes::elements_mask;
        switch(temp)
        {
          case CompressionModes::elements_off:
            break;
          case CompressionModes::elements_zlib:
#ifdef FEAT_HAVE_ZLIB
            break;
#else
            XABORTM("Zlib compression was enabled for elements, but zlib bibliography was not loaded. Please configure FEAT with -zlib flag!");
#endif
          case CompressionModes::elements_zfp:
#ifdef FEAT_HAVE_ZFP
            XASSERTM(tolerance > FEAT::Real(0.), "tolerance ist smaller or equall 0 while zfp is enabled!");
            break;
#else
            XABORTM("Zfp compression was enabled for elements, but zfp bibliography was not loaded. Please configure FEAT with -zfp flag!");
#endif
          default:
            XABORTM("No legal CompressionModes was given");
        }
        elements_compression = temp;
      }
      void set_indices_compression(CompressionModes comp)
      {
        CompressionModes temp = comp & CompressionModes::indices_mask;
        switch(temp)
        {
          case CompressionModes::indices_off:
            break;
          case CompressionModes::indices_zlib:
#ifdef FEAT_HAVE_ZLIB
            break;
#else
            XABORTM("Zlib compression was enabled for indices, but zlib bibliography was not loaded. Please configure FEAT with -zlib flag!");
#endif
          default:
            XABORTM("No legal CompressionModes was given");
        }
        indices_compression = temp;
      }
 
     void set_tolerance(FEAT::Real tol)
     {
       if(elements_compression == CompressionModes::elements_zfp)
       {
         XASSERTM(tol > FEAT::Real(0.), "Zfp enabled, but tolerance is smaller or equal to 0!");
       }
       tolerance = tol;
     }
     CompressionModes get_elements_compression() const
     {
       return elements_compression;
     }
 
     CompressionModes get_indices_compression() const
     {
       return indices_compression;
     }
 
     FEAT::Real get_tolerance() const
     {
       return tolerance;
     }
 
    }; //class SerialConfig
 
 
    template <typename DT_, typename IT_>
    class Container
    {
      template <typename DT2_, typename IT2_>
      friend class Container;
 
    protected:
      std::vector<DT_*> _elements;
      std::vector<IT_*> _indices;
      std::vector<Index> _elements_size;
      std::vector<Index> _indices_size;
      std::vector<Index> _scalar_index;
      std::vector<DT_> _scalar_dt;
      bool _foreign_memory;
 
      void _copy_content(const Container & other, bool full)
      {
        // avoid self-copy
        if(this == &other)
          return;
 
        XASSERTM(_elements.size() == other.get_elements().size(), "Container size mismatch!");
        XASSERTM(_indices.size() == other.get_indices().size(), "Container size mismatch!");
        XASSERTM(_scalar_index.size() == other.get_scalar_index().size(), "Container size mismatch!");
        XASSERTM(_scalar_dt.size() == other.get_scalar_dt().size(), "Container size mismatch!");
 
        if (full)
        {
          this->_scalar_index.assign(other._scalar_index.begin(), other._scalar_index.end());
          this->_scalar_dt.assign(other._scalar_dt.begin(), other._scalar_dt.end());
 
          for (Index i(0) ; i < _indices.size() ; ++i)
          {
            XASSERTM(_indices_size.at(i) == other.get_indices_size().at(i), "Container size mismatch!");
            MemoryPool::copy(_indices.at(i), other.get_indices().at(i), _indices_size.at(i));
          }
        }
 
        for (Index i(0) ; i < _elements.size() ; ++i)
        {
          XASSERTM(_elements_size.at(i) == other.get_elements_size().at(i), "Container size mismatch!");
          MemoryPool::copy(_elements.at(i), other.get_elements().at(i), _elements_size.at(i));
        }
 
      }
 
      template <typename DT2_, typename IT2_>
      void assign(const Container<DT2_, IT2_> & other)
      {
        XASSERTM(!other._foreign_memory, "assign/convert is forbidden with foreign memory source objects.");
        if (!this->_foreign_memory)
        {
          for (Index i(0) ; i < this->_elements.size() ; ++i)
            MemoryPool::release_memory(this->_elements.at(i));
          for (Index i(0) ; i < this->_indices.size() ; ++i)
            MemoryPool::release_memory(this->_indices.at(i));
        }
 
        this->_foreign_memory = false;
 
        this->_elements.clear();
        this->_indices.clear();
        this->_elements_size.clear();
        this->_indices_size.clear();
        this->_scalar_index.clear();
        this->_scalar_dt.clear();
 
        this->_elements_size.assign(other.get_elements_size().begin(), other.get_elements_size().end());
        this->_indices_size.assign(other.get_indices_size().begin(), other.get_indices_size().end());
        this->_scalar_index.assign(other.get_scalar_index().begin(), other.get_scalar_index().end());
        if constexpr (std::is_same<DT_, DT2_>::value)
        {
          this->_scalar_dt.assign(other.get_scalar_dt().begin(), other.get_scalar_dt().end());
 
        }
        else
        {
          for(auto t : other.get_scalar_dt())
          {
            this->_scalar_dt.push_back(DT_(t));
          }
        }
 
        if constexpr (std::is_same<DT_, DT2_>::value)
        {
          this->_elements.assign(other.get_elements().begin(), other.get_elements().end());
 
          for (Index i(0) ; i < this->_elements.size() ; ++i)
            MemoryPool::increase_memory(this->_elements.at(i));
        }
        else
        {
          for (Index i(0) ; i < this->_elements_size.size() ; ++i)
          {
            const Index tsize(this->_elements_size.at(i));
            this->_elements.push_back(MemoryPool::template allocate_memory<DT_>(tsize));
            MemoryPool::convert(this->_elements.at(i), other.get_elements().at(i), tsize);
          }
        }
 
        if constexpr (std::is_same<IT_, IT2_>::value)
        {
          this->_indices.assign(other.get_indices().begin(), other.get_indices().end());
 
          for (Index i(0) ; i < this->_indices.size() ; ++i)
            MemoryPool::increase_memory(this->_indices.at(i));
        }
        else
        {
          for (Index i(0) ; i < this->_indices_size.size() ; ++i)
          {
            const Index tsize(this->_indices_size.at(i));
            this->_indices.push_back(MemoryPool::template allocate_memory<IT_>(tsize));
            MemoryPool::convert(this->_indices.at(i), other.get_indices().at(i), tsize);
          }
        }
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      std::uint64_t _serialized_size(const LAFEM::SerialConfig& config = LAFEM::SerialConfig()) const
      {
        Container<DT2_, IT2_> tc(0);
        tc.assign(*this);
 
        std::uint64_t gsize(4 * sizeof(std::uint64_t)); //raw array size + magic number + type_index DT_ + type_index IT_
        gsize += 7 * sizeof(std::uint64_t); // size of all seven stl containers
        gsize += 2 * tc._elements_size.size() * sizeof(std::uint64_t); // _elements_size contents + _elements_arrays bytesize
        gsize += 2 * tc._indices_size.size() * sizeof(std::uint64_t); // _indices_size contents + _indizes_arrays bytesize
        gsize += tc._scalar_index.size() * sizeof(std::uint64_t); // _scalar_index contents
        gsize += tc._scalar_dt.size() * sizeof(DT2_); // _scalar_dt contents
 
        CompressionModes compress = config.get_elements_compression() | config.get_indices_compression();
        Pack::Type compression_type_elements = Pack::deduct_type<DT2_>();
        Pack::Type compression_type_index = Pack::deduct_type<IT2_>();
        if((compress & CompressionModes::elements_mask) == CompressionModes::elements_zfp) // If zfp is used for elements
        {
          compression_type_elements = compression_type_elements | Pack::Type::Mask_P;
        }
        else if((compress & CompressionModes::elements_mask) == CompressionModes::elements_zlib) //If zlib is used and zfp is not used elements
        {
          compression_type_elements = compression_type_elements | Pack::Type::Mask_Z;
        }
        if((compress & CompressionModes::indices_mask) == CompressionModes::indices_zlib) // If zlib is used for indices
            compression_type_index = compression_type_index | Pack::Type::Mask_Z;
 
 
        FEAT::Real tolerance = config.get_tolerance();
 
        for (Index i(0) ; i < tc._elements_size.size() ; ++i)
        {
          gsize += Pack::estimate_size(tc._elements_size.at(i), compression_type_elements, (double)tolerance); // upper_bound for (compressed) elements
        }
 
        for (Index i(0) ; i < tc._indices_size.size() ; ++i)
        {
          gsize += Pack::estimate_size(tc._indices_size.at(i), compression_type_index); // upper_bound for (compressed) indizes
        }
        gsize += 16; //padding for datatype alignment mismatch
 
        return gsize;
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      std::vector<char> _serialize(FileMode mode, const SerialConfig& config = SerialConfig()) const
      {
        std::uint64_t raw_size = 0u;
        FEAT::Real tolerance = config.get_tolerance();
 
        CompressionModes compress = config.get_elements_compression() | config.get_indices_compression();
        Pack::Type compression_type_elements = Pack::deduct_type<DT2_>();
        Pack::Type compression_type_index = Pack::deduct_type<IT2_>();
        if((compress & CompressionModes::elements_mask) == CompressionModes::elements_zfp) // If zfp is used for elements
        {
          compression_type_elements = compression_type_elements | Pack::Type::Mask_P;
        }
        else if((compress & CompressionModes::elements_mask) == CompressionModes::elements_zlib) //If zlib is used and zfp is not used elements
        {
          compression_type_elements = compression_type_elements | Pack::Type::Mask_Z;
        }
        if((compress & CompressionModes::indices_mask) == CompressionModes::indices_zlib) // If zlib is used for indices
            compression_type_index = compression_type_index | Pack::Type::Mask_Z;
 
        Container<DT2_, IT2_> tc(0);
        tc.assign(*this);
 
        std::uint64_t gsize = this->template _serialized_size<DT2_, IT2_>(config);
 
        std::vector<char> result((size_t(gsize)));
        char * array(result.data());
        std::uint64_t * uiarray(reinterpret_cast<std::uint64_t *>(array));
        DT2_ * dtarray(reinterpret_cast<DT2_ *>(array));
        IT2_ * itarray(reinterpret_cast<IT2_ *>(array));
 
        #if defined(FEAT_COMPILER_CLANG)
        std::uint64_t magic = (std::uint64_t)static_cast<__underlying_type(FileMode)>(mode);
        #else
        std::uint64_t magic = (std::uint64_t)static_cast<typename std::underlying_type<FileMode>::type>(mode);
        #endif
        uiarray[0] = gsize; //we will overwrite this at the end with the finalized data...
        uiarray[1] = magic;
        uiarray[2] = Type::Traits<DT_>::feature_hash();
        uiarray[3] = Type::Traits<IT_>::feature_hash();
        uiarray[4] = tc._elements.size();
        uiarray[5] = tc._indices.size();
        uiarray[6] = tc._elements_size.size();
        uiarray[7] = tc._indices_size.size();
        uiarray[8] = tc._scalar_index.size();
        uiarray[9] = tc._scalar_dt.size();
        uiarray[10] = (std::uint64_t)compress;
        raw_size += 11 * (std::uint64_t)sizeof(std::uint64_t);
 
        Index global_i(11); // count how many elements of std::uint64_t have been inserted so far
        Index local_elements(0); // count where elements array bytesize starts
        Index local_index(0); // same for index...
 
        for (Index i(0) ; i < tc._elements_size.size() ; ++i)
        {
          uiarray[i + global_i] = tc._elements_size.at(i);
        }
        global_i += Index(tc._elements_size.size());
        local_elements = global_i;
        for (Index i(0) ; i < tc._elements_size.size() ; ++i)
        {
          uiarray[i + global_i] = (std::uint64_t)0u; //placeholder, until we calculate the real data...
        }
        global_i += Index(tc._elements_size.size());
        raw_size += 2 * std::uint64_t(tc._elements_size.size()) * std::uint64_t(sizeof(std::uint64_t));
 
        for (Index i(0) ; i < tc._indices_size.size() ; ++i)
        {
          uiarray[i + global_i] = tc._indices_size.at(i);
        }
        global_i += Index(tc._indices_size.size());
        local_index = global_i;
        for (Index i(0) ; i < tc._indices_size.size() ; ++i)
        {
          uiarray[i + global_i] = 0;
        }
        global_i += Index(tc._indices_size.size());
        raw_size += 2 * std::uint64_t(tc._indices_size.size()) * std::uint64_t(sizeof(std::uint64_t));
 
        for (Index i(0) ; i < tc._scalar_index.size() ; ++i)
        {
          uiarray[i + global_i] = tc._scalar_index.at(i);
        }
        global_i += Index(tc._scalar_index.size());
        raw_size += std::uint64_t(tc._scalar_index.size()) * std::uint64_t(sizeof(std::uint64_t));
 
        global_i = Index((global_i * sizeof(std::uint64_t) + sizeof(DT2_) - 1u) / sizeof(DT2_)); // now counting how many DT2 have been inserted so far
 
        for (Index i(0) ; i < tc._scalar_dt.size() ; ++i)
        {
          dtarray[i + global_i] = tc._scalar_dt.at(i);
        }
        global_i += Index(tc._scalar_dt.size());
        raw_size += std::uint64_t(tc._scalar_dt.size()) * std::uint64_t(sizeof(DT2_));
 
        if((compress & CompressionModes::elements_mask) != CompressionModes::elements_off)
        {
          global_i = Index((global_i * sizeof(DT2_) + sizeof(char) - 1u) / sizeof(char)); // now counting how many bytes/chars have been inserted so far
          for (Index i(0) ; i < tc._elements.size() ; ++i)
          {
            char* dest = &result[global_i];
            std::size_t est_buff_size = Pack::estimate_size(tc._elements_size.at(i), compression_type_elements, (double)tolerance);
            std::size_t real_size = Pack::encode<DT2_>(dest, tc._elements.at(i), est_buff_size, tc._elements_size.at(i), compression_type_elements, false, (double)tolerance);
            XASSERTM(real_size != 0u, "could not encode elements");
            uiarray[i + local_elements] = (std::uint64_t)real_size; //save used memory for compressed array
            global_i += (Index)real_size; //go forward the number of bytes(chars)
            raw_size += (std::uint64_t)real_size * (std::uint64_t)sizeof(char);
          }
          global_i = Index((global_i * sizeof(char) + sizeof(DT2_) - 1u) / sizeof(DT2_)); // go back to DT2_ indexing
        }
        else
        {
          for (Index i(0) ; i < tc._elements.size() ; ++i)
          {
            std::memcpy(&dtarray[global_i], tc._elements.at(i), tc._elements_size.at(i) * sizeof(DT2_));
            uiarray[i + local_elements] = (std::uint64_t) tc._elements_size.at(i) * sizeof(DT2_);
            global_i += tc._elements_size.at(i);
            raw_size += (std::uint64_t) tc._elements_size.at(i) * sizeof(DT2_);
          }
        }
        if((compress & CompressionModes::indices_mask) != CompressionModes::indices_off)
        {
          global_i = Index((global_i * sizeof(DT2_) + sizeof(char) - 1u) / sizeof(char)); // now counting how many bytes/chars have been inserted so far
          for (Index i(0) ; i < tc._indices.size() ; ++i)
          {
            char* dest = &result[global_i];
            std::size_t est_buff_size = Pack::estimate_size(tc._indices_size.at(i), compression_type_index);
            std::size_t real_size = Pack::encode<IT2_>(dest, tc._indices.at(i), est_buff_size, tc._indices_size.at(i), compression_type_index, false);
            XASSERTM(real_size != 0u, "could not encode indices");
            uiarray[i + local_index] = (std::uint64_t) real_size;
            global_i += Index(real_size);
            raw_size += std::uint64_t(real_size) * std::uint64_t(sizeof(char));
          }
        }
        else
        {
          global_i = Index((global_i * sizeof(DT2_) + sizeof(IT2_) - 1u) / sizeof(IT2_)); // now counting IT2_ elements
          for (Index i(0) ; i < tc._indices.size() ; ++i)
          {
            std::memcpy(&itarray[global_i], tc._indices.at(i), tc._indices_size.at(i) * sizeof(IT2_));
            uiarray[i + local_index] = (std::uint64_t) tc._indices_size.at(i) * sizeof(IT2_);
            global_i += tc._indices_size.at(i);
            raw_size += (std::uint64_t) tc._indices_size.at(i) * sizeof(IT2_);
          }
        }
        uiarray[0] = raw_size + 16u; //padding
        //std::cout << "Compressed size is: " << uiarray[0] << "\n";
 
        result.resize(std::size_t(uiarray[0]));
        return result;
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      void _serialize(FileMode mode, std::ostream & file, const SerialConfig& config = SerialConfig()) const
      {
        auto temp(this->template _serialize<DT2_, IT2_>(mode, config));
        file.write(temp.data(), long(temp.size()));
        if (!file.good())
          XABORTM("Error in _serialize - file ostream is not good anymore!");
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      void _deserialize(FileMode mode, std::vector<char> & input)
      {
        this->clear();
        Container<DT2_, IT2_> tc(0);
        tc.clear();
 
        char * array(input.data());
        std::uint64_t * uiarray(reinterpret_cast<std::uint64_t *>(array));
        DT2_ * dtarray(reinterpret_cast<DT2_ *>(array));
        IT2_ * itarray(reinterpret_cast<IT2_ *>(array));
 
#if defined(FEAT_COMPILER_CLANG)
        std::uint64_t magic = (std::uint64_t)static_cast<__underlying_type(FileMode)>(mode);
#else
        std::uint64_t magic = (std::uint64_t)static_cast<typename std::underlying_type<FileMode>::type>(mode);
#endif
        XASSERTM(magic == uiarray[1], "_deserialize: given FileMode incompatible with given array!");
 
        //ensure that we have the same integral/floating type configuration, that was used when storing the serialized data
        XASSERT(Type::Traits<DT_>::is_int == Type::Helper::extract_intness(uiarray[2]));
        XASSERT(Type::Traits<DT_>::is_float == Type::Helper::extract_floatness(uiarray[2]));
        XASSERT(Type::Traits<DT_>::is_signed == Type::Helper::extract_signedness(uiarray[2]));
        XASSERT(Type::Traits<IT_>::is_int == Type::Helper::extract_intness(uiarray[3]));
        XASSERT(Type::Traits<IT_>::is_float == Type::Helper::extract_floatness(uiarray[3]));
        XASSERT(Type::Traits<IT_>::is_signed == Type::Helper::extract_signedness(uiarray[3]));
 
        if (sizeof(DT_) > Type::Helper::extract_type_size(uiarray[2]))
          std::cerr<<"Warning: You are reading a container floating point in higher precision then it was saved before!\n";
 
        if (sizeof(IT_) > Type::Helper::extract_type_size(uiarray[3]))
          std::cerr<<"Warning: You are reading a container integral type in higher precision then it was saved before!\n";
 
        CompressionModes compress = (CompressionModes)uiarray[10];
        //test whether system has right third_party software loaded:
#ifndef FEAT_HAVE_ZLIB
        XASSERTM((compress & CompressionModes::elements_mask) != CompressionModes::elements_zlib,
                 "Data was compressed with ZLIB! To read in data, please configure FEAT with zlib enabled.\n For more information see FEAT documentation.");
        XASSERTM((compress & CompressionModes::indices_mask) != CompressionModes::indices_zlib,
                 "Data was compressed with ZLIB! To read in data, please configure FEAT with zlib enabled.\n For more information see FEAT documentation.");
#endif
#ifndef FEAT_HAVE_ZFP
        XASSERTM((compress & CompressionModes::elements_mask) != CompressionModes::elements_zfp,
                 "Data was compressed with zfp! To read in data, please configure FEAT with zfp enabled.\n For more information see FEAT documentation.");
#endif
        std::vector<std::uint64_t> elements_bytes(uiarray[6]); //temp arrays to keep track of bytessize of compressed arrays
        std::vector<std::uint64_t> indices_bytes(uiarray[7]);
        Index global_i(11);
        for (std::uint64_t i(0) ; i < uiarray[6] ; ++i)
        {
          tc._elements_size.push_back(Index(uiarray[i + global_i]));
        }
        global_i += Index(uiarray[6]);
        for (std::uint64_t i(0) ; i < uiarray[6] ; ++i)
        {
          elements_bytes[i] = uiarray[i + global_i];
        }
        global_i += Index(uiarray[6]);
 
        for (std::uint64_t i(0) ; i < uiarray[7] ; ++i)
        {
          tc._indices_size.push_back(Index(uiarray[i + global_i]));
        }
        global_i += Index(uiarray[7]);
        for (std::uint64_t i(0) ; i < uiarray[7] ; ++i)
        {
          indices_bytes[i] = uiarray[i + global_i];
        }
        global_i += Index(uiarray[7]);
 
        for (std::uint64_t i(0) ; i < uiarray[8] ; ++i)
        {
          tc._scalar_index.push_back(Index(uiarray[i + global_i]));
        }
        global_i += Index(uiarray[8]);
 
        global_i = Index((global_i * sizeof(std::uint64_t) + sizeof(DT2_) - 1u) / sizeof(DT2_));
        for (std::uint64_t i(0) ; i < uiarray[9] ; ++i)
        {
          tc._scalar_dt.push_back(dtarray[i + global_i]);
        }
        global_i += Index(uiarray[9]);
 
        Pack::Type compression_type_elements = Pack::deduct_type<DT2_>();
        Pack::Type compression_type_index = Pack::deduct_type<IT2_>();
        if((compress & CompressionModes::elements_mask) == CompressionModes::elements_zfp)// If zfp is used
        {
          compression_type_elements = compression_type_elements | Pack::Type::Mask_P;
        }
        else if((compress & CompressionModes::elements_mask) == CompressionModes::elements_zlib) //If zlib is loaded and zfp is not used
        {
          compression_type_elements = compression_type_elements | Pack::Type::Mask_Z;
        }
        if((compress & CompressionModes::indices_mask) == CompressionModes::indices_zlib)
        {
          compression_type_index = compression_type_index | Pack::Type::Mask_Z;
        }
 
        if((compress & CompressionModes::elements_mask) != CompressionModes::elements_off)
        {
          global_i = Index((global_i * sizeof(DT2_) + sizeof(char) - 1u) / sizeof(char));
          for(Index i(0); i < Index(uiarray[4]); ++i)
          {
            tc._elements.push_back(MemoryPool::template allocate_memory<DT2_>(tc._elements_size.at(i)));
            if(0u == Pack::decode(tc._elements.at(i), &array[global_i], (std::size_t) tc._elements_size.at(i), (std::size_t) elements_bytes[i], compression_type_elements, false))
              XABORTM("Cannot decode compressed elements array");
            global_i += (Index)elements_bytes[i];
          }
          global_i = Index((global_i * sizeof(char) + sizeof(DT2_) - 1u) / sizeof(DT2_));
        }
        else
        {
          for (Index i(0) ; i < Index(uiarray[4]) ; ++i)
          {
            tc._elements.push_back(MemoryPool::template allocate_memory<DT2_>(tc._elements_size.at(i)));
            MemoryPool::template copy<DT2_>(tc._elements.at(i), &dtarray[global_i], tc._elements_size.at(i));
            global_i += tc._elements_size.at(i);
          }
        }
 
        if((compress & CompressionModes::indices_mask) != CompressionModes::indices_off)
        {
          global_i = Index((global_i * sizeof(DT2_) + sizeof(char) - 1u) / sizeof(char));
          for (Index i(0) ; i < Index(uiarray[5]) ; ++i)
          {
            tc._indices.push_back(MemoryPool::template allocate_memory<IT2_>(tc._indices_size.at(i)));
            if(0u == Pack::decode(tc._indices.at(i), &array[global_i], (std::size_t) tc._indices_size.at(i), (std::size_t) indices_bytes[i], compression_type_index, false))
              XABORTM("Cannot decode compressed indice array");
            global_i += (Index)indices_bytes[i];
          }
        }
        else
        {
          global_i = Index((global_i * sizeof(DT2_) + sizeof(IT2_) - 1u) / sizeof(IT2_));
          for (Index i(0) ; i < Index(uiarray[5]) ; ++i)
          {
            tc._indices.push_back(MemoryPool::template allocate_memory<IT2_>(tc._indices_size.at(i)));
            MemoryPool::template copy<IT2_>(tc._indices.at(i), &itarray[global_i], tc._indices_size.at(i));
            global_i += tc._indices_size.at(i);
          }
        }
 
        this->assign(tc);
      }
 
      template <typename DT2_ = DT_, typename IT2_ = IT_>
      void _deserialize(FileMode mode, std::istream & file)
      {
        std::uint64_t tsize;
        file.read((char *)&tsize, (long)(sizeof(std::uint64_t)));
        std::vector<char> temp((size_t(tsize)));
        file.seekg(-(long)sizeof(std::uint64_t), file.cur);
        file.read(temp.data(), (long)(tsize));
        if (!file.good())
          XABORTM("Error in _deserialize - file istream is not good anymore!");
        this->template _deserialize<DT2_, IT2_>(mode, temp);
      }
 
    public:
      explicit Container(Index size_in) :
        _foreign_memory(false)
      {
        _scalar_index.push_back(size_in);
      }
 
      virtual ~Container()
      {
        if(! _foreign_memory)
        {
          for (Index i(0) ; i < _elements.size() ; ++i)
            MemoryPool::release_memory(_elements.at(i));
          for (Index i(0) ; i < _indices.size() ; ++i)
            MemoryPool::release_memory(_indices.at(i));
        }
      }
 
      Container(Container && other) :
        _elements(std::move(other._elements)),
        _indices(std::move(other._indices)),
        _elements_size(std::move(other._elements_size)),
        _indices_size(std::move(other._indices_size)),
        _scalar_index(std::move(other._scalar_index)),
        _scalar_dt(std::move(other._scalar_dt)),
        _foreign_memory(other._foreign_memory)
      {
        other._elements.clear();
        other._indices.clear();
        other._elements_size.clear();
        other._indices_size.clear();
        other._scalar_index.clear();
        other._scalar_dt.clear();
      }
 
      void format(DT_ value = DT_(0))
      {
        for (Index i(0) ; i < _elements.size() ; ++i)
          MemoryPool::set_memory(_elements.at(i), value, _elements_size.at(i));
      }
 
      void format(Random & rng, DT_ min, DT_ max)
      {
        for (Index e(0) ; e < _elements.size() ; ++e)
        {
          MemoryPool::set_memory(rng, min, max, this->_elements.at(e), this->_elements_size.at(e));
        }
      }
 
      virtual void clear()
      {
        if (! _foreign_memory)
        {
          for (Index i(0) ; i < _elements.size() ; ++i)
            MemoryPool::release_memory(this->_elements.at(i));
          for (Index i(0) ; i < _indices.size() ; ++i)
            MemoryPool::release_memory(this->_indices.at(i));
        }
 
        this->_elements.clear();
        this->_indices.clear();
        this->_elements_size.clear();
        this->_indices_size.clear();
        this->_scalar_index.clear();
        this->_scalar_dt.clear();
        this->_foreign_memory = false;
      }
 
      void clone(const Container & other, CloneMode clone_mode = CloneMode::Weak)
      {
        if (this == &other)
        {
          XABORTM("Trying to self-clone a lafem container!");
        }
 
        XASSERTM(other._foreign_memory == false || clone_mode == CloneMode::Deep, "Must use deep cloning with ranged based source containers");
 
        this->clear();
 
        this->_scalar_index.assign(other._scalar_index.begin(), other._scalar_index.end());
        this->_scalar_dt.assign(other._scalar_dt.begin(), other._scalar_dt.end());
        this->_elements_size.assign(other._elements_size.begin(), other._elements_size.end());
        this->_indices_size.assign(other._indices_size.begin(), other._indices_size.end());
 
 
        if (clone_mode == CloneMode::Deep || clone_mode == CloneMode::Allocate)
        {
          for (Index i(0) ; i < other._indices.size() ; ++i)
          {
            this->_indices.push_back(MemoryPool::template allocate_memory<IT_>(this->_indices_size.at(i)));
            if (clone_mode == CloneMode::Deep)
              MemoryPool::template copy<IT_>(this->_indices.at(i), other._indices.at(i), this->_indices_size.at(i));
          }
 
          for (Index i(0) ; i < other._elements.size() ; ++i)
          {
            this->_elements.push_back(MemoryPool::template allocate_memory<DT_>(this->_elements_size.at(i)));
            if (clone_mode == CloneMode::Deep)
              MemoryPool::template copy<DT_>(this->_elements.at(i), other._elements.at(i), this->_elements_size.at(i));
          }
 
          return;
        }
        else
        {
          this->_indices.assign(other._indices.begin(), other._indices.end());
          for (Index i(0) ; i < this->_indices.size() ; ++i)
            MemoryPool::increase_memory(this->_indices.at(i));
        }
 
        if(clone_mode == CloneMode::Shallow)
        {
          this->_elements.assign(other._elements.begin(), other._elements.end());
          for (Index i(0) ; i < this->_elements.size() ; ++i)
            MemoryPool::increase_memory(this->_elements.at(i));
 
          return;
        }
        else if(clone_mode == CloneMode::Layout)
        {
          for (Index i(0) ; i < other._elements.size() ; ++i)
          {
            this->_elements.push_back(MemoryPool::template allocate_memory<DT_>(this->_elements_size.at(i)));
          }
 
          return;
        }
        else if(clone_mode == CloneMode::Weak)
        {
          for (Index i(0) ; i < other._elements.size() ; ++i)
          {
            this->_elements.push_back(MemoryPool::template allocate_memory<DT_>(this->_elements_size.at(i)));
            MemoryPool::template copy<DT_>(this->_elements.at(i), other._elements.at(i), this->_elements_size.at(i));
          }
 
          return;
        }
      }
 
      template <typename DT2_, typename IT2_>
      void clone(const Container<DT2_, IT2_> & other, CloneMode clone_mode = CloneMode::Weak)
      {
        Container t(other.size());
        t.assign(other);
        clone(t, clone_mode);
      }
 
      void move(Container && other)
      {
        if (this == &other)
          return;
 
        if (!this->_foreign_memory)
        {
          for (Index i(0) ; i < this->_elements.size() ; ++i)
            MemoryPool::release_memory(this->_elements.at(i));
          for (Index i(0) ; i < this->_indices.size() ; ++i)
            MemoryPool::release_memory(this->_indices.at(i));
        }
 
        this->_elements = std::move(other._elements);
        this->_indices = std::move(other._indices);
        this->_elements_size = std::move(other._elements_size);
        this->_indices_size = std::move(other._indices_size);
        this->_scalar_index = std::move(other._scalar_index);
        this->_scalar_dt = std::move(other._scalar_dt);
 
        other._elements.clear();
        other._indices.clear();
        other._elements_size.clear();
        other._indices_size.clear();
 
        this->_foreign_memory = other._foreign_memory;
      }
 
      std::uint64_t get_checkpoint_size(const LAFEM::SerialConfig& config)
      {
        return this->template _serialized_size<>(config);
      }
 
      void restore_from_checkpoint_data(std::vector<char> & data)
      {
        this->template _deserialize<>(FileMode::fm_binary, data);
      }
 
      std::uint64_t set_checkpoint_data(std::vector<char>& data, const LAFEM::SerialConfig& config)
      {
        auto buffer = this->template _serialize<>(FileMode::fm_binary, config);
        data.insert(std::end(data), std::begin(buffer), std::end(buffer));
        return std::uint64_t(buffer.size());
      }
 
      std::size_t bytes() const
      {
        std::size_t tbytes(0);
 
        for (Index i(0) ; i < _elements_size.size() ; ++i)
        {
          tbytes += std::size_t(_elements_size.at(i) * sizeof(DT_));
        }
 
        for (Index i(0) ; i < _indices_size.size() ; ++i)
        {
          tbytes += std::size_t(_indices_size.at(i) * sizeof(IT_));
        }
 
        tbytes += std::size_t(_scalar_index.size() * sizeof(Index));
        tbytes += std::size_t(_scalar_dt.size() * sizeof(DT_));
 
        return tbytes;
      }
 
 
      const std::vector<DT_*> & get_elements() const
      {
        return _elements;
      }
 
      const std::vector<IT_*> & get_indices() const
      {
        return _indices;
      }
 
      const std::vector<Index> & get_elements_size() const
      {
        return _elements_size;
      }
 
      const std::vector<Index> & get_indices_size() const
      {
        return _indices_size;
      }
 
      const std::vector<Index> & get_scalar_index() const
      {
        return _scalar_index;
      }
 
      const std::vector<DT_> & get_scalar_dt() const
      {
        return _scalar_dt;
      }
 
      template <Perspective = Perspective::native>
      Index size() const
      {
        if (_scalar_index.size() > 0)
          return _scalar_index.at(0);
        else
          return Index(0);
      }
 
      template <Perspective = Perspective::native>
      Index used_elements() const
      {
        return this->size();
      }
 
      bool empty() const
      {
        return (this->size() == Index(0));
      }
 
      static String name()
      {
        return "Container";
      }
    };
  } // namespace LAFEM
} // namespace FEAT