hdfbufferfactory.hh

Go to the documentation of this file.

 
#ifndef UTOPIA_DATAIO_HDFBUFFERFACTORY_HH
#define UTOPIA_DATAIO_HDFBUFFERFACTORY_HH
 
#include <vector>
 
#include <hdf5.h>
 
#include <boost/multi_array.hpp>
 
#include "hdftype.hh"
#include "hdfutilities.hh"
 
namespace Utopia
{
namespace DataIO
{
class HDFBufferFactory
{
  private:
 
    std::shared_ptr< spdlog::logger > _log;
 
  public:
    template < typename T >
    static auto
    convert_source(T& source)
    {
        if constexpr (std::is_same_v< T, std::string >)
        {
            return source.c_str();
        }
        else
        {
            hvl_t value;
            value.len = source.size();
            value.p   = &(source[0]);
            return value;
        }
    }
 
    template < typename Iter, typename Adaptor >
    static auto
    buffer(Iter begin, Iter end, Adaptor&& adaptor)
    {
        using T = Utils::remove_qualifier_t< decltype(adaptor(*begin)) >;
        if constexpr (Utils::is_container_v< T >)
        {
            
            // set up buffer
            if constexpr (Utils::is_array_like_v< T >)
            {
                std::vector< T > data_buffer(std::distance(begin, end));
                auto             buffer_begin = data_buffer.begin();
                for (; begin != end; ++begin, ++buffer_begin)
                {
                    *buffer_begin = adaptor(*begin);
                }
                return data_buffer;
            }
            else
            {
                std::vector< hvl_t > data_buffer(std::distance(begin, end));
 
                auto buffer_begin = data_buffer.begin();
                for (; begin != end; ++begin, ++buffer_begin)
                {
                    *buffer_begin = convert_source(adaptor(*begin));
                }
 
                return data_buffer;
            }
        }
        else if constexpr (std::is_same_v< T, std::string >)
        {
            // set up buffer
 
            std::vector< const char* > data_buffer(std::distance(begin, end));
 
            auto buffer_begin = data_buffer.begin();
            for (auto it = begin; it != end; ++it, ++buffer_begin)
            {
                *buffer_begin = convert_source(adaptor(*it));
            }
 
            return data_buffer;
        }
 
        else
        { // not a container
            // set up buffer
            std::vector< T > data_buffer(std::distance(begin, end));
 
            // make buffer
            auto buffer_begin = data_buffer.begin();
            for (; begin != end; ++begin, ++buffer_begin)
            {
                *buffer_begin = adaptor(*begin);
            }
            return data_buffer;
        }
    }
};
 
} // namespace DataIO
} // namespace Utopia
 
#endif