larlight::user_info Class Reference

A class to hold user defined variables on the fly. More...

#include <user_info.hh>

Inheritance diagram for larlight::user_info:
larlight::data_base

List of all members.

Public Member Functions

void dump_contents ()
 Method to dump all key & value contents in the storage map on the screen This is useful to check what's in the data interactively.
 user_info (DATA::DATA_TYPE type=DATA::UserInfo)
 Default constructor.
 user_info (const user_info &original)
 Default copy constructor to avoid memory leak in ROOT streamer.
void store (std::string key, double value)
 setter for a single double variable
void store (std::string key, int value)
 setter for a single int variable
void store (std::string key, std::string value)
 setter for a single std::string variable
void store (std::string key, bool value)
 setter for a single bool variable
void append (std::string key, double value)
 method to add double value to a double array
void append (std::string key, int value)
 method to add int value to an int array
void append (std::string key, std::string value)
 method to add std::string value to an std::string array
void append (std::string key, bool value)
 method to add bool value to an bool array
bool exist_double (std::string key) const
 checker for an existence of a double variable key
bool exist_string (std::string key) const
 checker for an existence of a string variable key
bool exist_int (std::string key) const
 checker for an existence of a int variable key
bool exist_bool (std::string key) const
 checker for an existence of a bool variable key
bool exist_darray (std::string key) const
 checker for an existence of a double array
bool exist_sarray (std::string key) const
 checker for an existence of a string array
bool exist_iarray (std::string key) const
 checker for an existence of a int array
bool exist_barray (std::string key) const
 checker for an existence of a bool array
double get_double (std::string key) const
 getter for a single double variable
int get_int (std::string key) const
 getter for a single int variable
std::string get_string (std::string key) const
 getter for a single std::string variable
bool get_bool (std::string key) const
 getter for a single bool variable
std::vector< double > * get_darray (std::string key)
 getter for a double array
std::vector< int > * get_iarray (std::string key)
 getter for an int array
std::vector< std::string > * get_sarray (std::string key)
 getter for a std::string array
std::vector< bool > * get_barray (std::string key)
 getter for a bool array
virtual ~user_info ()
 Default destructor.
virtual void clear_data ()
 Clear method override.
DATA::DATA_TYPE data_type () const
 data type getter
void add_association (DATA::DATA_TYPE type, const std::vector< unsigned short > ass)
 Adder for a set of association.
size_t size_association (DATA::DATA_TYPE type) const
 Getter for # of associations.
const std::vector< unsigned short > association (DATA::DATA_TYPE type, size_t index=0) const
 Getter of an association.

Protected Attributes

std::map< std::string, double > _d_map
 var. holder map of double
std::map< std::string, int > _i_map
 var. holder map of int
std::map< std::string,
std::string > 		_s_map
 var. holder map of std::string
std::map< std::string, bool > _b_map
 var. holder map of bool
std::map< std::string,
std::vector< double > > 		_darray_map
 var. holder map of double array
std::map< std::string,
std::vector< int > > 		_iarray_map
 var. holder map of int array
std::map< std::string,
std::vector< std::string > > 		_sarray_map
 var. holder map of std::string array
std::map< std::string,
std::vector< bool > > 		_barray_map
 var. holder map of bool array
DATA::DATA_TYPE _type
 DATA_TYPE.
std::map
< larlight::DATA::DATA_TYPE,
std::vector< std::vector
< unsigned short > > > 		_ass
 Association storage ... allow multiple set of associations.

Detailed Description

A class to hold user defined variables on the fly.

What we mean by "on the fly"? It means you can define variable name and store it in the data w/o defining a dedicated data container class.

The supported variable type for storage includes double, int, std::string, bool, and vector of those types. The variable is stored as a pair of a specific std::string key and value, both provided by a user. The string is then used to retrieve a variable later. Note that each retrieval requires std::string comparison, hence is somewhat expensive (i.e. takes time). But it is a matter of micro-seconds for even very large map (i.e. large map = you store a lot of variables).

See user_collection class which is actually used in event loop.

Definition at line 37 of file user_info.hh.

Constructor & Destructor Documentation

larlight::user_info::user_info ( DATA::DATA_TYPE  type = DATA::UserInfo  ) 

Default constructor.

Definition at line 9 of file user_info.cc.

References larlight::data_base::_type, clear_data(), larlight::DATA::DATA_TREE_NAME, larlight::MSG::ERROR, larlight::Message::send(), and larlight::DATA::UserInfo.

00009                                          : data_base(type) 
00010   //**********************************************************
00011   {
00012     if(_type!=DATA::UserInfo) {
00013       
00014       Message::send(MSG::ERROR,__FUNCTION__,
00015             Form("Provided data type (%s) not supported! Reset to default.",DATA::DATA_TREE_NAME[_type].c_str()));
00016       
00017       _type=DATA::UserInfo;
00018 
00019     }
00020 
00021     clear_data();
00022   }

larlight::user_info::user_info ( const user_info &  original  ) 

Default copy constructor to avoid memory leak in ROOT streamer.

Definition at line 25 of file user_info.cc.

00025                                                 :
00026     data_base(original),
00027     _d_map(original._d_map),
00028     _i_map(original._i_map),
00029     _s_map(original._s_map),
00030     _b_map(original._b_map),
00031     _darray_map(original._darray_map),
00032     _iarray_map(original._iarray_map),
00033     _sarray_map(original._sarray_map),
00034     _barray_map(original._barray_map)
00035   //**********************************************************
00036   {};

virtual larlight::user_info::~user_info (  )  [inline, virtual]

Default destructor.

Definition at line 106 of file user_info.hh.

00106 {};

Member Function Documentation

void larlight::data_base::add_association ( DATA::DATA_TYPE  type,
const std::vector< unsigned short >  ass 
) [inherited]

Adder for a set of association.

Definition at line 9 of file data_base.cc.

References larlight::data_base::_ass.

00011   {
00012 
00013     if( _ass.find(type) == _ass.end() )
00014       
00015       _ass[type]=std::vector<std::vector<unsigned short> >();
00016     
00017     _ass[type].push_back(ass);
00018     
00019     
00020   }

void larlight::user_info::append ( std::string  key,
bool  value 
)

method to add bool value to an bool array

Definition at line 206 of file user_info.cc.

References _barray_map.

00208   {
00209     if(_barray_map.find(key)==_barray_map.end())
00210       _barray_map[key]=std::vector<bool>();
00211     _barray_map[key].push_back(value);
00212   }

void larlight::user_info::append ( std::string  key,
std::string  value 
)

method to add std::string value to an std::string array

Definition at line 197 of file user_info.cc.

References _sarray_map.

00199   {
00200     if(_sarray_map.find(key)==_sarray_map.end())
00201       _sarray_map[key]=std::vector<std::string>();
00202     _sarray_map[key].push_back(value);
00203   }

void larlight::user_info::append ( std::string  key,
int  value 
)

method to add int value to an int array

Definition at line 188 of file user_info.cc.

References _iarray_map.

00190   {
00191     if(_iarray_map.find(key)==_iarray_map.end())
00192       _iarray_map[key]=std::vector<int>();
00193     _iarray_map[key].push_back(value);
00194   }

void larlight::user_info::append ( std::string  key,
double  value 
)

method to add double value to a double array

Definition at line 179 of file user_info.cc.

References _darray_map.

00181   {
00182     if(_darray_map.find(key)==_darray_map.end()) 
00183       _darray_map[key]=std::vector<double>();
00184     _darray_map[key].push_back(value);
00185   }

const std::vector< unsigned short > larlight::data_base::association ( DATA::DATA_TYPE  type,
size_t  index = 0 
) const [inherited]

Getter of an association.

Definition at line 35 of file data_base.cc.

References larlight::DATA::DATA_TREE_NAME, larlight::MSG::ERROR, and larlight::Message::send().

00037   {
00038     
00039     size_t ass_length = size_association(type);
00040     
00041     if( !(ass_length) ) {
00042       
00043       Message::send(MSG::ERROR,__FUNCTION__,
00044             Form("There is no association to %s",DATA::DATA_TREE_NAME[type].c_str()));
00045       
00046       return std::vector<unsigned short>();
00047       
00048     }
00049     
00050     if( ass_length <= index ) {
00051       
00052       Message::send(MSG::ERROR,__FUNCTION__,
00053             Form("There are only %zu associations. No association @ index=%zu",ass_length,index));
00054       
00055       return std::vector<unsigned short>();
00056       
00057     }
00058     
00059     return ((_ass.find(type))->second).at(index);
00060   }

void larlight::user_info::clear_data (  )  [virtual]

Clear method override.

Reimplemented from larlight::data_base.

Definition at line 39 of file user_info.cc.

References _b_map, _barray_map, _d_map, _darray_map, _i_map, _iarray_map, _s_map, and _sarray_map.

Referenced by user_info().

00041   {
00042     _d_map.clear();
00043     _i_map.clear();
00044     _s_map.clear();
00045     _b_map.clear();
00046     _darray_map.clear();
00047     _iarray_map.clear();
00048     _sarray_map.clear();
00049     _barray_map.clear();
00050   }

DATA::DATA_TYPE larlight::data_base::data_type (  )  const [inline, inherited]

data type getter

Reimplemented in larlight::event_base.

Definition at line 48 of file data_base.hh.

References larlight::data_base::_type.

00048 {return _type; }

void larlight::user_info::dump_contents (  ) 

Method to dump all key & value contents in the storage map on the screen This is useful to check what's in the data interactively.

Definition at line 53 of file user_info.cc.

References _b_map, _barray_map, _d_map, _darray_map, _i_map, _iarray_map, _s_map, _sarray_map, larlight::Message::get(), larlight::MSG::NORMAL, and larlight::Message::send().

00055   {
00056     
00057     Message::get()->send(MSG::NORMAL,__FUNCTION__," Start contents dump...");
00058     std::string msg("");
00059     
00060     if(_d_map.size()){
00061       msg ="Contents of double variables shown below.\n";
00062       msg+=Form("  %-20s ... Value\n","Key");
00063       for(std::map<std::string,double>::const_iterator iter(_d_map.begin());
00064       iter!=_d_map.end();
00065       ++iter)
00066     msg+=Form("  %-20s ... %g\n",(*iter).first.c_str(), (*iter).second);
00067       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00068     }
00069     
00070     if(_i_map.size()){
00071       msg ="Contents of int variables shown below.\n";
00072       msg+=Form("  %-20s ... Value\n","Key");
00073       for(std::map<std::string,int>::const_iterator iter(_i_map.begin());
00074       iter!=_i_map.end();
00075       ++iter)
00076     msg+=Form("  %-20s ... %d\n",(*iter).first.c_str(), (*iter).second);
00077       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00078     }
00079     
00080     if(_s_map.size()){
00081       msg ="Contents of std::string variables shown below.\n";
00082       msg+=Form("  %-20s ... Value\n","Key");
00083       for(std::map<std::string,std::string>::const_iterator iter(_s_map.begin());
00084       iter!=_s_map.end();
00085       ++iter)
00086     msg+=Form("  %-20s ... %s\n",(*iter).first.c_str(), (*iter).second.c_str());
00087       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00088     }
00089     
00090     if(_b_map.size()){
00091       msg ="Contents of bool variables shown below.\n";
00092       msg+=Form("  %-20s ... Value\n","Key");
00093       for(std::map<std::string,bool>::const_iterator iter(_b_map.begin());
00094       iter!=_b_map.end();
00095       ++iter)
00096     msg+=Form("  %-20s ... %d\n",(*iter).first.c_str(), (int)((*iter).second));
00097       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00098     }
00099     
00100     if(_darray_map.size()){
00101       msg ="Contents of double array shown below.\n";
00102       for(std::map<std::string,std::vector<double> >::const_iterator iter(_darray_map.begin());
00103       iter!=_darray_map.end();
00104       ++iter){
00105     msg+=Form("  Key=%-20s\n    ",(*iter).first.c_str());
00106     int ctr=1;
00107     for(std::vector<double>::const_iterator cont_iter((*iter).second.begin());
00108         cont_iter!=(*iter).second.end();
00109         ++cont_iter){
00110       msg+=Form("%g ",(*cont_iter));
00111       ctr++;
00112       if(ctr%8==0)
00113         msg+="\n    ";
00114     }
00115       }
00116       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00117     }
00118     
00119     if(_iarray_map.size()){
00120       msg ="Contents of int array shown below.\n";
00121       for(std::map<std::string,std::vector<int> >::const_iterator iter(_iarray_map.begin());
00122       iter!=_iarray_map.end();
00123       ++iter){
00124     msg+=Form("  Key=%-20s\n    ",(*iter).first.c_str());
00125     int ctr=1;
00126     for(std::vector<int>::const_iterator cont_iter((*iter).second.begin());
00127         cont_iter!=(*iter).second.end();
00128         ++cont_iter){
00129       msg+=Form("%d ",(*cont_iter));
00130       ctr++;
00131       if(ctr%8==0)
00132         msg+="\n    ";
00133     }
00134       }
00135       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00136     }
00137     
00138     if(_sarray_map.size()){
00139       msg ="Contents of std::string array shown below.\n";
00140       for(std::map<std::string,std::vector<std::string> >::const_iterator iter(_sarray_map.begin());
00141       iter!=_sarray_map.end();
00142       ++iter){
00143     msg+=Form("  Key=%-20s\n    ",(*iter).first.c_str());
00144     int ctr=1;
00145     for(std::vector<std::string>::const_iterator cont_iter((*iter).second.begin());
00146         cont_iter!=(*iter).second.end();
00147         ++cont_iter){
00148       msg+=Form("%s ",(*cont_iter).c_str());
00149       ctr++;
00150       if(ctr%8==0)
00151         msg+="\n    ";
00152     }
00153       }
00154       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00155     }
00156     
00157     if(_barray_map.size()){
00158       msg ="Contents of bool array shown below.\n";
00159       for(std::map<std::string,std::vector<bool> >::const_iterator iter(_barray_map.begin());
00160       iter!=_barray_map.end();
00161       ++iter){
00162     msg+=Form("  Key=%-20s\n    ",(*iter).first.c_str());
00163     int ctr=1;
00164     for(std::vector<bool>::const_iterator cont_iter((*iter).second.begin());
00165         cont_iter!=(*iter).second.end();
00166         ++cont_iter){
00167       msg+=Form("%d ",(int)(*cont_iter));
00168       ctr++;
00169       if(ctr%8==0)
00170         msg+="\n    ";
00171     }
00172       }
00173       Message::get()->send(MSG::NORMAL,__FUNCTION__,msg.c_str());
00174     }
00175     Message::get()->send(MSG::NORMAL,__FUNCTION__," End of dump...");
00176   }

bool larlight::user_info::exist_barray ( std::string  key  )  const [inline]

checker for an existence of a bool array

Definition at line 85 of file user_info.hh.

References _barray_map.

00085 { return _barray_map.find(key)!=_barray_map.end(); };

bool larlight::user_info::exist_bool ( std::string  key  )  const [inline]

checker for an existence of a bool variable key

Definition at line 77 of file user_info.hh.

References _b_map.

00077 { return _b_map.find(key)!=_b_map.end(); };

bool larlight::user_info::exist_darray ( std::string  key  )  const [inline]

checker for an existence of a double array

Definition at line 79 of file user_info.hh.

References _darray_map.

00079 { return _darray_map.find(key)!=_darray_map.end(); };

bool larlight::user_info::exist_double ( std::string  key  )  const [inline]

checker for an existence of a double variable key

Definition at line 71 of file user_info.hh.

References _d_map.

00071 { return _d_map.find(key)!=_d_map.end(); };

bool larlight::user_info::exist_iarray ( std::string  key  )  const [inline]

checker for an existence of a int array

Definition at line 83 of file user_info.hh.

References _iarray_map.

00083 { return _iarray_map.find(key)!=_iarray_map.end(); };

bool larlight::user_info::exist_int ( std::string  key  )  const [inline]

checker for an existence of a int variable key

Definition at line 75 of file user_info.hh.

References _i_map.

00075 { return _i_map.find(key)!=_i_map.end(); };

bool larlight::user_info::exist_sarray ( std::string  key  )  const [inline]

checker for an existence of a string array

Definition at line 81 of file user_info.hh.

References _sarray_map.

00081 { return _sarray_map.find(key)!=_sarray_map.end(); };

bool larlight::user_info::exist_string ( std::string  key  )  const [inline]

checker for an existence of a string variable key

Definition at line 73 of file user_info.hh.

References _s_map.

00073 { return _s_map.find(key)!=_s_map.end(); };

std::vector< bool > * larlight::user_info::get_barray ( std::string  key  ) 

getter for a bool array

Definition at line 299 of file user_info.cc.

References _barray_map, larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00301   {
00302     std::map<std::string,std::vector<bool> >::iterator item(_barray_map.find(key));
00303     if(item==_barray_map.end()){
00304       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00305       return 0;
00306     }
00307     return &((*item).second);
00308   }

bool larlight::user_info::get_bool ( std::string  key  )  const

getter for a single bool variable

Definition at line 251 of file user_info.cc.

References larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00253   {
00254     std::map<std::string,bool>::const_iterator item(_b_map.find(key));
00255     if(item==_b_map.end()){
00256       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00257       return 0;
00258     }
00259     return (*item).second;
00260   }

std::vector< double > * larlight::user_info::get_darray ( std::string  key  ) 

getter for a double array

Definition at line 263 of file user_info.cc.

References _darray_map, larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00265   {
00266     std::map<std::string,std::vector<double> >::iterator item(_darray_map.find(key));
00267     if(item==_darray_map.end()){
00268       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00269       return 0;
00270     }
00271     return &((*item).second);
00272   }

double larlight::user_info::get_double ( std::string  key  )  const

getter for a single double variable

Definition at line 215 of file user_info.cc.

References larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00217   {  
00218     std::map<std::string,double>::const_iterator item(_d_map.find(key));
00219     if(item==_d_map.end()){
00220       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00221       return 0;
00222     }
00223     return (*item).second;
00224   }

std::vector< int > * larlight::user_info::get_iarray ( std::string  key  ) 

getter for an int array

Definition at line 275 of file user_info.cc.

References _iarray_map, larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00277   {
00278     std::map<std::string,std::vector<int> >::iterator item(_iarray_map.find(key));
00279     if(item==_iarray_map.end()){
00280       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00281       return 0;
00282     }
00283     return &((*item).second);
00284   }

int larlight::user_info::get_int ( std::string  key  )  const

getter for a single int variable

Definition at line 227 of file user_info.cc.

References larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00229   {
00230     std::map<std::string,int>::const_iterator item(_i_map.find(key));
00231     if(item==_i_map.end()){
00232       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00233       return 0;
00234     }
00235     return (*item).second;
00236   }

std::vector< std::string > * larlight::user_info::get_sarray ( std::string  key  ) 

getter for a std::string array

Definition at line 287 of file user_info.cc.

References _sarray_map, larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00289   {
00290     std::map<std::string,std::vector<std::string> >::iterator item(_sarray_map.find(key));
00291     if(item==_sarray_map.end()){
00292       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00293       return 0;
00294     }
00295     return &((*item).second);
00296   }

std::string larlight::user_info::get_string ( std::string  key  )  const

getter for a single std::string variable

Definition at line 239 of file user_info.cc.

References larlight::MSG::ERROR, larlight::Message::get(), and larlight::Message::send().

00241   {
00242     std::map<std::string,std::string>::const_iterator item(_s_map.find(key));
00243     if(item==_s_map.end()){
00244       Message::get()->send(MSG::ERROR,__FUNCTION__,Form("Key \"%s\" does not exist!", key.c_str()));
00245       return 0;
00246     }
00247     return (*item).second;
00248   }

size_t larlight::data_base::size_association ( DATA::DATA_TYPE  type  )  const [inherited]

Getter for # of associations.

Definition at line 23 of file data_base.cc.

Referenced by larlight::cluster::get_hit_type().

00025   {
00026     
00027     if( _ass.find(type) == _ass.end() ) return 0;
00028     
00029     return ((_ass.find(type))->second).size();
00030     //return _ass[type].size();
00031     
00032   }

void larlight::user_info::store ( std::string  key,
bool  value 
) [inline]

setter for a single bool variable

Definition at line 59 of file user_info.hh.

References _b_map.

00059 {_b_map[key]=value;};

void larlight::user_info::store ( std::string  key,
std::string  value 
) [inline]

setter for a single std::string variable

Definition at line 57 of file user_info.hh.

References _s_map.

00057 {_s_map[key]=value;};

void larlight::user_info::store ( std::string  key,
int  value 
) [inline]

setter for a single int variable

Definition at line 55 of file user_info.hh.

References _i_map.

00055 {_i_map[key]=value;};

void larlight::user_info::store ( std::string  key,
double  value 
) [inline]

setter for a single double variable

Definition at line 53 of file user_info.hh.

References _d_map.

00053 {_d_map[key]=value;};

Member Data Documentation

std::map<larlight::DATA::DATA_TYPE,std::vector<std::vector<unsigned short> > > larlight::data_base::_ass [protected, inherited]

Association storage ... allow multiple set of associations.

Definition at line 65 of file data_base.hh.

Referenced by larlight::data_base::add_association(), and larlight::data_base::clear_data().

std::map<std::string,bool> larlight::user_info::_b_map [protected]

var. holder map of bool

Definition at line 116 of file user_info.hh.

Referenced by clear_data(), dump_contents(), exist_bool(), and store().

std::map<std::string,std::vector<bool> > larlight::user_info::_barray_map [protected]

var. holder map of bool array

Definition at line 120 of file user_info.hh.

Referenced by append(), clear_data(), dump_contents(), exist_barray(), and get_barray().

std::map<std::string,double> larlight::user_info::_d_map [protected]

var. holder map of double

Definition at line 113 of file user_info.hh.

Referenced by clear_data(), dump_contents(), exist_double(), and store().

std::map<std::string,std::vector<double> > larlight::user_info::_darray_map [protected]

var. holder map of double array

Definition at line 117 of file user_info.hh.

Referenced by append(), clear_data(), dump_contents(), exist_darray(), and get_darray().

std::map<std::string,int> larlight::user_info::_i_map [protected]

var. holder map of int

Definition at line 114 of file user_info.hh.

Referenced by clear_data(), dump_contents(), exist_int(), and store().

std::map<std::string,std::vector<int> > larlight::user_info::_iarray_map [protected]

var. holder map of int array

Definition at line 118 of file user_info.hh.

Referenced by append(), clear_data(), dump_contents(), exist_iarray(), and get_iarray().

std::map<std::string,std::string> larlight::user_info::_s_map [protected]

var. holder map of std::string

Definition at line 115 of file user_info.hh.

Referenced by clear_data(), dump_contents(), exist_string(), and store().

std::map<std::string,std::vector<std::string> > larlight::user_info::_sarray_map [protected]

var. holder map of std::string array

Definition at line 119 of file user_info.hh.

Referenced by append(), clear_data(), dump_contents(), exist_sarray(), and get_sarray().

DATA::DATA_TYPE larlight::data_base::_type [protected, inherited]

DATA_TYPE.

Definition at line 62 of file data_base.hh.

Referenced by larlight::calorimetry::calorimetry(), larlight::cluster::cluster(), larlight::data_base::data_base(), larlight::event_base::data_type(), larlight::data_base::data_type(), larlight::endpoint2d::endpoint2d(), larlight::event_calorimetry::event_calorimetry(), larlight::event_cluster::event_cluster(), larlight::event_endpoint2d::event_endpoint2d(), larlight::event_fifo::event_fifo(), larlight::event_hit::event_hit(), larlight::event_mcpart::event_mcpart(), larlight::event_mcshower::event_mcshower(), larlight::event_mctruth::event_mctruth(), larlight::event_pulse::event_pulse(), larlight::event_shower::event_shower(), larlight::event_simch::event_simch(), larlight::event_sps::event_sps(), larlight::event_track::event_track(), larlight::event_user::event_user(), larlight::event_vertex::event_vertex(), larlight::event_wire::event_wire(), larlight::fifo::fifo(), larlight::hit::hit(), larlight::mcnu::mcnu(), larlight::mcpart::mcpart(), larlight::mcshower::mcshower(), larlight::mctrajectory::mctrajectory(), larlight::mctruth::mctruth(), larlight::pmtfifo::pmtfifo(), larlight::pulse::pulse(), larlight::fifo::readout_sample_number_16MHz(), larlight::fifo::readout_sample_number_2MHz(), larlight::fifo::readout_sample_number_64MHz(), larlight::shower::shower(), larlight::simch::simch(), larlight::spacepoint::spacepoint(), larlight::tpcfifo::tpcfifo(), larlight::track::track(), larlight::trigger::trigger(), user_info(), larlight::vertex::vertex(), and larlight::wire::wire().

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Enumerations Enumerator
Generated on 3 Jun 2014 for MyProject by  doxygen 1.6.1