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
// ===========================================================================
//
// Author: Eugen Wintersberger <eugen.wintersberger@gmail.com>
// 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();
    }

};

}

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);
    }

    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());
    }

};

}

}