tools::wroot::directory Class Reference

Inheritance diagram for tools::wroot::directory:

Collaboration diagram for tools::wroot::directory:

Public Member Functions
virtual ifile &	file ()
virtual seek	seek_directory () const
virtual void	append_object (iobject *a_object)
	directory (ifile &a_file)
	directory (ifile &a_file, const std::string &a_name, const std::string &a_title)
	directory (ifile &a_file, directory *a_parent, const std::string &a_name, const std::string &a_title)
virtual	~directory ()
bool	is_valid () const
void	set_seek_directory (seek a_seek)
directory *	mkdir (const std::string &a_name, const std::string &a_title="")
void	set_nbytes_name (uint32 a_n)
uint32	record_size () const
bool	close ()
bool	to_buffer (wbuf &a_wb)
bool	write (uint32 &a_nbytes)
void	clear_dirs ()
void	clear_objs ()
const std::list< key * > &	keys () const
Public Member Functions inherited from tools::wroot::idir
virtual	~idir ()

Static Public Member Functions
static const std::string &	s_class ()

Protected Member Functions
	directory (const directory &a_from)
directory &	operator= (const directory &)
void	clear_keys ()
bool	save ()
bool	save_self ()
key *	find_key (const std::string &a_name)
seek	seek_keys () const
uint16	append_key (key *a_key)
bool	write_keys ()
bool	write_header ()
bool	write_object (iobject &a_obj, uint32 &a_nbytes)

Protected Attributes
ifile &	m_file
directory *	m_parent
bool	m_is_valid
std::string	m_name
std::string	m_title
std::vector< directory * >	m_dirs
std::vector< iobject * >	m_objs
std::list< key * >	m_keys
date	m_date_C
date	m_date_M
uint32	m_nbytes_keys
uint32	m_nbytes_name
seek	m_seek_directory
seek	m_seek_parent
seek	m_seek_keys

Detailed Description

Definition at line 26 of file directory.

Constructor & Destructor Documentation

directory() [1/4]

tools::wroot::directory::directory ( ifile &  a_file )

inline

Definition at line 38 of file directory.

  :m_file(a_file)
  ,m_parent(0)
  ,m_is_valid(false)
  ,m_date_C(0)
  ,m_date_M(0)
  ,m_nbytes_keys(0)
  ,m_nbytes_name(0)
  ,m_seek_directory(0)
  ,m_seek_parent(0)
  ,m_seek_keys(0)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

directory() [2/4]

tools::wroot::directory::directory ( ifile &  a_file, const std::string &  a_name, const std::string &  a_title  )

inline

Definition at line 54 of file directory.

  :m_file(a_file)
  ,m_parent(0)
  ,m_is_valid(false)
  ,m_name(a_name)
  ,m_title(a_title)
  ,m_nbytes_keys(0)
  ,m_nbytes_name(0)
  ,m_seek_directory(0)
  ,m_seek_parent(0)
  ,m_seek_keys(0)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    m_date_C = get_date();
    m_date_M = get_date();
 
    if(m_name.empty()) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " directory name cannot be \"\"."
                   << std::endl;
      return; //FIXME : throw
    }
    if(m_name.find('/')!=std::string::npos) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " directory name " << sout(m_name)
                   << " cannot contain a slash."
                   << std::endl;
      return; //FIXME : throw
    }
    if(m_title.empty()) m_title = m_name;
    m_is_valid = true;
  }

directory() [3/4]

tools::wroot::directory::directory ( ifile &  a_file, directory *  a_parent, const std::string &  a_name, const std::string &  a_title  )

inline

Definition at line 88 of file directory.

  :m_file(a_file)
  ,m_parent(a_parent)
  ,m_is_valid(false)
  ,m_name(a_name)
  ,m_title(a_title)
  ,m_nbytes_keys(0)
  ,m_nbytes_name(0)
  ,m_seek_directory(0)
  ,m_seek_parent(0)
  ,m_seek_keys(0)
  {
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
    m_date_C = get_date();
    m_date_M = get_date();
 
    if(m_name.empty()) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " directory name cannot be \"\"."
                   << std::endl;
      return; //FIXME : throw
    }
    if(m_name.find('/')!=std::string::npos) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " directory name " << sout(m_name)
                   << " cannot contain a slash."
                   << std::endl;
      return; //FIXME : throw
    }
 
    if(m_title.empty()) m_title = m_name;
 
    if(m_parent->find_key(m_name)) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " directory " << sout(m_name) << " exists already."
                   << std::endl;
      return; //FIXME : throw
    }
 
    m_seek_parent = m_parent->seek_directory();
    uint32 nbytes = record_size();
 
    wroot::key* key = new wroot::key(m_file.out(),m_file,m_parent->seek_directory(),
                                     m_name,m_title,"TDirectory",nbytes); // It does a m_file.set_END().
    m_nbytes_name = key->key_length();
    m_seek_directory = key->seek_key(); //at EOF
    if(!m_seek_directory) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " bad key."
                   << std::endl;
      delete key;
      return; //FIXME : throw
    }
   {char* buffer = key->data_buffer();
    wbuf wb(m_file.out(),m_file.byte_swap(),key->eob(),buffer);
    if(!to_buffer(wb)) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " directory name " << sout(m_name)
                   << " cannot fill buffer."
                   << std::endl;
      delete key;
      return; //FIXME : throw
    }}
    uint16 cycle = m_parent->append_key(key);
    key->set_cycle(cycle);
    if(!key->write_self(m_file)) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " key.write_self() failed."
                   << std::endl;
      return; //FIXME : throw
    }
    uint32 n;
    if(!key->write_file(m_file,n)) {
      m_file.out() << "tools::wroot::directory::directory :"
                   << " directory name " << sout(m_name)
                   << " cannot write key to file."
                   << std::endl;
      return; //FIXME : throw
    }
 
    m_is_valid = true;
  }

~directory()

virtual tools::wroot::directory::~directory ( )

inlinevirtual

Definition at line 175 of file directory.

                      {
    clear_dirs();
    clear_objs();
    clear_keys();
#ifdef TOOLS_MEM
    mem::decrement(s_class().c_str());
#endif
  }

directory() [4/4]

tools::wroot::directory::directory ( const directory &  a_from )

inlineprotected

Definition at line 184 of file directory.

  :idir(a_from)
  ,m_file(a_from.m_file)
  ,m_parent(0)
  ,m_is_valid(false){
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

Member Function Documentation

append_key()

uint16 tools::wroot::directory::append_key ( key *  a_key )

inlineprotected

Definition at line 380 of file directory.

                               { //take ownership of a_key
    tools_lforit(key*,m_keys,it) {
      if((*it)->object_name()==a_key->object_name()) {
        m_keys.insert(it,a_key); //a_key will be before *it.
        return ((*it)->cycle() + 1);
      }
    }
    // Not found :
    m_keys.push_back(a_key);
    return 1;
  }

append_object()

virtual void tools::wroot::directory::append_object ( iobject *  a_object )

inlinevirtual

Implements tools::wroot::idir.

Definition at line 36 of file directory.

{m_objs.push_back(a_object);} //take ownership of a_object

clear_dirs()

void tools::wroot::directory::clear_dirs ( )

inline

Definition at line 326 of file directory.

{safe_clear<directory>(m_dirs);}

clear_keys()

void tools::wroot::directory::clear_keys ( )

inlineprotected

Definition at line 333 of file directory.

                    {
    std::list<key*>::iterator it;
    for(it=m_keys.begin();it!=m_keys.end();) {
      key* k = *it;
      it = m_keys.erase(it);
      delete k;
    }
    m_keys.clear();
  }

clear_objs()

void tools::wroot::directory::clear_objs ( )

inline

Definition at line 327 of file directory.

{safe_clear<iobject>(m_objs);}

close()

bool tools::wroot::directory::close ( )

inline

Definition at line 245 of file directory.

               {
    if(!save()) return false;
    clear_dirs();
    clear_objs();
    clear_keys();
    return true;
  }

file()

virtual ifile& tools::wroot::directory::file ( )

inlinevirtual

Implements tools::wroot::idir.

Definition at line 34 of file directory.

{return m_file;}

find_key()

key* tools::wroot::directory::find_key ( const std::string &  a_name )

inlineprotected

Definition at line 366 of file directory.

                                         {
    if(m_file.verbose()) {
      m_file.out() << "tools::wroot::directory::find_key :"
                   << " " << sout(a_name) << " ..."
                   << std::endl;
    }
    tools_lforcit(key*,m_keys,it) {
      if((*it)->object_name()==a_name) return *it;
    }
 
    return 0;
  }

is_valid()

bool tools::wroot::directory::is_valid ( ) const

inline

Definition at line 198 of file directory.

{return m_is_valid;}

keys()

const std::list<key*>& tools::wroot::directory::keys ( ) const

inline

Definition at line 329 of file directory.

{return m_keys;}

mkdir()

directory* tools::wroot::directory::mkdir ( const std::string &  a_name, const std::string &  a_title = ""  )

inline

Definition at line 201 of file directory.

                                                                         {
    // Create a sub-directory and return a pointer to the created directory.
    // Note that the directory name cannot contain slashes.
    if(a_name.empty()) {
      m_file.out() << "tools::wroot::directory::mkdir :"
                   << " directory name cannot be \"\"."
                   << std::endl;
      return 0;
    }
    if(a_name.find('/')!=std::string::npos) {
      m_file.out() << "tools::wroot::directory::mkdir :"
                   << " " << sout(a_name)
                   << " cannot contain a slash."
                   << std::endl;
      return 0;
    }
    directory* dir = new directory(m_file,this,a_name,a_title.empty()?a_name:a_title);
    if(!dir->is_valid()) {
      m_file.out() << "tools::wroot::directory::mkdir :"
                   << " directory badly created."
                   << std::endl;
      delete dir;
      return 0;
    }
    m_dirs.push_back(dir);
    return dir;
  }

operator=()

directory& tools::wroot::directory::operator= ( const directory &  )

inlineprotected

Definition at line 193 of file directory.

                                         {
    m_is_valid = false;
    return *this;
  }

record_size()

uint32 tools::wroot::directory::record_size ( ) const

inline

Definition at line 232 of file directory.

                             {
    uint32 nbytes = sizeof(short);
    nbytes += sizeof(date); //m_date_C.record_size();
    nbytes += sizeof(date); //m_date_M.record_size();
    nbytes += sizeof(m_nbytes_keys);
    nbytes += sizeof(m_nbytes_name);
    //ROOT version >= 40000:
    nbytes += sizeof(seek);
    nbytes += sizeof(seek);
    nbytes += sizeof(seek);
    return nbytes;
  }

s_class()

static const std::string& tools::wroot::directory::s_class ( )

inlinestatic

Definition at line 29 of file directory.

                                    {
    static const std::string s_v("tools::wroot::directory");
    return s_v;
  }

save()

bool tools::wroot::directory::save ( )

inlineprotected

Definition at line 343 of file directory.

             {
    if(!save_self()) return false;
    tools_vforit(directory*,m_dirs,it) {
      if(!(*it)->save()) return false;
    }
    return true;
  }

save_self()

bool tools::wroot::directory::save_self ( )

inlineprotected

Definition at line 351 of file directory.

                   {
    // Save Directory keys and header :
    //  If the directory has been modified (fModified set), write the keys
    //  and the directory header.
    //if (fModified || aForce) {
    //  if(!fFile.freeSegments().empty()) {
    //    if(!writeKeys()) return false; // Write keys record.
    //    if(!writeHeader()) return false; // Update directory record.
    //  }
    //}
    if(!write_keys()) return false;
    if(!write_header()) return false;
    return true;
  }

seek_directory()

virtual seek tools::wroot::directory::seek_directory ( ) const

inlinevirtual

Implements tools::wroot::idir.

Definition at line 35 of file directory.

{return m_seek_directory;}

seek_keys()

seek tools::wroot::directory::seek_keys ( ) const

inlineprotected

Definition at line 378 of file directory.

{return m_seek_keys;}

set_nbytes_name()

void tools::wroot::directory::set_nbytes_name ( uint32  a_n )

inline

Definition at line 230 of file directory.

{m_nbytes_name = a_n;}

set_seek_directory()

void tools::wroot::directory::set_seek_directory ( seek  a_seek )

inline

Definition at line 199 of file directory.

{m_seek_directory = a_seek;}

to_buffer()

bool tools::wroot::directory::to_buffer ( wbuf &  a_wb )

inline

Definition at line 253 of file directory.

                            {
    // Decode input buffer.
    // (Name, title) are stored in the (name, title) of the associated key.
    short version = class_version();
    version += big_file_version_tag(); //GB : enforce writing on seek (and not seek32).
    if(!a_wb.write(version)) return false;
    if(!a_wb.write(m_date_C)) return false;
    if(!a_wb.write(m_date_M)) return false;
    if(!a_wb.write(m_nbytes_keys)) return false;
    if(!a_wb.write(m_nbytes_name)) return false;
 
    if(!a_wb.write(m_seek_directory)) return false;
    if(!a_wb.write(m_seek_parent)) return false;
    if(!a_wb.write(m_seek_keys)) return false;
 
    if(m_file.verbose()) {
      m_file.out() << "tools::wroot::key::to_buffer :"
          << " nbytes keys : " << m_nbytes_keys
          << ", pos keys : " << m_seek_keys
          << std::endl;
    }
    return true;
  }

write()

bool tools::wroot::directory::write ( uint32 &  a_nbytes )

inline

Definition at line 277 of file directory.

                              {
    // Write all objects in memory to disk.
    // Loop on all objects in memory (including subdirectories).
    // A new key is created in the m_keys linked list for each object.
    // For allowed options see TObject::Write().
    // The directory header info is rewritten on the directory header record
    a_nbytes = 0;
    if(m_file.verbose()) {
      m_file.out() << "tools::wroot::directory::write :"
                   << " " << sout(m_name)
                   << " : " << m_dirs.size()
                   << " : " << m_objs.size()
                   << " objects."
                   << std::endl;
    }
 
    uint32 nbytes = 0;
 
   {tools_vforcit(directory*,m_dirs,it) {
      uint32 n;
      if(!(*it)->write(n)) return false;
      nbytes += n;
    }}
 
   {tools_vforit(iobject*,m_objs,it) {
      uint32 n;
      if(!write_object(*(*it),n)) {
        m_file.out() << "tools::wroot::directory::write :"
                     << " for directory " << sout(m_name)
                     << ", write_object " << sout((*it)->name())
                     << " failed."
                     << std::endl;
        return false;
      }
      nbytes += n;
    }}
 
    if(!save_self()) {
      m_file.out() << "tools::wroot::directory::write :"
                   << " for directory " << sout(m_name)
                   << ", save_self failed."
                   << std::endl;
      return false; //it will write keys of objects.
    }
 
    a_nbytes = nbytes;
    return true;
  }

write_header()

bool tools::wroot::directory::write_header ( )

inlineprotected

Definition at line 449 of file directory.

                     {
    // Overwrite the Directory header record.
    uint32 nbytes = record_size();
    char* header = new char[nbytes];
    char* buffer = header;
    m_date_M = get_date();
    wbuf wb(m_file.out(),m_file.byte_swap(),header+nbytes,buffer);
    if(!to_buffer(wb)) {
      delete [] header;
      return false;
    }
    // do not overwrite the name/title part
    seek pointer = m_seek_directory + m_nbytes_name;
    //fModified = false;
    if(!m_file.set_pos(pointer)) {
      delete [] header;
      return false;
    }
    if(!m_file.write_buffer(header,nbytes)) {
      delete [] header;
      return false;
    }
    if(!m_file.synchronize()) {
      delete [] header;
      return false;
    }
    delete [] header;
    return true;
  }

write_keys()

bool tools::wroot::directory::write_keys ( )

inlineprotected

Definition at line 392 of file directory.

                   {
    // The list of keys (m_keys) is written as a single data record
    // Delete the old keys structure if it exists
 
    //if(fSeekKeys) {
    //  if(!fFile.makeFreeSegment
    //     (fSeekKeys, fSeekKeys + fNbytesKeys -1)) return false;
    //}
 
    // Write new keys record :
    uint32 nkeys  = uint32(m_keys.size());
 
    // Compute size of all keys
    uint32 nbytes = sizeof(nkeys);
 
   {tools_lforit(key*,m_keys,it) {
      nbytes += (*it)->key_length();
    }}
 
    key headerkey(m_file.out(),m_file,m_seek_directory,m_name,m_title,"TDirectory",nbytes); // m_file.set_END().
    if(!headerkey.seek_key()) return false;
 
   {char* buffer = headerkey.data_buffer();
    wbuf wb(m_file.out(),m_file.byte_swap(),headerkey.eob(),buffer);
    if(!wb.write(nkeys)) return false;
   {tools_lforit(key*,m_keys,it) {
      if(!((*it)->to_buffer(wb,m_file.verbose()))) return false;
    }}}
 
    m_seek_keys = headerkey.seek_key();
    m_nbytes_keys = headerkey.number_of_bytes();
 
    if(m_file.verbose()) {
      m_file.out() << "tools::wroot::directory::write_keys :"
                   << " write header key"
                   << " " << sout(m_name)
                   << " " << sout(m_title)
                   << " (" << nkeys
                   << ", " << nbytes
                   << ", " << m_seek_keys
                   << ", " << m_nbytes_keys
                   << "):"
                   << std::endl;
    }
 
    headerkey.set_cycle(1);
    if(!headerkey.write_self(m_file)) {
      m_file.out() << "tools::wroot::directory::write_keys :"
                   << " key.write_self() failed."
                   << std::endl;
      return false;
    }
 
    uint32 n;
    return headerkey.write_file(m_file,n);
  }

write_object()

bool tools::wroot::directory::write_object ( iobject &  a_obj, uint32 &  a_nbytes  )

inlineprotected

Definition at line 479 of file directory.

                                                    {
    buffer bref(m_file.out(),m_file.byte_swap(),256*128); //32768
    if(!a_obj.stream(bref)) {
      m_file.out() << "tools::wroot::directory::write_object :"
                   << " cannot stream object of store class name "
                   << " " << sout(a_obj.store_class_name()) << "."
                   << std::endl;
      a_nbytes = 0;
      return false;
    }
 
    std::string name = a_obj.name();
    strip(name);
 
    //first create the key to get key_length();
 
    wroot::key* key = new wroot::key(m_file.out(),m_file,m_seek_directory,
                                     name,
                                     a_obj.title(),a_obj.store_class_name(),
                                     bref.length()); // It does a m_file.set_END().
 
    if(!key->seek_key()) {
      delete key;
      return false;
    }
 
    if(!bref.displace_mapped(key->key_length())) { //done before compression.
      delete key;
      return false;
    }
 
    char* kbuf = 0;
    uint32 klen = 0;
    bool kdelete = false;
    m_file.compress_buffer(bref,kbuf,klen,kdelete);
 
    ::memcpy(key->data_buffer(),kbuf,klen);
    if(kdelete) delete [] kbuf;
 
   {uint32 nkey = key->key_length()+klen;
    m_file.set_END(key->seek_key()+nkey);
    key->set_number_of_bytes(nkey);}
 
    uint16 cycle = append_key(key);
    key->set_cycle(cycle);
 
    if(!key->write_self(m_file)) {
      m_file.out() << "tools::wroot::directory::write_object :"
                   << " key.write_self() failed."
                   << std::endl;
      return false;
    }
 
    //FIXME m_file.sumBuffer(key->object_size()); //uncompressed data size.
 
    if(m_file.verbose()) {
      m_file.out() << "tools::wroot::directory::_write_buffer :"
                   << " " << sout(a_obj.name()) << "."
                   << std::endl;
    }
 
    return key->write_file(m_file,a_nbytes);
  }

Member Data Documentation

m_date_C

date tools::wroot::directory::m_date_C

protected

Definition at line 553 of file directory.

m_date_M

date tools::wroot::directory::m_date_M

protected

Definition at line 554 of file directory.

m_dirs

std::vector<directory*> tools::wroot::directory::m_dirs

protected

Definition at line 549 of file directory.

m_file

ifile& tools::wroot::directory::m_file

protected

Definition at line 544 of file directory.

m_is_valid

bool tools::wroot::directory::m_is_valid

protected

Definition at line 546 of file directory.

m_keys

std::list<key*> tools::wroot::directory::m_keys

protected

Definition at line 551 of file directory.

m_name

std::string tools::wroot::directory::m_name

protected

Definition at line 547 of file directory.

m_nbytes_keys

uint32 tools::wroot::directory::m_nbytes_keys

protected

Definition at line 555 of file directory.

m_nbytes_name

uint32 tools::wroot::directory::m_nbytes_name

protected

Definition at line 556 of file directory.

m_objs

std::vector<iobject*> tools::wroot::directory::m_objs

protected

Definition at line 550 of file directory.

m_parent

directory* tools::wroot::directory::m_parent

protected

Definition at line 545 of file directory.

m_seek_directory

seek tools::wroot::directory::m_seek_directory

protected

Definition at line 557 of file directory.

m_seek_keys

seek tools::wroot::directory::m_seek_keys

protected

Definition at line 559 of file directory.

m_seek_parent

seek tools::wroot::directory::m_seek_parent

protected

Definition at line 558 of file directory.

m_title

std::string tools::wroot::directory::m_title

protected

Definition at line 548 of file directory.

---

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

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/wroot/directory