DataBucket.h

Go to the documentation of this file.

#ifndef EDM_DATABUCKET_H
#define EDM_DATABUCKET_H
#include <cassert>
#include <iostream>
#include <list>
#include <string>
#include <vector>
#include "TClonesArray.h"
#include "TFolder.h"
#include "TObjArray.h"
#include "EventDataModel/Exception.h"

namespace edm {
  class DataBucket {
  public:
    static const int kFixedSizeObject    = 0x01;
    static const int kVariableSizeObject = 0x02;
  public:
    DataBucket(TFolder* top);

    template<class T> int Get(const char* path, 
                              std::vector<const T*>& v) const;    
    template<class T> T* Put(const T& obj, const char* path, 
                             int opt=kFixedSizeObject);
    template<class T> int PutArray(const T* obj, const char* path, 
                                   int nObj, int opt=kFixedSizeObject);
    
    template<class T> int PutVector(const std::vector<T*>& obj, 
                                    const char* path,
                                    int opt=kFixedSizeObject);
    
    void          List(const char* opt="*")        const;
    TFolder*      GetFolder(const char* path)      const;
    TClonesArray* GetClonesArray(const char* path) const;
    TObjArray*    GetObjArray(const char* path)    const;
    
    void          ClearArrays(const TFolder* f = 0);
    TFolder*      MakeFolder(const char* path);
    int           MakeFolders(const char* dirs[]);
    int           Remove(const char* path);
    
  private:
    TClonesArray* NewClonesArray(const char* path, const char* classname);
    TObjArray*    NewObjArray(const char* path, const char* classname);
    static void   ListFolder(const TFolder& f, int lvl);
    static void   Split(const char* path, char* dir, char* base);

  private:
    TFolder* fTopFolder; 
  };
}

//......................................................................
template<class T>
int edm::DataBucket::Get(const char* path, std::vector<const T*>& v) const
{
  // Try to find exactly the collection names by
  // user. eg. "./dir/Objects" If that fails, assume the user gave
  // only a directory. Guess the collection name based on the class
  // type
  static std::string newPath;
  register int i;
  
  TObjArray* c = 0;
  if (c==0) c = this->GetClonesArray(path);
  if (c==0) c = this->GetObjArray(path);
  if (c==0) {
    T tmpItem;
    newPath = path;
    newPath += "/";
    newPath += tmpItem.ClassName();
    newPath += "s"; // Object array names are plural.
  
    if (c==0) c = this->GetClonesArray(newPath.c_str());
    if (c==0) c = this->GetObjArray(newPath.c_str());
  }
  // By this time we need to have a collection in order to proceed
  if (c==0) {
    // std::cerr << "edm::DataBucket: Couldn't locate collection at "
    //           << path << std::endl;
    throw Exception(__FILE__,__LINE__,COLLECTION_NOT_FOUND);
    return 0;
  }
  
  const T* cc = 0;
  int nitem     = c->GetEntries();
  int ntot_size = nitem+v.size();
  if (ntot_size>(int)v.capacity()) v.reserve(ntot_size);
  for (i = 0; i<nitem; ++i) {
    cc = dynamic_cast<const T*>(c->At(i));
    if (cc==0) {
      std::cerr << "Failed to convert objects in array "
                << c->GetName() << " to requested type.";
      throw Exception(__FILE__,__LINE__,TYPE_MISMATCH);
      assert(cc);
    }
    v.push_back(cc);
  }

  return nitem;
}

//======================================================================
template<class T>
T* edm::DataBucket::Put(const T& obj, const char* path, int opt)
{
  static std::string collectName;
  static std::string fullPath;
  int indx;

  collectName = obj.ClassName();
  fullPath = path;
  fullPath += "/";
  fullPath += collectName;
  fullPath += "s";
  
  if (opt & kFixedSizeObject) {
    TClonesArray *c = this->GetClonesArray(fullPath.c_str());
    if (c == 0) {
      // No collection of this type of object. Make a new collection
      if ((c = this->NewClonesArray(path, collectName.c_str())) == 0) {
        std::cerr << "edm::DataBucket: no folder " << path << " found"
                  << std::endl;
        throw Exception(__FILE__,__LINE__,NO_FOLDER_FOUND);
      }
    }
    
    // Create new object of type T in event store. The "new with
    // placement" is a signature of the TClonesArray container
    assert(c!=0); // By this time we must have a home for the object
    indx = c->GetLast()+1;
    T* t = new ((*c)[indx]) T(obj);
    return t; // Add OK
  }

  if (opt & kVariableSizeObject) {
    TObjArray* c = this->GetObjArray(fullPath.c_str());
    if (c == 0) {
      // No collection of this type of object. Make a new collection
      if ((c = this->NewObjArray(path, collectName.c_str())) == 0) {
        std::cerr << "edm::DataBucket: no folder " << path << " found"
                  << std::endl;
        throw Exception(__FILE__,__LINE__,NO_FOLDER_FOUND);
      }
    }
    
    // Create new object of type T in event store.
    assert(c!=0); // By this time we must have a home for the object
    T* t = new T(obj);
    c->AddLast(t);
    return t; // Add OK
  }

  return 0;
}

//......................................................................
template<class T>
int edm::DataBucket::PutArray(const T* obj, const char* path, 
                              int nObj, int opt)
{
  static std::string collectName;
  static std::string fullPath;
  int indx;
  register int i;

  collectName = obj[0].ClassName();
  fullPath = path;
  fullPath += "/";
  fullPath += collectName;
  fullPath += "s";
  
  if (opt & kFixedSizeObject) {
    TClonesArray *c = this->GetClonesArray(fullPath.c_str());
    if (c == 0) {
      // No collection of this type of object. Make a new collection
      if ((c = this->NewClonesArray(path, collectName.c_str())) == 0) {
        std::cerr << "edm::DataBucket: no folder " << path << " found"
                  << std::endl;
        throw Exception(__FILE__,__LINE__,NO_FOLDER_FOUND);
      }
    }
    
    // Create new object of type T in event store. The "new with
    // placement" is a signature of the TClonesArray container
    assert(c != 0); // By this time we must have a home for the object
    indx = c->GetLast() + 1;
    const T* objPtr = obj;
    for (i = 0; i < nObj; ++i) {
      new ((*c)[indx++]) T(*objPtr++);
    }
    return indx; // Add OK
  }

  if (opt & kVariableSizeObject) {
    TObjArray* c = this->GetObjArray(fullPath.c_str());
    if (c == 0) {
      // No collection of this type of object. Make a new collection
      if ((c = this->NewObjArray(path, collectName.c_str())) == 0) {
        std::cerr << "edm::DataBucket: no folder " << path << " found"
                  << std::endl;
        throw Exception(__FILE__,__LINE__,NO_FOLDER_FOUND);
      }
    }
    
    // Create new object of type T in event store.
    assert(c!=0); // By this time we must have a home for the object
    for (i = 0; i < nObj; ++i) {
      c->AddLast(new T(obj[i]));
    }
    return c->GetLast(); // Add OK
  }

  return 0;
}

//......................................................................
template<class T> 
int edm::DataBucket::PutVector(const std::vector<T*>& vec, 
                               const char* path, int opt)
{
  static std::string collectName;
  static std::string fullPath;
  int indx;

  if (vec.empty()) return 0;

  unsigned int vecSize = vec.size();

  // This doesn't seem to work for some reason...
  // std::vector<const T*>::const_iterator itr(vec.begin());
  // std::vector<const T*>::const_iterator itrEnd(vec.end());

  collectName = vec[0]->ClassName();
  fullPath = path;
  fullPath += "/";
  fullPath += collectName;
  fullPath += "s";
  
  if (opt & kFixedSizeObject) {
    TClonesArray *c = this->GetClonesArray(fullPath.c_str());
    if (c == 0) {
      // No collection of this type of object. Make a new collection
      if ((c = this->NewClonesArray(path, collectName.c_str())) == 0) {
        std::cerr << "edm::DataBucket: no folder " << path << " found"
                  << std::endl;
        throw Exception(__FILE__,__LINE__,NO_FOLDER_FOUND);
      }
    }
    
    // Create new object of type T in event store. The "new with
    // placement" is a signature of the TClonesArray container
    assert(c != 0); // By this time we must have a home for the object
    indx = c->GetLast() + 1;
    for (unsigned int i = 0; i < vecSize; ++i) {// ; itr != itrEnd; ++itr) {
      new ((*c)[indx++]) T(*vec[i]);
    }
    return indx; // Add OK
  }

  if (opt & kVariableSizeObject) {
    TObjArray* c = this->GetObjArray(fullPath.c_str());
    if (c == 0) {
      // No collection of this type of object. Make a new collection
      if ((c = this->NewObjArray(path, collectName.c_str())) == 0) {
        std::cerr << "edm::DataBucket: no folder " << path << " found"
                  << std::endl;
        throw Exception(__FILE__,__LINE__,NO_FOLDER_FOUND);
      }
    }
    
    // Create new object of type T in event store.
    assert(c!=0); // By this time we must have a home for the object
    for (unsigned int i = 0; i < vecSize; ++i) {//; itr != itrEnd; ++itr) 
      c->AddLast(new T(*vec[i]));
    }
    return c->GetLast(); // Add OK
  }

  return 0;
}

#endif // EDM_DATABUCKET_H

---