array_adapter.hpp

Go to the documentation of this file.

//
// (c) Copyright 2018 DESY,ESS
//
// This file is part of h5cpp.
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation; either version 2.1 of the License, or
// (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
// License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the
// Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor
// Boston, MA  02110-1301 USA
// ===========================================================================
//
// Authors: Eugen Wintersberger <eugen.wintersberger@gmail.com>
//          Jan Kotanski <jan.kotanski@desy.de>
// Created on: Jul 1, 2018
//
#pragma once
 
#include <cstdint>
#include <vector>
 
#include <h5cpp/core/types.hpp>
#include <h5cpp/dataspace/type_trait.hpp>
#include <h5cpp/datatype/type_trait.hpp>
 
namespace hdf5 {
 
template<typename T> class ArrayAdapter
{
  private:
    T *data_;
    size_t size_;
 
    void reset() noexcept
    {
      data_ = nullptr;
      size_ = 0;
    }
 
  public:
    ArrayAdapter():
      data_(nullptr),
      size_(0)
    {}
 
    ArrayAdapter(T *data,size_t size):
      data_(data),
      size_(size)
    {}
 
    ArrayAdapter(const ArrayAdapter<T> &adapter);
 
    ArrayAdapter(ArrayAdapter<T> &&adapter);
 
    ArrayAdapter<T> &operator=(const ArrayAdapter<T> &adapter);
 
    ArrayAdapter<T> &operator=(ArrayAdapter<T> &&adapter);
 
    size_t size() const noexcept
    {
      return size_;
    }
 
    T *data() noexcept
    {
      return data_;
    }
 
    const T *data() const noexcept
    {
      return data_;
    }
};
 
template<typename T>
ArrayAdapter<T>::ArrayAdapter(const ArrayAdapter<T> &adapter):
  data_(adapter.data_),
  size_(adapter.size_)
{
}
 
template<typename T>
ArrayAdapter<T>::ArrayAdapter(ArrayAdapter<T> &&adapter):
  data_(adapter.data_),
  size_(adapter.size_)
{
  //declare the original adapter instance as invalid
  adapter.reset();
}
 
template<typename T>
ArrayAdapter<T> &ArrayAdapter<T>::operator=(const ArrayAdapter<T> &adapter)
{
  if(this == &adapter)
    return *this;
 
  data_ = adapter.data_;
  size_ = adapter.size_;
  return *this;
}
 
template<typename T>
ArrayAdapter<T> &ArrayAdapter<T>::operator=(ArrayAdapter<T> &&adapter)
{
  if(this == &adapter)
    return *this;
 
  data_ = adapter.data_;
  size_ = adapter.size_;
  adapter.reset();
 
  return *this;
}
 
 
template<typename T>
Dimensions get_dimensions(const ArrayAdapter<T> adapter)
{
  return Dimensions{adapter.size()};
}
 
 
namespace datatype {
 
template<typename T>
class TypeTrait<ArrayAdapter<T>>
{
  public:
    using TypeClass = typename TypeTrait<T>::TypeClass;
 
    static TypeClass create(const ArrayAdapter<T> & = ArrayAdapter<T>())
    {
      return TypeTrait<T>::create();
    }
    const static TypeClass & get(const ArrayAdapter<T> & = ArrayAdapter<T>()) {
      const static TypeClass & cref_ = create();
      return cref_;
    }
 
};
 
}
 
namespace dataspace {
 
template<typename T>
class TypeTrait<ArrayAdapter<T>>
{
  public:
    using DataspaceType = Simple;
 
    static DataspaceType create(const ArrayAdapter<T> &adapter)
    {
      Dimensions adapter_dimensions = get_dimensions(adapter);
      return Simple(adapter_dimensions,adapter_dimensions);
    }
 
    const static DataspaceType & get(const ArrayAdapter<T> &adapter, dataspace::DataspacePool &) {
      Dimensions adapter_dimensions = get_dimensions(adapter);
      const static DataspaceType & cref_ = Simple(adapter_dimensions,adapter_dimensions);
      return cref_;
    }
 
    static void* ptr(ArrayAdapter<T> &adapter)
    {
      return reinterpret_cast<void*>(adapter.data());
    }
 
    static const void *cptr(const ArrayAdapter<T> &adapter)
    {
      return reinterpret_cast<const void*>(adapter.data());
    }
 
};
 
}
 
}