tools/wroot/columns.icc

0001 // Copyright (C) 2010, Guy Barrand. All rights reserved.
0002 // See the file tools.license for terms.
0003
0004 // common columns code for ntuple and base_pntuple.
0005
0006   template <class T>
0007   class column_ref : public virtual icol {
0008   public:
0009     static cid id_class() {
0010       static const T s_v = T(); //do that for T = std::string.
0011       return _cid(s_v)+10000;
0012     }
0013     virtual void* cast(cid a_class) const {
0014       if(void* p = cmp_cast<column_ref>(this,a_class)) {return p;}
0015       else return 0;
0016     }
0017     virtual cid id_cls() const {return id_class();}
0018   public: //icol
0019     virtual void add() {}
0020     virtual void set_def() {}
0021     virtual const std::string& name() const {return m_leaf->name();}
0022     virtual void set_basket_size(uint32 a_size) {m_branch.set_basket_size(a_size);}
0023     virtual branch& get_branch() const {return m_branch;}
0024     virtual base_leaf* get_leaf() const {return m_leaf;}
0025   public:
0026     column_ref(branch& a_branch,const std::string& a_name,const T& a_ref)
0027     :m_branch(a_branch),m_leaf(0)
0028     {
0029       m_leaf = m_branch.create_leaf_ref<T>(a_name,a_ref);
0030     }
0031     virtual ~column_ref(){
0032     }
0033   protected:
0034     column_ref(const column_ref& a_from)
0035     :icol(a_from)
0036     ,m_branch(a_from.m_branch)
0037     ,m_leaf(0)
0038     {}
0039     column_ref& operator=(const column_ref& a_from){
0040       if(&a_from==this) return *this;
0041       m_leaf = 0;
0042       return *this;
0043     }
0044   public:
0045     const T& variable() const {return m_leaf->variable();}
0046     T& variable() {return m_leaf->variable();}
0047   protected:
0048     branch& m_branch;
0049     leaf_ref<T>* m_leaf;
0050   };
0051
0052   template <class T>
0053   class column : public column_ref<T> {
0054     typedef column_ref<T> parent;
0055   public:
0056     static cid id_class() {
0057       static const T s_v = T(); //do that for T = std::string.
0058       return _cid(s_v);
0059     }
0060     virtual void* cast(cid a_class) const {
0061       if(void* p = cmp_cast<column>(this,a_class)) {return p;}
0062       else return 0;
0063     }
0064     virtual cid id_cls() const {return id_class();}
0065   public: //icol
0066     virtual void set_def() {m_value = m_def;}
0067   public:
0068     column(branch& a_branch,const std::string& a_name,const T& a_def)
0069     :parent(a_branch,a_name,m_value)
0070     ,m_def(a_def),m_value(a_def)
0071     {
0072     }
0073     virtual ~column(){
0074     }
0075   protected:
0076     column(const column& a_from)
0077     :icol(a_from)
0078     ,parent(a_from)
0079     ,m_def(a_from.m_def)
0080     ,m_value(a_from.m_value)
0081     {}
0082     column& operator=(const column& a_from){
0083       if(&a_from==this) return *this;
0084       parent::operator=(a_from);
0085       m_def = a_from.m_def;
0086       m_value = a_from.m_value;
0087       return *this;
0088     }
0089   public:
0090     column& operator=(const T& a_value){m_value = a_value;return *this;}
0091     bool fill(const T& a_value) {m_value = a_value;return true;}
0092   protected:
0093     T m_def;
0094     T m_value;
0095   };
0096
0097   class column_string_ref : public virtual icol {
0098   public:
0099     static cid id_class() {
0100       static const std::string s_v;
0101       return _cid(s_v)+10000;
0102     }
0103     virtual void* cast(cid a_class) const {
0104       if(void* p = cmp_cast<column_string_ref>(this,a_class)) {return p;}
0105       else return 0;
0106     }
0107     virtual cid id_cls() const {return id_class();}
0108   public: //icol
0109     virtual void add() {}
0110     virtual void set_def() {}
0111     virtual const std::string& name() const {return m_leaf->name();}
0112     virtual void set_basket_size(uint32 a_size) {m_branch.set_basket_size(a_size);}
0113     virtual branch& get_branch() const {return m_branch;}
0114     virtual base_leaf* get_leaf() const {return m_leaf;}
0115   public:
0116     column_string_ref(branch& a_branch,const std::string& a_name,const std::string& a_ref)
0117     :m_branch(a_branch),m_leaf(0)
0118     {
0119       m_leaf = m_branch.create_leaf_string_ref(a_name,a_ref);
0120     }
0121     virtual ~column_string_ref(){
0122     }
0123   protected:
0124     column_string_ref(const column_string_ref& a_from)
0125     :icol(a_from)
0126     ,m_branch(a_from.m_branch)
0127     ,m_leaf(0)
0128     {}
0129     column_string_ref& operator=(const column_string_ref& a_from){
0130       if(&a_from==this) return *this;
0131       m_leaf = 0;
0132       return *this;
0133     }
0134   public:
0135     const std::string& variable() const {return m_leaf->variable();}
0136     std::string& variable() {return m_leaf->variable();}
0137   protected:
0138     branch& m_branch;
0139     leaf_string_ref* m_leaf;
0140   };
0141
0142   class column_string : public column_string_ref {
0143     typedef column_string_ref parent;
0144   public:
0145     static cid id_class() {
0146       static const std::string s_v;
0147       return _cid(s_v);
0148     }
0149     virtual void* cast(cid a_class) const {
0150       if(void* p = cmp_cast<column_string>(this,a_class)) {return p;}
0151       else return 0;
0152     }
0153     virtual cid id_cls() const {return id_class();}
0154   public: //icol
0155     virtual void set_def() {m_value = m_def;}
0156   public:
0157     column_string(branch& a_branch,const std::string& a_name,const std::string& a_def)
0158     :parent(a_branch,a_name,m_value)
0159     ,m_def(a_def),m_value(a_def)
0160     {
0161     }
0162     virtual ~column_string(){
0163     }
0164   protected:
0165     column_string(const column_string& a_from)
0166     :icol(a_from)
0167     ,parent(a_from)
0168     ,m_def(a_from.m_def)
0169     ,m_value(a_from.m_value)
0170     {}
0171     column_string& operator=(const column_string& a_from){
0172       if(&a_from==this) return *this;
0173       parent::operator=(a_from);
0174       m_def = a_from.m_def;
0175       m_value = a_from.m_value;
0176       return *this;
0177     }
0178   public:
0179     column_string& operator=(const std::string& a_value){m_value = a_value;return *this;}
0180     bool fill(const std::string& a_value) {m_value = a_value;return true;}
0181   protected:
0182     std::string m_def;
0183     std::string m_value;
0184   };
0185
0186   class column_vector_string_ref : public column_string_ref {
0187     typedef column_string_ref parent;
0188   public:
0189     static cid id_class() {return _cid_std_vector<std::string>()+10000;}
0190     virtual void* cast(cid a_class) const {
0191       if(void* p = cmp_cast<column_vector_string_ref>(this,a_class)) {return p;}
0192       else return 0;
0193     }
0194     virtual cid id_cls() const {return id_class();}
0195   public: //icol
0196     virtual void add() {
0197       m_string.clear();
0198       tools_vforcit(std::string,m_ref,it) {
0199         if(it!=m_ref.begin()) m_string += m_sep;
0200         m_string += *it;
0201       }
0202       parent::add();
0203     }
0204   public:
0205     column_vector_string_ref(branch& a_branch,const std::string& a_name,const std::vector<std::string>& a_ref,char a_sep)
0206     :parent(a_branch,a_name,m_string)
0207     ,m_ref(a_ref)
0208     ,m_sep(a_sep)
0209     {
0210     }
0211     virtual ~column_vector_string_ref(){
0212     }
0213   protected:
0214     column_vector_string_ref(const column_vector_string_ref& a_from)
0215     :icol(a_from)
0216     ,parent(a_from)
0217     ,m_ref(a_from.m_ref)
0218     ,m_sep(a_from.m_sep)
0219     {}
0220     column_vector_string_ref& operator=(const column_vector_string_ref& a_from){
0221       if(&a_from==this) return *this;
0222       m_sep = a_from.m_sep;
0223       return *this;
0224     }
0225   public:
0226     const std::vector<std::string>& variable() const {return m_ref;}
0227     std::vector<std::string>& variable() {return const_cast< std::vector<std::string>& >(m_ref);}
0228   protected:
0229     const std::vector<std::string>& m_ref;
0230     char m_sep;
0231     std::string m_string;
0232   };
0233
0234   class column_vector_string : public column_vector_string_ref {
0235     typedef column_vector_string_ref parent;
0236   public:
0237     static cid id_class() {return _cid_std_vector<std::string>();}
0238     virtual void* cast(cid a_class) const {
0239       if(void* p = cmp_cast<column_vector_string>(this,a_class)) {return p;}
0240       else return 0;
0241     }
0242     virtual cid id_cls() const {return id_class();}
0243   public: //icol
0244     virtual void set_def() {m_value = m_def;}
0245   public:
0246     column_vector_string(branch& a_branch,const std::string& a_name,const std::vector<std::string>& a_def,char a_sep)
0247     :parent(a_branch,a_name,m_value,a_sep)
0248     ,m_def(a_def),m_value(a_def)
0249     {
0250     }
0251     virtual ~column_vector_string(){
0252     }
0253   protected:
0254     column_vector_string(const column_vector_string& a_from)
0255     :icol(a_from)
0256     ,parent(a_from)
0257     ,m_def(a_from.m_def)
0258     ,m_value(a_from.m_value)
0259     {}
0260     column_vector_string& operator=(const column_vector_string& a_from){
0261       if(&a_from==this) return *this;
0262       parent::operator=(a_from);
0263       m_def = a_from.m_def;
0264       m_value = a_from.m_value;
0265       return *this;
0266     }
0267   public:
0268     column_vector_string& operator=(const std::vector<std::string>& a_value){m_value = a_value;return *this;}
0269     bool fill(const std::vector<std::string>& a_value) {m_value = a_value;return true;}
0270   protected:
0271     std::vector<std::string> m_def;
0272     std::vector<std::string> m_value;
0273   };
0274
0275   template <class T>
0276   class std_vector_column_ref : public virtual icol {
0277   public:
0278     static cid id_class() {return _cid_std_vector<T>()+10000;}
0279     virtual void* cast(cid a_class) const {
0280       if(void* p = cmp_cast<std_vector_column_ref>(this,a_class)) {return p;}
0281       else return 0;
0282     }
0283     virtual cid id_cls() const {return id_class();}
0284   public: //icol
0285     virtual void add() {
0286       if(m_leaf_count) m_leaf_count->fill((int)m_ref.size()); //row_wise
0287     }
0288     virtual void set_def() {}
0289     virtual const std::string& name() const {return m_leaf->name();}
0290     virtual void set_basket_size(uint32 a_size) {m_branch.set_basket_size(a_size);}
0291     virtual branch& get_branch() const {return m_branch;}
0292     virtual base_leaf* get_leaf() const {return m_leaf;}
0293   public:
0294     std_vector_column_ref(branch& a_branch,const std::string& a_name,const std::vector<T>& a_ref)
0295     :m_branch(a_branch)
0296     ,m_ref(a_ref)
0297     ,m_leaf(0)
0298     ,m_leaf_count(0) //row_wise
0299     {
0300       if(a_branch.store_cls()==branch_element_store_class()) {
0301         //::printf("debug : std_vector_column_ref : column_wise\n");
0302         int id = -1;  //same as in std_vector_be.
0303         int type = 0;
0304         m_leaf = m_branch.create_leaf_element(a_name,id,type);
0305       } else { //row_wise.
0306         //::printf("debug : std_vector_column_ref : row_wise\n");
0307         std::string leaf_count_name = a_name+"_count";
0308         m_leaf_count = m_branch.create_leaf<int>(leaf_count_name);
0309         m_leaf = m_branch.create_leaf_std_vector_ref<T>(a_name,*m_leaf_count,a_ref);
0310         m_leaf->set_title(a_name+"["+leaf_count_name+"]"); //for TTreeFormula::RegisterDimensions.
0311       }
0312     }
0313     virtual ~std_vector_column_ref(){
0314     }
0315   protected:
0316     std_vector_column_ref(const std_vector_column_ref& a_from)
0317     :icol(a_from)
0318     ,m_branch(a_from.m_branch)
0319     ,m_ref(a_from.m_ref)
0320     ,m_leaf(0)
0321     ,m_leaf_count(0)
0322     {}
0323     std_vector_column_ref& operator=(const std_vector_column_ref& a_from){
0324       if(&a_from==this) return *this;
0325       m_leaf = 0;
0326       m_leaf_count = 0;
0327       return *this;
0328     }
0329   public:
0330     const std::vector<T>& variable() const {return m_ref;}
0331     std::vector<T>& variable() {return const_cast< std::vector<T>& >(m_ref);}
0332   protected:
0333     branch& m_branch;
0334     const std::vector<T>& m_ref;
0335     base_leaf* m_leaf;
0336     leaf<int>* m_leaf_count; //row_wise.
0337   };
0338
0339   template <class T>
0340   class std_vector_column : public std_vector_column_ref<T> {
0341     typedef std_vector_column_ref<T> parent;
0342   public:
0343     static cid id_class() {return _cid_std_vector<T>();}
0344     virtual void* cast(cid a_class) const {
0345       if(void* p = cmp_cast<std_vector_column>(this,a_class)) {return p;}
0346       else return 0;
0347     }
0348     virtual cid id_cls() const {return id_class();}
0349   public: //icol
0350     virtual void set_def() {m_value = m_def;}
0351   public:
0352     std_vector_column(branch& a_branch,const std::string& a_name,const std::vector<T>& a_def)
0353     :parent(a_branch,a_name,m_value)
0354     ,m_def(a_def),m_value(a_def)
0355     {
0356     }
0357     virtual ~std_vector_column(){
0358     }
0359   protected:
0360     std_vector_column(const std_vector_column& a_from)
0361     :icol(a_from)
0362     ,parent(a_from)
0363     ,m_def(a_from.m_def)
0364     ,m_value(a_from.m_value)
0365     {}
0366     std_vector_column& operator=(const std_vector_column& a_from){
0367       if(&a_from==this) return *this;
0368       parent::operator=(a_from);
0369       m_def = a_from.m_def;
0370       m_value = a_from.m_value;
0371       return *this;
0372     }
0373   public:
0374     std_vector_column& operator=(const std::vector<T>& a_value){m_value = a_value;return *this;}
0375     bool fill(const std::vector<T>& a_value) {m_value = a_value;return true;}
0376   protected:
0377     std::vector<T> m_def;
0378     std::vector<T> m_value;
0379   };