| # Gaudi Framework, version v21r7 |

Home |  | Generated: 22 Jan 2010

# Tuples Namespace Reference

General namespace for Tuple properties. More...

## Classes
class | Tuple
| A simple wrapper class over standard Gaudi NTuple::Tuple facility. More...
class | TupleColumn
| Helper class which allows to extend the functionality of Tuple with possibility to use your own representation of complex objects. More...
class | TupleObj
| A simple wrapper class over standard Gaudi NTuple::Tuple facility. More...
class | ItemStore
| Simple class, which represents the local storage of N-tuple items of the given type. More...
class | _TupAdapter
| Trivial adapter to avoid the GCC problem (pointer to the function is never evaluated as "const TYPE&" ). More...
## Namespaces
namespace | detail
namespace | Local
## Typedefs
typedef GaudiAlg::ID | TupleID
| the actual type for N-Tuple identifier (HBOOK-style)
## Enumerations
enum | Type { NTUPLE, EVTCOL }
enum | ErrorCodes { InvalidTuple = 100, InvalidColumn, InvalidOperation, InvalidObject, InvalidItem, TruncateValue = 200 }
| Tuple error codes. More...
## Functions
template<class ITEM>
TupleColumn< ITEM > | make_column (const std::string &name, const ITEM &item)
| helper function to create 'on-the-fly' the helper object Tuples::TupleColumn
template<class ITEM>
TupleColumn< const ITEM * > | make_column (const std::string &name, const ITEM *item)
| helper function to create 'on-the-fly' the helper object Tuples::TupleColumn
template<class ITEM>
TupleColumn< ITEM * > | make_column (const std::string &name, ITEM *item)
| helper function to create 'on-the-fly' the helper object Tuples::TupleColumn
template<class ITEM>
TupleColumn< ITEM > | Column (const std::string &name, const ITEM &item)
template<class ITEM>
TupleColumn< const ITEM * > | Column (const std::string &name, const ITEM *item)
template<class ITEM>
TupleColumn< ITEM * > | Column (const std::string &name, ITEM *item)
template<class OWNER>
TupleObj * | createTupleObj (const OWNER *owner, const std::string &name, NTuple::Tuple *tuple, const CLID &clid=CLID_ColumnWiseTuple, const Tuples::Type type=Tuples::NTUPLE)
| Templated helper functions allow to avoid heavy semantics of dealing with explicit type of class TupleObjImp.
template<class OBJECT>
_TupAdapter< OBJECT, double, double > | useFun (OBJECT object)
| trivial helper function to convert on flight pointer to function into "functor" It is especially useful in conjunction with N-Tuples fills
| BOOST_STATIC_ASSERT (boost::integer_traits< int >::is_specialized)
| BOOST_STATIC_ASSERT (boost::integer_traits< short >::is_specialized)
| BOOST_STATIC_ASSERT (boost::integer_traits< unsigned short >::is_specialized)
| BOOST_STATIC_ASSERT (boost::integer_traits< char >::is_specialized)
| BOOST_STATIC_ASSERT (boost::integer_traits< unsigned char >::is_specialized)
| BOOST_STATIC_ASSERT (sizeof(int)<=sizeof(long))
| BOOST_STATIC_ASSERT (sizeof(int)<=sizeof(unsigned long))
| BOOST_STATIC_ASSERT (sizeof(int)<=sizeof(unsigned int))
| BOOST_STATIC_ASSERT (sizeof(short)<=sizeof(int))
| BOOST_STATIC_ASSERT (sizeof(unsigned short)<=sizeof(int))
| BOOST_STATIC_ASSERT (sizeof(char)<=sizeof(int))
| BOOST_STATIC_ASSERT (sizeof(signed char)<=sizeof(int))
| BOOST_STATIC_ASSERT (sizeof(unsigned char)<=sizeof(int))
| BOOST_STATIC_ASSERT (boost::integer_traits< int >::const_max<=boost::integer_traits< long >::const_max)
| BOOST_STATIC_ASSERT (boost::integer_traits< int >::const_min >=boost::integer_traits< long >::const_min)
| BOOST_STATIC_ASSERT (boost::integer_traits< short >::const_max<=boost::integer_traits< int >::const_max)
| BOOST_STATIC_ASSERT (boost::integer_traits< short >::const_min >=boost::integer_traits< int >::const_min)
| BOOST_STATIC_ASSERT (boost::integer_traits< unsigned short >::const_max<=(unsigned int) boost::integer_traits< int >::const_max)
| BOOST_STATIC_ASSERT (boost::integer_traits< char >::const_max<=boost::integer_traits< int >::const_max)
| BOOST_STATIC_ASSERT (boost::integer_traits< char >::const_min >=boost::integer_traits< int >::const_min)
| BOOST_STATIC_ASSERT (boost::integer_traits< unsigned char >::const_max<=(unsigned int) boost::integer_traits< int >::const_max)
| BOOST_STATIC_ASSERT (31==boost::integer_traits< int >::digits)
| BOOST_STATIC_ASSERT (std::numeric_limits< float >::is_specialized)

## Detailed Description

General namespace for Tuple properties.

Tuples.h GaudiAlg/Tuples.h helper namespace to collect useful definitions, types, constants and functions, related to manipulations with N-Tuples and event tag collections.

helper namespace to collect useful definitions, types, constants and functions, related to manipulations with N-Tuples

Author:
  Vanya BELYAEV Ivan.Belyaev@itep.ru

Date:
  2004-01-23

Author:
  Vanya BELYAEV Ivan.Belyaev@lapp.in2p3.fr

Date:
  2005-08-06

Author:
  Vanya BELYAEV Ivan.Belyaev@itep.ru

Date:
  2004-01-23

## Typedef Documentation

typedef GaudiAlg::ID Tuples::TupleID

the actual type for N-Tuple identifier (HBOOK-style)

Definition at line 25 of file TupleID.h.

## Enumeration Type Documentation

enum Tuples::ErrorCodes

Tuple error codes.

Author:
  Vanya BELYAEV Ivan.Belyaev@itep.ru

Date:
  2004-01-23

Enumerator:

  InvalidTuple |
  InvalidColumn |
  InvalidOperation |
  InvalidObject |
  InvalidItem |
  TruncateValue |

Definition at line 76 of file TupleObj.h.

    00077     {
    00078       InvalidTuple      = 100 ,
    00079       InvalidColumn           ,
    00080       InvalidOperation        ,
    00081       InvalidObject           ,
    00082       InvalidItem             ,
    00083       TruncateValue     = 200
    00084     };

enum Tuples::Type

Enumerator:

  NTUPLE |
  EVTCOL |

Definition at line 63 of file TupleObj.h.

    00064     {
    00065       NTUPLE  , // Analysis nTuple
    00066       EVTCOL    // Event Collection
    00067     };

## Function Documentation

Tuples::BOOST_STATIC_ASSERT | ( | std::numeric_limits< float >::is_specialized |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | 31 | = `=boost::integer_traits< int >::digits` | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< unsigned char >::const_max<=(unsigned int) boost::integer_traits< int >::const_max |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< char >::const_min >=boost::integer_traits< int >::const_min |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< char >::const_max<=boost::integer_traits< int >::const_max |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< unsigned short >::const_max<=(unsigned int) boost::integer_traits< int >::const_max |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< short >::const_min >=boost::integer_traits< int >::const_min |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< short >::const_max<=boost::integer_traits< int >::const_max |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< int >::const_min >=boost::integer_traits< long >::const_min |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< int >::const_max<=boost::integer_traits< long >::const_max |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(unsigned char)<=sizeof(int) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(signed char)<=sizeof(int) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(char)<=sizeof(int) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(unsigned short)<=sizeof(int) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(short)<=sizeof(int) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(int)<=sizeof(unsigned int) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(int)<=sizeof(unsigned long) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | sizeof(int)<=sizeof(long) |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< unsigned char >::is_specialized |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< char >::is_specialized |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< unsigned short >::is_specialized |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< short >::is_specialized |  | ) |

Tuples::BOOST_STATIC_ASSERT | ( | boost::integer_traits< int >::is_specialized |  | ) |

template<class ITEM>

TupleColumn<ITEM*> Tuples::Column | ( | const std::string & | name,
|  | ITEM * | item |
| ) |  |  | `[inline]`

Definition at line 332 of file Tuple.h.

    00333   { return make_column             ( name , item ) ; }

template<class ITEM>

TupleColumn<const ITEM*> Tuples::Column | ( | const std::string & | name,
|  | const ITEM * | item |
| ) |  |  | `[inline]`

Definition at line 327 of file Tuple.h.

    00328   { return make_column             ( name , item ) ; }

template<class ITEM>

TupleColumn<ITEM> Tuples::Column | ( | const std::string & | name,
|  | const ITEM & | item |
| ) |  |  | `[inline]`

Definition at line 322 of file Tuple.h.

    00323   { return make_column             ( name , item ) ; }

template<class OWNER>

TupleObj* Tuples::createTupleObj | ( | const OWNER * | owner,
|  | const std::string & | name,
|  | NTuple::Tuple * | tuple,
|  | const CLID & | clid = `CLID_ColumnWiseTuple`,
|  | const Tuples::Type | type = `Tuples::NTUPLE` |
| ) |  |  | `[inline]`

Templated helper functions allow to avoid heavy semantics of dealing with explicit type of class TupleObjImp.

       const GaudiAlgorithm* algo  = ... ;
       NTuple::Tuple*        tuple = ... ;
       TupleObj* obj = createTupleObj( algo , " my tuple 1 "   , ntuple ) ;

       const GaudiTool* tool   = ... ;
       NTuple::Tuple*   tuple2 = ... ;
       TupleObj* obj2 = createTupleObj( tool , " my tuple 2 " , ntuple2 ) ;

Author:
  Vanya BELYAEV Ivan.Belyaev@itep.ru

Date:
  2004-1-24

Definition at line 243 of file TupleDetail.h.

    00248   {
    00249     return detail::createTupleObj
    00250       ( detail::make_handler ( owner , &OWNER::Error   ) ,
    00251         detail::make_handler ( owner , &OWNER::Warning ) ,
    00252         name , tuple , clid , type ) ;
    00253   }

template<class ITEM>

TupleColumn<ITEM*> Tuples::make_column | ( | const std::string & | name,
|  | ITEM * | item |
| ) |  |  | `[inline]`

helper function to create 'on-the-fly' the helper object Tuples::TupleColumn

Definition at line 317 of file Tuple.h.

    00318   { return TupleColumn<ITEM*>      ( name , item ) ; }

template<class ITEM>

TupleColumn<const ITEM*> Tuples::make_column | ( | const std::string & | name,
|  | const ITEM * | item |
| ) |  |  | `[inline]`

helper function to create 'on-the-fly' the helper object Tuples::TupleColumn

Definition at line 309 of file Tuple.h.

    00310   { return TupleColumn<const ITEM*>( name , item ) ; }

template<class ITEM>

TupleColumn<ITEM> Tuples::make_column | ( | const std::string & | name,
|  | const ITEM & | item |
| ) |  |  | `[inline]`

helper function to create 'on-the-fly' the helper object Tuples::TupleColumn

Definition at line 301 of file Tuple.h.

    00302   { return TupleColumn<ITEM> ( name , item ) ; }

template<class OBJECT>

_TupAdapter<OBJECT,double,double> Tuples::useFun | ( | OBJECT | object | ) | `[inline]`

trivial helper function to convert on flight pointer to function into "functor" It is especially useful in conjunction with N-Tuples fills

       using namespace Tuples ;

      typedef std::vector<double> Array ;
      Array arr = ... ;

       tuple->farray ( "sinarr"        ,
                       useFun  ( sin ) ,
                       "cosarr"        ,
                       useFun  ( cos ) ,
                       arr.begin ()    ,
                       arr.end   ()    ,
                       "Length"  , 100 ) ;

See also:
  GaudiTupleAlg

  Tuples::TupleObj

Author:
  Vanya BELYAEV Ivan.Belyaev@lapp.in2p3.fr

Date:
  2005-05-01

Definition at line 80 of file Tuples.h.

    00081   { return _TupAdapter<OBJECT,double,double>( object ) ; }