tools::hdf5::store Class Reference

Inheritance diagram for tools::hdf5::store:

Public Member Functions
	store (std::ostream &a_out, hid_t a_group, const std::string &a_name, bool a_write, unsigned int a_compress)
virtual	~store ()
std::ostream &	out () const
bool	entries (tools::uint64 &a_entries) const
pages *	create_pages (const std::string &a_name, const std::string &a_form)
hid_t	group () const
unsigned int	compress_level () const

Protected Member Functions
	store (const store &a_from)
store &	operator= (const store &)

Protected Attributes
std::ostream &	m_out
std::string	m_name
bool	m_write
unsigned int	m_compress
hid_t	m_group
std::vector< pages * >	m_pagess

Detailed Description

Definition at line 15 of file store.

Constructor & Destructor Documentation

store() [1/2]

tools::hdf5::store::store ( std::ostream &  a_out, hid_t  a_group, const std::string &  a_name, bool  a_write, unsigned int  a_compress  )

inline

Definition at line 19 of file store.

  :m_out(a_out)
  ,m_write(a_write)
  ,m_compress(a_compress) //used at write.
  ,m_group(-1)
  {
#ifdef TOOLS_MEM
    tools::mem::increment(s_class().c_str());
#endif
    if(m_write) {
      if(a_name.empty()) {
        a_out << "tools::hdf5::store::store : string a_name is empty." << std::endl;
        m_group = -1;
        return;
      }
      m_group = tools_H5Gcreate(a_group,a_name.c_str(),0);
      if(m_group<0) {
        a_out << "tools::hdf5::store::store : can't create " << a_name << " group." << std::endl;
        m_group = -1;
        return;
      }
      if(!write_atb(m_group,"type","object")) {
        m_out << "tools::hdf5::store::store : write_atb(type) failed." << std::endl;
        ::H5Gclose(m_group);
        m_group = -1;
        return;
      }
      if(!write_atb(m_group,"class",s_class())) {
        m_out << "tools::hdf5::store::store : write_atb(class) failed." << std::endl;
        ::H5Gclose(m_group);
        m_group = -1;
        return;
      }
      int v = 2; //1->2 add "type" atb.
      if(!write_scalar_atb<int>(m_group,"version",v)) {
        m_out << "tools::hdf5::store::store : write_scalar_atb(version) failed." << std::endl;
        ::H5Gclose(m_group);
        m_group = -1;
        return;
      }
    } else { // to read.
      m_group = tools_H5Gopen(a_group,a_name.c_str());
      if(m_group<0) {
        a_out << "tools::hdf5::store::store : can't open " << a_name << " group." << std::endl;
        m_group = -1;
        return;
      }
      std::vector<std::string> names;
      if(!read_array_string(m_group,s_names(),names)) {
        m_out << "tools::hdf5::store::store : read_array_string(names) failed." << std::endl;
        ::H5Gclose(m_group);
        m_group = -1;
    return;
      }
      std::vector<std::string> TFORMs;
      if(!read_array_string(m_group,s_forms(),TFORMs)) {
        m_out << "tools::hdf5::store::store : read_array_string(tforms) failed." << std::endl;
        ::H5Gclose(m_group);
        m_group = -1;
    return;
      }
      if(names.size()!=TFORMs.size()) {
        m_out << "tools::hdf5::store::store : names/TFORMs size mismatch." << std::endl;
        m_out << "names :" << std::endl;
       {tools_vforcit(std::string,names,it) m_out << *it << std::endl;}
        m_out << "TFORMs :" << std::endl;
       {tools_vforcit(std::string,TFORMs,it) m_out << *it << std::endl;}
        ::H5Gclose(m_group);
        m_group = -1;
    return;
      }
      for(size_t index=0;index<names.size();index++) {
        if(!create_pages(names[index],TFORMs[index])) {
          m_out << "tools::hdf5::store::store : can't create hdf5_column "
                << tools::sout(names[index]) << "." << std::endl;
          tools::safe_clear(m_pagess);
          ::H5Gclose(m_group);
          m_group = -1;
          return;
        }
      }
    }
  }

~store()

virtual tools::hdf5::store::~store ( )

inlinevirtual

Definition at line 102 of file store.

                  {
    if(m_write) {
      tools::uint64 _entries;
      if(!entries(_entries)) {
        m_out << "tools::hdf5::store::~store : not same entries on all columns. Write 0." << std::endl;
      }
      if(m_group<0) { //constructor may have failed.
      } else {
        if(!write_scalar<tools::uint64>(m_group,s_entries(),_entries)) {
          m_out << "tools::hdf5::store::~store : write_scalar(entries) failed." << std::endl;
        }
        if(!write_scalar<unsigned int>(m_group,s_columns(),m_pagess.size())) {
          m_out << "tools::hdf5::store::~store : write_scalar(columns) failed." << std::endl;
        }
       {std::vector<std::string> names;
        tools_vforcit(pages*,m_pagess,it) names.push_back((*it)->name());
     //{m_out << "debug : write : names :" << std::endl;
     // tools_vforcit(std::string,names,it) m_out << *it << std::endl;}
        if(!write_array_string(m_group,s_names(),names)) {
          m_out << "tools::hdf5::store::~store : write_array_string(names) failed." << std::endl;
        }}
       {std::vector<std::string> TFORMs;
        tools_vforcit(pages*,m_pagess,it) TFORMs.push_back((*it)->form());
     //{m_out << "debug : write : TFORMs :" << std::endl;
     // tools_vforcit(std::string,TFORMs,it) m_out << *it << std::endl;}
        if(!write_array_string(m_group,s_forms(),TFORMs)) {
          m_out << "tools::hdf5::store::~store : write_array_string(tforms) failed." << std::endl;
        }}
      }
    }
    tools::safe_clear(m_pagess);
    if(m_group<0) { //constructor may have failed.
    } else {
      ::H5Gclose(m_group);
    }
#ifdef TOOLS_MEM
    tools::mem::decrement(s_class().c_str());
#endif
  }

store() [2/2]

tools::hdf5::store::store ( const store &  a_from )

inlineprotected

Definition at line 142 of file store.

  :m_out(a_from.m_out)
  ,m_name(a_from.m_name)
  ,m_compress(a_from.m_compress)
  ,m_group(-1)
  {
#ifdef TOOLS_MEM
    tools::mem::increment(s_class().c_str());
#endif
  }

Member Function Documentation

compress_level()

unsigned int tools::hdf5::store::compress_level ( ) const

inline

Definition at line 193 of file store.

{return m_compress;}

create_pages()

pages* tools::hdf5::store::create_pages ( const std::string &  a_name, const std::string &  a_form  )

inline

Definition at line 171 of file store.

                                                                       {
    //::printf("debug : create_pages %s %s\n",a_name.c_str(),a_form.c_str());
    pages* _pages = new pages(m_out,m_group,a_name,a_form,m_write,m_compress);
    if(!_pages->is_valid()) {
      m_out << "tools::hdf5::store::create_column : can't create pages." << std::endl;
      delete _pages;
      return 0;
    }
    m_pagess.push_back(_pages);
    return _pages;
  }

entries()

bool tools::hdf5::store::entries ( tools::uint64 &  a_entries ) const

inline

Definition at line 157 of file store.

                                             {
    if(m_pagess.empty()) {a_entries = 0;return true;}
    a_entries = m_pagess.front()->entries();
    tools_vforcit(pages*,m_pagess,it) {
      if((*it)->entries()!=a_entries) {
        m_out << "tools::hdf5::store::entries : not same entries on all columns."
          << " Front " << a_entries << ", it " << (*it)->entries() << "." << std::endl;
        a_entries = 0;
    return false;
      }
    }
    return true;
  }

group()

hid_t tools::hdf5::store::group ( ) const

inline

Definition at line 192 of file store.

{return m_group;}

operator=()

store& tools::hdf5::store::operator= ( const store &  )

inlineprotected

Definition at line 152 of file store.

{return *this;}

out()

std::ostream& tools::hdf5::store::out ( ) const

inline

Definition at line 154 of file store.

{return m_out;}

Member Data Documentation

m_compress

unsigned int tools::hdf5::store::m_compress

protected

Definition at line 198 of file store.

m_group

hid_t tools::hdf5::store::m_group

protected

Definition at line 199 of file store.

m_name

std::string tools::hdf5::store::m_name

protected

Definition at line 196 of file store.

m_out

std::ostream& tools::hdf5::store::m_out

protected

Definition at line 195 of file store.

m_pagess

std::vector<pages*> tools::hdf5::store::m_pagess

protected

Definition at line 200 of file store.

m_write

bool tools::hdf5::store::m_write

protected

Definition at line 197 of file store.

---

The documentation for this class was generated from the following file:

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/hdf5/store