ALPS Home Libraries License Support People ALPS Web Site

PrevUpHomeNext

Chapter 12. Alps/HDF5 Library

Table of Contents

Reference
Header <alps/hdf5.hpp>
Examples

Reference

Header <alps/hdf5.hpp>


_HDF5USEDLL_
_HDF5USEHLDLL_
ALPS_HDF5_SZIP_BLOCK_SIZE
ALPS_HDF5_STRINGIFY(arg)
ALPS_HDF5_STRINGIFY_HELPER(arg)
ALPS_HDF5_THROW_ERROR(error, message)
ALPS_HDF5_THROW_RUNTIME_ERROR(message)
ALPS_HDF5_THROW_RANGE_ERROR(message)
ALPS_HDF5_DEFINE_VECTOR_TYPE(C)
ALPS_HDF5_FOREACH_SCALAR_NO_LONG_LONG(callback)
ALPS_HDF5_FOREACH_SCALAR(callback)
ALPS_HDF5_GET_STRING(U)
ALPS_HDF5_DEFINE_VECTOR_TYPE2(C)
namespace alps {
  template<typename T> 
    boost::disable_if< typename boost::mpl::and_< typename boost::is_same< typename boost::remove_cv< typename boost::remove_all_extents< T >::type >::type, char >::type, typename boost::is_array< T >::type >::type, hdf5::pvp< T & > >::type 
    make_pvp(std::string const & p, T & v);
  template<typename T> 
    boost::disable_if< typename boost::mpl::and_< typename boost::is_same< typename boost::remove_cv< typename boost::remove_all_extents< T >::type >::type, char >::type, typename boost::is_array< T >::type >::type, hdf5::pvp< T const & > >::type 
    make_pvp(std::string const & p, T const & v);
  template<typename T> 
    hdf5::pvp< std::pair< T *, std::vector< std::size_t > > > 
    make_pvp(std::string const & p, T * v, std::size_t s);
  template<typename T> 
    hdf5::pvp< std::pair< T *, std::vector< std::size_t > > > 
    make_pvp(std::string const & p, T * v, 
             std::vector< std::size_t > const & s);
  namespace hdf5 {
    template<typename T> struct serializable_type;
    template<typename T> struct native_type;
    template<typename T> struct is_native;
    template<typename T> struct is_cplx;

    template<> struct serializable_type<bool>;
    template<> struct native_type<bool>;
    template<> struct is_native<bool>;
    template<> struct is_native<bool const>;
    template<> struct serializable_type<std::string>;
    template<> struct native_type<std::string>;
    template<> struct is_native<std::string>;
    template<> struct is_native<std::string const>;
    template<> struct serializable_type<detail::internal_state_type::type>;
    template<> struct native_type<detail::internal_state_type::type>;
    template<> struct is_native<detail::internal_state_type::type>;
    template<> struct is_native<detail::internal_state_type::type const>;
    template<typename T> struct is_cplx<std::complex< T >>;
    template<typename T> struct serializable_type<std::complex< T >>;
    template<typename T> struct native_type<std::complex< T >>;
    template<typename T> struct is_native<std::complex< T >>;
    template<typename T> struct is_native<std::complex< T > const>;
    template<typename T> 
      struct serializable_type<std::pair< T *, std::vector< std::size_t > >>;
    template<typename T> 
      struct native_type<std::pair< T *, std::vector< std::size_t > >>;
    template<typename T> 
      struct is_cplx<std::pair< T *, std::vector< std::size_t > >>;

    class archive;
    class iarchive;
    class oarchive;
    template<typename T> class pvp;
    template<typename T> std::vector< hsize_t > call_get_extent(T const &);
    template<typename T> 
      void call_set_extent(T &, std::vector< std::size_t > const &);
    template<typename T> std::vector< hsize_t > call_get_offset(T const &);
    template<typename T> bool call_is_vectorizable(T const &);
    template<typename T, typename U> 
      U const * call_get_data(std::vector< U > &, T const &, 
                              std::vector< hsize_t > const &, 
                              boost::optional< std::vector< hsize_t > > const & t = boost::none_t());
    template<typename T, typename U> 
      void call_set_data(T &, std::vector< U > const &, 
                         std::vector< hsize_t > const &, 
                         std::vector< hsize_t > const &);
    template<typename T> std::vector< hsize_t > get_extent(T const &);
    template<typename T> 
      void set_extent(T &, std::vector< std::size_t > const &);
    template<typename T> std::vector< hsize_t > get_offset(T const &);
    template<typename T> bool is_vectorizable(T const &);
    template<typename T> 
      unspecified get_data(std::vector< typename serializable_type< T >::type > & m, 
                           T const & v, std::vector< hsize_t > const &, 
                           std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T, typename U> 
      void set_data(T & v, std::vector< U > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      boost::enable_if< typename boost::is_same< T, bool >::type, typename serializable_type< T >::type const * >::type 
      get_data(std::vector< serializable_type< bool >::type > & m, 
               T const & v, std::vector< hsize_t > const &, 
               std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T> 
      boost::enable_if< typename boost::is_same< T, std::string >::type, typename serializable_type< T >::type const * >::type 
      get_data(std::vector< serializable_type< std::string >::type > & m, 
               T const & v, std::vector< hsize_t > const &, 
               std::vector< hsize_t > const & t = std::vector< hsize_t >());
    template<typename T> 
      boost::disable_if< typename boost::mpl::or_< typename boost::is_same< T, std::complex< double > >::type, typename boost::is_same< T, char * >::type >::type >::type 
      set_data(std::string & v, std::vector< T > const & u, 
               std::vector< hsize_t > const & s, 
               std::vector< hsize_t > const & c);
    template<typename T> 
      unspecified get_data(unspecified m, T const & v, 
                           std::vector< hsize_t > const &, 
                           std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T> 
      void set_data(unspecified v, std::vector< T > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const &);
    template<typename T> bool is_vectorizable(std::complex< T > const &);
    template<typename T> 
      std::vector< hsize_t > get_offset(std::complex< T > const &);
    template<typename T> 
      void set_extent(std::complex< T > &, 
                      std::vector< std::size_t > const & s);
    template<typename T> 
      std::vector< hsize_t > get_extent(std::complex< T > const & v);
    template<typename T> 
      serializable_type< std::complex< T > >::type const * 
      get_data(std::vector< typename serializable_type< std::complex< T > >::type > & m, 
               std::complex< T > const & v, std::vector< hsize_t > const & s, 
               std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T, typename U> 
      boost::disable_if< typename boost::mpl::or_< typename boost::is_same< U, T >::type, typename boost::is_same< U, std::complex< T > >::type >::type >::type 
      set_data(std::complex< T > &, std::vector< U > const &, 
               std::vector< hsize_t > const &, 
               std::vector< hsize_t > const &);
    template<typename T> 
      void set_data(std::complex< T > & v, std::vector< T > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      void set_data(std::complex< T > & v, 
                    std::vector< std::complex< double > > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      std::vector< hsize_t > 
      get_extent(std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T> 
      void set_extent(std::pair< T *, std::vector< std::size_t > > & v, 
                      std::vector< std::size_t > const & s);
    template<typename T> 
      std::vector< hsize_t > 
      get_offset(std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T> 
      bool is_vectorizable(std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T> 
      serializable_type< std::pair< T *, std::vector< std::size_t > > >::type const * 
      get_data(std::vector< typename serializable_type< std::pair< T *, std::vector< std::size_t > > >::type > & m, 
               std::pair< T *, std::vector< std::size_t > > const & v, 
               std::vector< hsize_t > const & s, 
               std::vector< hsize_t > const & = std::vector< hsize_t >());
    template<typename T, typename U> 
      void set_data(std::pair< T *, std::vector< std::size_t > > & v, 
                    std::vector< U > const & u, 
                    std::vector< hsize_t > const & s, 
                    std::vector< hsize_t > const & c);
    template<typename T> 
      iarchive & call_serialize(iarchive & ar, std::string const & p, T & v);
    template<typename T> 
      oarchive & call_serialize(oarchive & ar, std::string const & p, 
                                T const & v);
    template<typename A, typename T> 
      A & serialize(A & ar, std::string const & p, T & v);
    template<typename T> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           std::complex< T > & v);
    template<typename T> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           std::complex< T > const & v);
    template<typename T> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           std::deque< T > & v);
    template<typename T> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           std::deque< T > const & v);
    template<typename T> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           std::pair< T *, std::vector< std::size_t > > & v);
    template<typename T> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           std::pair< T *, std::vector< std::size_t > > const & v);
    template<typename T, std::size_t N, typename A> 
      iarchive & serialize(iarchive & ar, std::string const & p, 
                           boost::multi_array< T, N, A > & v);
    template<typename T, std::size_t N, typename A> 
      oarchive & serialize(oarchive & ar, std::string const & p, 
                           boost::multi_array< T, N, A > const & v);
    template<typename T> 
      iarchive & operator>>(iarchive & ar, pvp< T > const & v);
    template<typename T> 
      oarchive & operator<<(oarchive & ar, pvp< T > const & v);
  }
}

Last revised: , at GMT


PrevUpHomeNext