Inheritance diagram for inlib::wroot::directory:

Collaboration diagram for inlib::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)
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
void	clear_dirs ()
void	clear_objs ()
uint16	append_key (key *a_key)
bool	write_keys ()
bool	write_header ()
bool	write_object (iobject &a_obj, uint32 &a_nbytes)
Static Protected Member Functions
static std::string	sout (const std::string &a_string)
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 25 of file directory.

Constructor & Destructor Documentation

inlib::wroot::directory::directory ( ifile & a_file ) [inline]

Definition at line 40 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 INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }

inlib::wroot::directory::directory	(	ifile &	a_file,
		const std::string &	a_name,
		const std::string &	a_title
	)		`[inline]`

Definition at line 56 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 INLIB_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() << "inlib::wroot::directory::directory :"
                   << " directory name cannot be \"\"."
                   << std::endl;
      return; //FIXME : throw
    }
    if(m_name.find('/')!=std::string::npos) {
      m_file.out() << "inlib::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;
  }

inlib::wroot::directory::directory	(	ifile &	a_file,
		directory *	a_parent,
		const std::string &	a_name,
		const std::string &	a_title
	)		`[inline]`

Definition at line 92 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 INLIB_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() << "inlib::wroot::directory::directory :"
                   << " directory name cannot be \"\"."
                   << std::endl;
      return; //FIXME : throw
    }
    if(m_name.find('/')!=std::string::npos) {
      m_file.out() << "inlib::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() << "inlib::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,m_parent->seek_directory(),
                     m_name,m_title,"TDirectory",nbytes); //set m_END
    m_nbytes_name = key->key_length();
    m_seek_directory = key->seek_key(); //at EOF
    if(!m_seek_directory) {
      m_file.out() << "inlib::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() << "inlib::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.out() << "inlib::wroot::directory::directory :"
                   << " key.write_self() failed."
                   << std::endl;
      return; //FIXME : throw
    }  
    uint32 n;
    if(!key->write_file(n)) {
      m_file.out() << "inlib::wroot::directory::directory :"
                   << " directory name " << sout(m_name)
                   << " cannot write key to file."
                   << std::endl;
      return; //FIXME : throw
    }  

    m_is_valid = true;
  }

virtual inlib::wroot::directory::~directory ( ) [inline, virtual]

Definition at line 180 of file directory.

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

inlib::wroot::directory::directory ( const directory & a_from ) [inline, protected]

Definition at line 189 of file directory.

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

Member Function Documentation

uint16 inlib::wroot::directory::append_key ( key * a_key ) [inline, protected]

Definition at line 390 of file directory.

                               { //take ownership of a_key
    std::list<key*>::iterator itk;
    for(itk=m_keys.begin();itk!=m_keys.end();++itk) {
      if((*itk)->object_name()==a_key->object_name()) {
        m_keys.insert(itk,a_key); //a_key will be before *itk.
        return ((*itk)->cycle() + 1);
      }
    }
    // Not found :
    m_keys.push_back(a_key);
    return 1;
  }

virtual void inlib::wroot::directory::append_object ( iobject * a_object ) [inline, virtual]

Implements inlib::wroot::idir.

Definition at line 35 of file directory.

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

void inlib::wroot::directory::clear_dirs ( ) [inline, protected]

Definition at line 387 of file directory.

{clear<directory>(m_dirs);}

void inlib::wroot::directory::clear_keys ( ) [inline, protected]

Definition at line 335 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();
  }

void inlib::wroot::directory::clear_objs ( ) [inline, protected]

Definition at line 388 of file directory.

{clear<iobject>(m_objs);}

bool inlib::wroot::directory::close ( ) [inline]

Definition at line 252 of file directory.

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

virtual ifile& inlib::wroot::directory::file ( ) [inline, virtual]

Implements inlib::wroot::idir.

Definition at line 33 of file directory.

{return m_file;}

key* inlib::wroot::directory::find_key ( const std::string & a_name ) [inline, protected]

Definition at line 372 of file directory.

                                         {
    if(m_file.verbose()) {
      m_file.out() << "inlib::wroot::directory::find_key :" 
                   << " " << sout(a_name) << " ..."
                   << std::endl;
    }
    std::list<key*>::const_iterator it;
    for(it=m_keys.begin();it!=m_keys.end();++it) {
      if((*it)->object_name()==a_name) return *it;
    }

    return 0;
  }

bool inlib::wroot::directory::is_valid ( ) const [inline]

Definition at line 203 of file directory.

{return m_is_valid;}

directory* inlib::wroot::directory::mkdir	(	const std::string &	a_name,
		const std::string &	a_title = `""`
	)		`[inline]`

Definition at line 206 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() << "inlib::wroot::directory::mkdir :" 
                   << " directory name cannot be \"\"." 
                   << std::endl;
      return 0;
    }
    if(a_name.find('/')!=std::string::npos) {
      m_file.out() << "inlib::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() << "inlib::wroot::directory::mkdir :" 
                   << " directory badly created."
                   << std::endl;
      delete dir;
      return 0;
    }
    m_dirs.push_back(dir);
    return dir;
  }

directory& inlib::wroot::directory::operator= ( const directory & ) [inline, protected]

Definition at line 198 of file directory.

                                         {
    m_is_valid = false;
    return *this;
  }

uint32 inlib::wroot::directory::record_size ( ) const [inline]

Definition at line 239 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;
  }

static const std::string& inlib::wroot::directory::s_class ( ) [inline, static]

Definition at line 28 of file directory.

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

bool inlib::wroot::directory::save ( ) [inline, protected]

Definition at line 345 of file directory.

             {
    if(!save_self()) return false;
   {std::vector<directory*>::iterator it;
    for(it=m_dirs.begin();it!=m_dirs.end();++it) {
      if(!(*it)->save()) return false;
    }}
    return true;
  }

bool inlib::wroot::directory::save_self ( ) [inline, protected]

Definition at line 354 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;
  }

virtual seek inlib::wroot::directory::seek_directory ( ) const [inline, virtual]

Implements inlib::wroot::idir.

Definition at line 34 of file directory.

{return m_seek_directory;}

seek inlib::wroot::directory::seek_keys ( ) const [inline, protected]

Definition at line 385 of file directory.

{return m_seek_keys;}

void inlib::wroot::directory::set_nbytes_name ( uint32 a_n ) [inline]

Definition at line 237 of file directory.

{m_nbytes_name = a_n;}

void inlib::wroot::directory::set_seek_directory ( seek a_seek ) [inline]

Definition at line 204 of file directory.

{m_seek_directory = a_seek;}

static std::string inlib::wroot::directory::sout ( const std::string & a_string ) [inline, static, protected]

Definition at line 558 of file directory.

                                                   {
    return std::string("\"")+a_string+"\"";
  }

bool inlib::wroot::directory::to_buffer ( wbuf & a_wb ) [inline]

Definition at line 260 of file directory.

                            {
    // Decode input buffer.
    // (Name, title) are stored in the (name, title) of the associated key.
    short version = class_version();
    version += 1000; //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() << "inlib::wroot::key::to_buffer :"
          << " nbytes keys : " << m_nbytes_keys 
          << ", pos keys : " << m_seek_keys 
          << std::endl;
    }
    return true;
  }

bool inlib::wroot::directory::write ( uint32 & a_nbytes ) [inline]

Definition at line 284 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() << "inlib::wroot::directory::write :"
                   << " " << sout(m_name)
                   << " : " << long2s(m_dirs.size())
                   << " : " << long2s(m_objs.size())
                   << " objects."
                   << std::endl;
    }

    uint32 nbytes = 0;

   {std::vector<directory*>::iterator it;
    for(it=m_dirs.begin();it!=m_dirs.end();++it) {
      uint32 n;
      if(!(*it)->write(n)) return false;
      nbytes += n;
    }}

   {std::vector<iobject*>::iterator it;
    for(it=m_objs.begin();it!=m_objs.end();++it) {
      uint32 n;
      if(!write_object(*(*it),n)) {
        m_file.out() << "inlib::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() << "inlib::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;
  }

bool inlib::wroot::directory::write_header ( ) [inline, protected]

Definition at line 463 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;
  }

bool inlib::wroot::directory::write_keys ( ) [inline, protected]

Definition at line 403 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  = m_keys.size();

    // Compute size of all keys
    uint32 nbytes = sizeof(nkeys);

   {std::list<key*>::iterator it;
    for(it=m_keys.begin();it!=m_keys.end();++it) {
      nbytes += (*it)->key_length();
    }}

    key headerkey(m_file,m_seek_directory,
                  m_name,m_title,"TDirectory",nbytes);
    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;
   {std::list<key*>::iterator it;
    for(it=m_keys.begin();it!=m_keys.end();++it) {
      if(!((*it)->to_buffer(wb))) return false;
    }}}
  
    m_seek_keys = headerkey.seek_key();
    m_nbytes_keys = headerkey.number_of_bytes();

    if(m_file.verbose()) {
      m_file.out() << "inlib::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.out() << "inlib::wroot::directory::write_keys :" 
                   << " key.write_self() failed."
                   << std::endl;
      return false;
    }  

    uint32 n;
    return headerkey.write_file(n);
  }

bool inlib::wroot::directory::write_object	(	iobject &	a_obj,
		uint32 &	a_nbytes
	)		`[inline, protected]`

Definition at line 493 of file directory.

                                                    {
    buffer bref(m_file.out(),m_file.byte_swap(),256*128); //32768
    if(!a_obj.stream(bref)) {
      m_file.out() << "inlib::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,m_seek_directory,
                                     name,
                                     a_obj.title(),a_obj.store_class_name(),
                                     bref.length()); //set m_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.out() << "inlib::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() << "inlib::wroot::directory::_write_buffer :" 
                   << " " << sout(a_obj.name()) << "."
                   << std::endl;
    }
    
    return key->write_file(a_nbytes);
  }