tableio C++ API Reference

class I3BroadcastTable : public I3Table

#include <I3BroadcastTable.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

Public Functions

I3BroadcastTable(I3TableService &service, std::string name, I3TableRowDescriptionConstPtr description, std::vector<I3TablePtr> &clients)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

virtual void AddRow(I3EventHeaderConstPtr header, I3TableRowConstPtr row)

virtual void Align()

Private Functions

virtual void WriteRows(I3TableRowConstPtr rows)

SET_LOGGER ("I3BroadcastTable")

Private Members

std::vector<I3TablePtr> clients_

class I3BroadcastTableService : public I3TableService

#include <I3BroadcastTableService.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

Public Functions

I3BroadcastTableService(const std::vector<I3TableServicePtr> &clients)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

virtual void SetIndexConverter(I3ConverterPtr gen)

Protected Functions

virtual I3TablePtr CreateTable(const std::string &tableName, I3TableRowDescriptionConstPtr description)

virtual void CloseFile()

Private Members

std::vector<I3TableServicePtr> clients_

class I3Converter

#include <I3Converter.h>

The basic interface of a tableio converter.

The basic interface to the individual converters. For this class pointer typdefs will be created. All methods take unspecialized pointers to I3FrameObjects. While this is the converter interface used by tableio, custom converters should instead be derived from I3ConverterImplementation.

Subclassed by I3ConverterBundle, I3ConverterImplementation< FrmObj >, I3ConverterImplementation< Container >, I3ConverterImplementation< frameobject_type >, I3ConverterImplementation< I3Direction >, I3ConverterImplementation< I3EventHeader >, I3ConverterImplementation< I3FilterResultMap >, I3ConverterImplementation< I3IceActRecoPulseSeriesMap >, I3ConverterImplementation< I3IceActTelescopePixelDoubleMap >, I3ConverterImplementation< I3IceActTelescopePixelUnsignedMap >, I3ConverterImplementation< I3IceActTelescopePixelVectorIntMap >, I3ConverterImplementation< I3IceActTelescopeStringDoubleMap >, I3ConverterImplementation< I3IceActTriggerMap >, I3ConverterImplementation< I3Map< IceActKey, ValueType > >, I3ConverterImplementation< I3Map< std::string, ValueType > >, I3ConverterImplementation< I3MapStringVectorDouble >, I3ConverterImplementation< I3Particle >, I3ConverterImplementation< I3Position >, I3ConverterImplementation< I3Vector< value_type > >, I3ConverterImplementation< I3WaveformSeriesMap >, PythonConverter

Public Types

enum ConvertState

Values:

enumerator NoConversion

Used to indicate that a converter cannot convert a given object.

enumerator ExactConversion

Used to indicate that a given object is exactly the type converted by a converter.

enumerator InexactConversion

Used to indicate that a given object is a type derived from the one a converter is designed to convert.

Public Functions

virtual ~I3Converter()

virtual size_t GetNumberOfRows(I3FrameObjectConstPtr object) = 0

Determine the number of rows the would be produced when converting the given object.

Allows to show an I3FrameObject to this converter to get the number of rows that this converter will produce

virtual size_t GetNumberOfRows(const I3FrameObject &object) = 0

Determine the number of rows the would be produced when converting the given object.

Allows to show an I3FrameObject to this converter to get the number of rows that this converter will produce

virtual I3TableRowDescriptionConstPtr GetDescription(I3FrameObjectConstPtr object) = 0

Return an I3TableRowDescription specifying the columns this converter will fill.

virtual I3TableRowDescriptionConstPtr GetDescription(const I3FrameObject &object) = 0

Return an I3TableRowDescription specifying the columns this converter will fill.

An overload of the function above for const I3FrameObject references.

I3TableRowDescriptionConstPtr GetDescription()

Return a pointer to an already created description object.

This function will log_fatal if no description exists. Check for existence of the description with HasDescription().

inline bool HasDescription()

Check if a description object has already been created.

virtual size_t Convert(I3FrameObjectConstPtr object, I3TableRowPtr rows, I3FramePtr frame = I3FramePtr()) = 0

Fill an object into the table.

Fills the object held by pointer object into rows. To allow more complex converters a pointer to the current frame can be passed along.

Parameters:

• object – The frame object to be converted

• rows – The table rows to be filled

• frame – Optional pointer to the current frame, allows direct access to all frame contents.

Returns:

The number of rows it wrote

virtual size_t Convert(const I3FrameObject &object, I3TableRowPtr rows, I3FramePtr frame = I3FramePtr()) = 0

Fill an object into the table.

An overload of the function above for const I3FrameObject references.

virtual ConvertState CanConvert(I3FrameObjectConstPtr object) = 0

Check if the converter can handle the given object.

Returns:

A value indicating whether the converter can handle the object, and if so whether it can do so specifically or more generically.

virtual I3Frame::Stream GetStop() = 0

Protected Attributes

I3TableRowDescriptionPtr description_

Pointer to the table row description.

I3FramePtr currentFrame_

Pointer to the current frame.

Implementations of more complex converters can use this to access all contents of the frame, instead of just a single frame object.

class I3ConverterBundle : public I3Converter

#include <I3ConverterBundle.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

Public Functions

I3ConverterBundle(std::vector<I3ConverterPtr> &converters)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

virtual size_t GetNumberOfRows(I3FrameObjectConstPtr object)

Determine the number of rows the would be produced when converting the given object.

Allows to show an I3FrameObject to this converter to get the number of rows that this converter will produce

virtual size_t GetNumberOfRows(const I3FrameObject &object)

Determine the number of rows the would be produced when converting the given object.

Allows to show an I3FrameObject to this converter to get the number of rows that this converter will produce

virtual I3TableRowDescriptionConstPtr GetDescription(I3FrameObjectConstPtr object)

Return an I3TableRowDescription specifying the columns this converter will fill.

virtual I3TableRowDescriptionConstPtr GetDescription(const I3FrameObject &object)

Return an I3TableRowDescription specifying the columns this converter will fill.

An overload of the function above for const I3FrameObject references.

virtual size_t Convert(I3FrameObjectConstPtr object, I3TableRowPtr rows, I3FramePtr frame = I3FramePtr())

Fill an object into the table.

Fills the object held by pointer object into rows. To allow more complex converters a pointer to the current frame can be passed along.

Parameters:

• object – The frame object to be converted

• rows – The table rows to be filled

• frame – Optional pointer to the current frame, allows direct access to all frame contents.

Returns:

The number of rows it wrote

virtual size_t Convert(const I3FrameObject &object, I3TableRowPtr rows, I3FramePtr frame = I3FramePtr())

Fill an object into the table.

An overload of the function above for const I3FrameObject references.

virtual ConvertState CanConvert(I3FrameObjectConstPtr object)

Check if the converter can handle the given object.

Returns:

A value indicating whether the converter can handle the object, and if so whether it can do so specifically or more generically.

virtual I3Frame::Stream GetStop()

Private Functions

I3ConverterBundle()

Private Members

std::vector<I3ConverterPtr> converters_

template<class FrmObj>
class I3ConverterImplementation : public I3Converter

#include <I3Converter.h>

The base class for the individual converter implementations.

The pointer conversion from I3FrameObject to the respective type of the converter is handled here. Also it somewhat hides the passed I3FramePtr. So the majority of the converters can follow the scheme of converting only a single object and more complex converters can be build that access currentFrame_ to get what they need.

Subclassed by PODConverter< FrmObj, TableType, unit >

Public Types

typedef FrmObj booked_type

Public Functions

inline virtual ~I3ConverterImplementation()

inline virtual size_t GetNumberOfRows(I3FrameObjectConstPtr object)

Determine the number of rows the would be produced when converting the given object.

This function handles the conversion to the specific frame object type and calls the overloaded protected function, which can be overloaded by derived converters.

inline virtual size_t GetNumberOfRows(const I3FrameObject &object)

Determine the number of rows the would be produced when converting the given object.

This function handles the conversion to the specific frame object type and calls the overloaded protected function, which can be overloaded by derived converters.

inline virtual size_t Convert(const I3FrameObject &object, I3TableRowPtr rows, I3FramePtr frame)

Fills a frame object into the given table rows.

This function calls FillRows which has to be implemented in the derived class. It handles the conversion of the generic I3FrameObject to the specific class FrmObj given as the template parameter. Also the lazy initialization of the description is handled here: A table row description will only be created when the first object is converted, thus allowing the converter to adjust the description to the specific object. This is useful, e.g., for constant size map<string, object> type lists where each entry will generate one column in the table.

Parameters:

• object – The frame object to be converted

• rows – The table rows to be filled

• frame – Optional pointer to the current frame, allows direct access to all frame contents.

Returns:

The number of rows it wrote

inline virtual size_t Convert(I3FrameObjectConstPtr object, I3TableRowPtr rows, I3FramePtr frame)

Fills a frame object into the given table rows.

An overload of the function above.

inline virtual I3TableRowDescriptionConstPtr GetDescription(const I3FrameObject &object)

Return an I3TableRowDescription specifying the columns this converter will fill.

The description will be re-created every time this method is called.

inline virtual I3TableRowDescriptionConstPtr GetDescription(I3FrameObjectConstPtr object)

Return an I3TableRowDescription specifying the columns this converter will fill.

An overload of the function above.

virtual ConvertState CanConvert(I3FrameObjectConstPtr object)

Check if the converter is able to treat the given frame object.

A default implementation of CanConvert. Tests whether the pointer matches the template type, and if that fails tests casting.

inline virtual I3Frame::Stream GetStop()

Protected Functions

virtual I3TableRowDescriptionPtr CreateDescription(const FrmObj &object) = 0

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t GetNumberOfRows(const FrmObj &object)

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

virtual size_t FillRows(const FrmObj &object, I3TableRowPtr rows) = 0

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

class I3CSVTable : public I3Table

#include <I3CSVTable.h>

Public Functions

I3CSVTable(I3TableService &service, const std::string &name, I3TableRowDescriptionConstPtr description, std::string &folderPath, I3TablePtr index = I3TablePtr())

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

virtual ~I3CSVTable()

template<>
inline void WriteElement(signed char *element)

template<>
inline void WriteElement(unsigned char *element)

Protected Functions

virtual void WriteRows(I3TableRowConstPtr row)

void CreateTable()

Private Types

enum NativeType

Values:

enumerator UNKNOWN

enumerator NATIVE_SCHAR

enumerator NATIVE_SHORT

enumerator NATIVE_INT

enumerator NATIVE_LONG

enumerator NATIVE_LLONG

enumerator NATIVE_UCHAR

enumerator NATIVE_USHORT

enumerator NATIVE_UINT

enumerator NATIVE_ULONG

enumerator NATIVE_ULLONG

enumerator NATIVE_FLOAT

enumerator NATIVE_DOUBLE

enumerator NATIVE_BOOL

Private Functions

NativeType GetNativeType(const I3Datatype &dtype)

template<typename T>
inline void WriteField(T *value, size_t arraySize)

template<typename T>
inline void WriteElement(T *element)

SET_LOGGER ("I3CSVTable")

Private Members

std::vector<NativeType> fieldTypes_

std::string folderPath_

std::ofstream output_

class I3CSVTableService : public I3TableService

#include <I3CSVTableService.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

Public Functions

I3CSVTableService(const std::string &foldername)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

virtual ~I3CSVTableService()

Protected Functions

virtual I3TablePtr CreateTable(const std::string &tableName, I3TableRowDescriptionConstPtr description)

virtual void CloseFile()

Private Functions

SET_LOGGER ("I3CSVTableService")

Private Members

std::string folderName_

struct I3Datatype

#include <I3Datatype.h>

Represents an atomic datatype.

Public Types

enum TypeClass

Categories describing types of atomic data objects.

Values:

enumerator Float

A floating point number

enumerator Int

An integer type number

enumerator Enum

An enumeration

enumerator Bool

A boolean value

Public Functions

bool operator!=(const I3Datatype &rhs) const

bool operator==(const I3Datatype &rhs) const

bool CompatibleWith(const I3Datatype &rhs, bool enums_are_ints = false) const

Tests if two data types are compatible.

std::string TypeClassAsString() const

std::string AsString() const

inline I3Datatype()

inline I3Datatype(TypeClass k, size_t s, bool sign)

Public Members

TypeClass kind

The type class.

size_t size

The size of the data type in memory.

bool is_signed

True if the data type has a sign bit.

std::vector<std::pair<std::string, long>> enum_members

Associates enum members with a string.

This information is used by tableio to write strings into tables instead of simply the integer numbers associated with the enumeration.

std::string description

A description of the data type.

class I3DirectionConverter : public I3ConverterImplementation<I3Direction>

#include <I3DirectionConverter.h>

Copyright (C) 2012 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Martin Wolf martin.wolf@fysik.su.se $LastChangedBy$

Public Types

enum BookRefFrame

Values:

enumerator car

enumerator sph

enumerator all

Public Functions

inline I3DirectionConverter()

inline I3DirectionConverter(BookRefFrame bookRefFrame, std::string tableColumnNamePrefix)

The bookRefFrame argument specifies the reference frame for which direction data should be booked. The tableColumnNamePrefix argument specified the prefix string that should be prefixed to all table column names.

virtual I3TableRowDescriptionPtr CreateDescription(const I3Direction &direction)

Copyright (C) 2012 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Martin Wolf martin.wolf@fysik.su.se $LastChangedBy$

virtual size_t FillRows(const I3Direction &direction, I3TableRowPtr row)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

Protected Attributes

BookRefFrame bookRefFrame_

The enum value in what reference frame the direction should get booked.

std::string tableColumnNamePrefix_

The prefix string that should be prefixed to all table column names.

class I3EventHeaderConverter : public I3ConverterImplementation<I3EventHeader>

#include <I3EventHeaderConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

Private Functions

virtual I3TableRowDescriptionPtr CreateDescription(const I3EventHeader &params)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

virtual size_t FillRows(const I3EventHeader &params, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

class I3FilterResultMapConverter : public I3ConverterImplementation<I3FilterResultMap>

#include <I3FilterResultMapConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

Private Functions

virtual I3TableRowDescriptionPtr CreateDescription(const I3FilterResultMap &frmap)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

virtual size_t FillRows(const I3FilterResultMap &frmap, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

class I3IceActRecoPulseSeriesMapConverter : public I3ConverterImplementation<I3IceActRecoPulseSeriesMap>

#include <dataclasses_IceAct_convert.h>

Private Functions

inline size_t getI3IceActRecoPulseSeriesMapLength(const I3IceActRecoPulseSeriesMap &map)

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3IceActRecoPulseSeriesMap &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3IceActRecoPulseSeriesMap &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

class I3IceActTelescopePixelDoubleMapConverter : public I3ConverterImplementation<I3IceActTelescopePixelDoubleMap>

#include <dataclasses_IceAct_convert.h>

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3IceActTelescopePixelDoubleMap &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3IceActTelescopePixelDoubleMap &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t GetNumberOfRows(const I3IceActTelescopePixelDoubleMap &map) override

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

inline size_t getI3IceActTelescopePixelDoubleMapLength(const I3IceActTelescopePixelDoubleMap &map)

class I3IceActTelescopePixelUnsignedMapConverter : public I3ConverterImplementation<I3IceActTelescopePixelUnsignedMap>

#include <dataclasses_IceAct_convert.h>

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3IceActTelescopePixelUnsignedMap &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3IceActTelescopePixelUnsignedMap &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t GetNumberOfRows(const I3IceActTelescopePixelUnsignedMap &map) override

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

inline size_t getI3IceActTelescopePixelUnsignedMapLength(const I3IceActTelescopePixelUnsignedMap &map)

class I3IceActTelescopePixelVectorIntMapConverter : public I3ConverterImplementation<I3IceActTelescopePixelVectorIntMap>

#include <dataclasses_IceAct_convert.h>

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3IceActTelescopePixelVectorIntMap &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3IceActTelescopePixelVectorIntMap &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t GetNumberOfRows(const I3IceActTelescopePixelVectorIntMap &map) override

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

class I3IceActTelescopeStringDoubleMapConverter : public I3ConverterImplementation<I3IceActTelescopeStringDoubleMap>

#include <dataclasses_IceAct_convert.h>

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3IceActTelescopeStringDoubleMap &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3IceActTelescopeStringDoubleMap &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t GetNumberOfRows(const I3IceActTelescopeStringDoubleMap &map) override

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

class I3IceActTriggerMapConverter : public I3ConverterImplementation<I3IceActTriggerMap>

#include <dataclasses_IceAct_convert.h>

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3IceActTriggerMap &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3IceActTriggerMap &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t GetNumberOfRows(const I3IceActTriggerMap &map) override

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

class I3IndexColumnsGenerator : public I3ConverterImplementation<I3EventHeader>

#include <I3IndexColumnsGenerator.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

Public Functions

I3IndexColumnsGenerator()

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

I3IndexColumnsGenerator(const std::vector<std::string> &streams)

I3IndexColumnsGenerator(I3TableRowDescriptionConstPtr desc)

I3EventHeaderPtr Resurrect(I3TableRowPtr rows)

Private Types

typedef hash_map<std::string, int> stream_map_t

typedef std::vector<stream_map_t::key_type> istream_t

Private Functions

virtual I3TableRowDescriptionPtr CreateDescription(const I3EventHeader &object)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t FillRows(const I3EventHeader &header, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

Private Members

stream_map_t streams_

istream_t istreams_

template<typename ValueType>
class I3MapIceActKeyConverter : public I3ConverterImplementation<I3Map<IceActKey, ValueType>>

#include <dataclasses_IceAct_convert.h>

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3Map<IceActKey, ValueType> &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3Map<IceActKey, ValueType> &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

template<class converter_type, typename map_type = I3Map<ModuleKey, std::vector<typename converter_type::booked_type>>, typename frameobject_type = map_type>
class I3MapModuleKeyVectorConverter : public I3ConverterImplementation<frameobject_type>

#include <I3MapConverter.h>

Public Functions

inline I3MapModuleKeyVectorConverter(bool bookGeometry, std::string bookToParticle)

inline I3MapModuleKeyVectorConverter(bool bookGeometry)

inline I3MapModuleKeyVectorConverter(std::string bookToParticle)

inline I3MapModuleKeyVectorConverter()

Protected Functions

inline size_t GetNumberOfRows(const map_type &m)

inline I3TableRowDescriptionPtr CreateDescription(const map_type &m)

inline size_t FillRows(const map_type &m, I3TableRowPtr rows)

Private Members

bool bookGeometry_

std::string bookToParticle_

converter_type converter_

template<class converter_type, typename map_type = I3Map<OMKey, std::vector<typename converter_type::booked_type>>, typename frameobject_type = map_type>
class I3MapOMKeyVectorConverter : public I3ConverterImplementation<frameobject_type>

#include <I3MapConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

Public Functions

inline I3MapOMKeyVectorConverter(bool bookGeometry, std::string bookToParticle)

inline I3MapOMKeyVectorConverter(std::string bookToParticle)

inline I3MapOMKeyVectorConverter(bool bookGeometry)

inline I3MapOMKeyVectorConverter()

Protected Functions

inline size_t GetNumberOfRows(const map_type &m)

inline I3TableRowDescriptionPtr CreateDescription(const map_type &m)

inline size_t FillRows(const map_type &m, I3TableRowPtr rows)

Private Members

bool bookGeometry_

std::string bookToParticle_

converter_type converter_

template<typename ValueType>
class I3MapStringConverter : public I3ConverterImplementation<I3Map<std::string, ValueType>>

#include <I3MapStringConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const I3Map<std::string, ValueType> &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const I3Map<std::string, ValueType> &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

class I3MapStringVectorDoubleConverter : public I3ConverterImplementation<I3MapStringVectorDouble>

#include <I3MapStringVectorDoubleConverter.h>

Private Functions

virtual I3TableRowDescriptionPtr CreateDescription(const I3MapStringVectorDouble &map)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t FillRows(const I3MapStringVectorDouble &map, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t GetNumberOfRows(const I3MapStringVectorDouble &map)

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

union I3MemoryChunk

#include <I3MemoryChunk.h>

A single field in the in-memory representation of the table.

The converters will fill a contiguous region of space of which different regions may contain different datatypes. In order to guarantee proper alignment of the fields reserve for every field sizeof(I3MemoryChunk) bytes.

Public Members

char char_

short short_

int int_

long long_

long long longLong_

float float_

double double_

long double longDouble_

bool bool_

class I3ParticleConverter : public I3ConverterImplementation<I3Particle>

#include <I3ParticleConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

Private Functions

virtual I3TableRowDescriptionPtr CreateDescription(const I3Particle &particle)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

virtual size_t FillRows(const I3Particle &particle, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

class I3PositionConverter : public I3ConverterImplementation<I3Position>

#include <I3PositionConverter.h>

Copyright (C) 2012 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Martin Wolf martin.wolf@fysik.su.se $LastChangedBy$

Public Types

enum BookRefFrame

Values:

enumerator car

enumerator sph

enumerator cyl

enumerator all

Public Functions

inline I3PositionConverter()

inline I3PositionConverter(BookRefFrame bookRefFrame, std::string tableColumnNamePrefix)

The bookRefFrame argument specifies the reference frame for which position data should be booked. The tableColumnNamePrefix argument specified the prefix string that should be prefixed to all table column names.

virtual I3TableRowDescriptionPtr CreateDescription(const I3Position &position)

Copyright (C) 2012 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Martin Wolf martin.wolf@fysik.su.se $LastChangedBy$

virtual size_t FillRows(const I3Position &position, I3TableRowPtr row)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

Protected Attributes

BookRefFrame bookRefFrame_

The enum value in what reference frame the position should get booked.

std::string tableColumnNamePrefix_

The prefix string that should be prefixed to all table column names.

class I3Table

#include <I3Table.h>

Base class for tableio tables.

Subclassed by I3BroadcastTable, I3CSVTable

Public Functions

I3Table(I3TableService &service, std::string name, I3TableRowDescriptionConstPtr description)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

virtual ~I3Table()

virtual void Flush(const size_t nrows = 0)

bool IsConnectedToWriter()

void SetConnectedToWriter(bool connected)

I3TableRowPtr CreateRow(size_t nrows)

virtual void AddRow(I3EventHeaderConstPtr header, I3TableRowConstPtr row)

virtual void Align()

I3TableRowConstPtr GetRowForEvent(size_t index) const

std::string GetName() const

size_t GetNumberOfEvents() const

size_t GetNumberOfRows() const

I3TableRowDescriptionConstPtr GetDescription()

Protected Types

enum AlignmentType

Values:

enumerator MultiRow

enumerator Strict

Protected Functions

virtual void WriteRows(I3TableRowConstPtr row) = 0

virtual I3TableRowConstPtr ReadRows(size_t start, size_t nrows) const

virtual std::pair<size_t, size_t> GetRangeForEvent(size_t index) const

bool DoPadding()

virtual AlignmentType GetAlignmentType()

Protected Attributes

I3TableService &service_

std::string name_

I3TableRowDescriptionConstPtr description_

boost::shared_ptr<I3Table> indexTable_

size_t nevents_

size_t nrows_

size_t nrowsWithPadding_

bool connected_

bool tableCreated_

I3EventHeaderConstPtr lastHeader_

Private Functions

I3Table()

SET_LOGGER ("I3Table")

class I3TableRow

#include <I3TableRow.h>

Public Functions

I3TableRow(I3TableRowDescriptionConstPtr description, size_t nrows = 1)

I3TableRow(const I3TableRow &rhs)

I3TableRow(const I3TableRow &rhs, size_t start, size_t stop)

I3TableRow &operator=(const I3TableRow &rhs)

~I3TableRow()

void SetCurrentRow(size_t row)

size_t GetCurrentRow() const

I3TableRowPtr GetSingleRow(size_t row) const

template<class T>
void Set(const std::string &fieldName, T value, bool all = false)

template<class T>
void Set(size_t index, T value, bool all = false)

template<class T>
T Get(const std::string &fieldName)

template<class T>
T Get(size_t index)

template<class T>
T *GetPointer(const std::string &fieldName)

template<class T>
T *GetPointer(size_t index)

template<class T>
T *GetPointer(const std::string &fieldName, size_t row)

template<class T>
T *GetPointer(size_t index, size_t row)

template<class T>
const T *GetPointer(const std::string &fieldName) const

template<class T>
const T *GetPointer(size_t index) const

template<class T>
const T *GetPointer(const std::string &fieldName, size_t row) const

template<class T>
const T *GetPointer(size_t index, size_t row) const

void const *GetPointer() const

void const *GetPointerToField(size_t index, size_t row) const

void const *GetPointerToRow(size_t row) const

void *GetPointerToField(size_t index, size_t row)

I3TableRowDescriptionConstPtr GetDescription() const

size_t GetNumberOfRows() const

void SetNumberOfRows(size_t nrows)

inline void SetEnumsAreInts(bool flag)

void reserve(size_t nrows)

void erase(size_t nrows)

void append(const I3TableRow &rhs)

template<>
void Set(const std::string &fieldName, bool value, bool all)

template<>
void *GetPointer(const std::string &fieldName, size_t row)

Private Functions

template<class T>
void SetAll(size_t index, T value)

template<class T>
void SetCurrent(size_t index, T value)

template<class T>
bool CheckType(size_t index) const

I3TableRow()

void init()

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

void expand(size_t nrows)

Private Members

I3TableRowDescriptionConstPtr description_

size_t nrows_

size_t capacity_

size_t currentRow_

I3MemoryChunk *data_

bool enums_are_ints_

class I3TableRowDescription

#include <I3TableRowDescription.h>

Public Functions

I3TableRowDescription()

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

virtual ~I3TableRowDescription()

void AddField(const std::string &name, I3Datatype type, const std::string &unit, const std::string &doc, size_t arrayLength)

template<class T>
inline void AddField(const std::string &name, const std::string &unit, const std::string &doc, size_t arrayLength = 1)

template<typename enum_type>
inline void AddEnumField(const std::string &name, const std::vector<std::pair<std::string, enum_type>> &elements, const std::string &unit, const std::string &doc, size_t arrayLength = 1)

bool CanBeFilledInto(boost::shared_ptr<const I3TableRowDescription> other) const

const std::vector<std::string> &GetFieldNames() const

const std::vector<I3Datatype> &GetFieldTypes() const

const std::vector<size_t> &GetFieldTypeSizes() const

const std::vector<size_t> &GetFieldByteOffsets() const

const std::vector<size_t> &GetFieldArrayLengths() const

const std::vector<std::string> &GetFieldUnits() const

const std::vector<std::string> &GetFieldDocStrings() const

size_t GetFieldColumn(const std::string &fieldName) const

size_t GetTotalByteSize() const

size_t GetTotalChunkSize() const

size_t GetNumberOfFields() const

inline bool GetIsMultiRow() const

inline void SetIsMultiRow(bool f)

inline bool GetUseIndex() const

inline void SetUseIndex(bool u)

inline bool GetUsePadding() const

inline void SetUsePadding(bool up)

bool operator==(boost::shared_ptr<const I3TableRowDescription> other) const

template<>
void AddField(const std::string &name, const std::string &unit, const std::string &doc, size_t arrayLength)

template<>
void AddField(const std::string &name, const std::string &unit, const std::string &doc, size_t arrayLength)

Public Members

bool isMultiRow_

Private Types

typedef boost::unordered_map<std::string, size_t> fieldNameToIndex_t

Private Functions

size_t GetNextOffset() const

SET_LOGGER ("I3TableRowDescription")

Private Members

std::vector<std::string> fieldNames_

fieldNameToIndex_t fieldNameToIndex_

std::vector<I3Datatype> fieldTypes_

std::vector<size_t> fieldTypeSizes_

std::vector<size_t> fieldArrayLengths_

std::vector<size_t> fieldByteOffsets_

std::vector<std::string> fieldUnits_

std::vector<std::string> fieldDocStrings_

bool useIndex_

bool usePadding_

Friends

friend I3TableRowDescription operator|(const I3TableRowDescription &lhs, const I3TableRowDescription &rhs)

friend I3TableRowDescription &operator<<(I3TableRowDescription &lhs, const I3TableRowDescription &rhs)

class I3TableService

#include <I3TableService.h>

Subclassed by I3BroadcastTableService, I3CSVTableService

Public Functions

I3TableService()

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

virtual ~I3TableService()

virtual I3TablePtr GetTable(std::string tableName, I3TableRowDescriptionConstPtr description)

std::vector<std::string> GetTableNames()

I3TableRowConstPtr GetPaddingRows(I3EventHeaderConstPtr lastHeader, I3EventHeaderConstPtr newHeader, I3TableRowDescriptionConstPtr description_)

I3EventHeaderConstPtr GetLastHeader()

I3TableRowDescriptionConstPtr GetIndexDescription()

void HeaderWritten(I3EventHeaderConstPtr lastHeader, size_t nrows)

virtual void SetIndexConverter(I3ConverterPtr gen)

void Finish()

Protected Functions

virtual I3TablePtr CreateTable(const std::string &tableName, I3TableRowDescriptionConstPtr description) = 0

virtual void CloseFile() = 0

Protected Attributes

std::map<std::string, I3TablePtr> tables_

Private Functions

bool EventHeadersEqual(const I3EventHeader &header1, const I3EventHeader &header2)

SET_LOGGER ("I3TableService")

Private Members

std::vector<I3EventHeaderConstPtr> eventHeaderCache_

I3ConverterPtr ticConverter_

I3TableRowDescriptionConstPtr indexDescription_

class I3TableTranscriber

#include <I3TableTranscriber.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

Public Functions

I3TableTranscriber(I3TableServicePtr input, I3TableServicePtr output)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

void Execute()

void Execute(size_t nframes)

void Finish()

Protected Functions

I3TablePtr ConnectTable(std::string tableName, const I3TableRowDescription &description)

void DisconnectTable(I3TablePtr &table)

Private Functions

I3TableTranscriber()

SET_LOGGER ("I3TableTranscriber")

Private Members

I3TableServicePtr inputService_

I3TableServicePtr outputService_

boost::shared_ptr<I3IndexColumnsGenerator> indexer_

std::vector<std::pair<I3TablePtr, I3TablePtr>> transcriptions_

size_t nEvents_

class I3TableWriter

#include <I3TableWriter.h>

Public Functions

I3TableWriter(I3TableServicePtr service, std::vector<I3ConverterMillPtr> &converters, std::vector<std::string> &streams)

virtual ~I3TableWriter()

bool AddObject(std::string name, std::string tableName, I3Frame::Stream frame_stop, I3ConverterPtr converter, I3FrameObjectConstPtr obj)

void AddObject(std::string typeName, TableSpec spec)

void AddType(TypeSpec type, TableSpec spec)

void AddConverter(std::string typeName, I3ConverterPtr converter)

void Setup()

void Convert(I3FramePtr frame)

void Finish()

Protected Types

typedef std::map<std::string, std::vector<TableSpec>> tablespec_map

typedef std::map<TypeSpec, std::vector<TableSpec>> typespec_map

Protected Functions

I3TablePtr ConnectTable(std::string tableName, const I3TableRowDescription &description)

void DisconnectTable(I3TablePtr &table)

Protected Attributes

I3TableServicePtr service_

std::map<std::string, std::vector<TableBundle>> tables_

std::map<std::string, I3ConverterPtr> converters_

std::vector<I3ConverterMillPtr> converterCache_

std::vector<std::string> streams_

std::set<std::string> ignoredStreams_

std::set<std::string> uselessKeys_

tablespec_map wantedNames_

typespec_map wantedTypes_

std::map<std::string, std::string> objNameToTableName_

std::map<std::string, std::string> typeNameToConverterName_

I3FrameConstPtr currentFrame_

I3ConverterPtr ticConverter_

Private Functions

I3TableWriter()

I3TableWriter(const I3TableWriter &rhs)

const std::string GetTypeName(I3FramePtr, const std::string&)

I3ConverterPtr FindConverter(I3FrameObjectConstPtr obj)

SET_LOGGER ("I3TableWriter")

Friends

friend struct I3TableWriterTestAccess

template<class Converter, typename Container = I3Tree<typename Converter::booked_type>>
class I3TreeConverter : public I3ConverterImplementation<Container>

#include <I3TreeConverter.h>

Protected Functions

inline virtual size_t GetNumberOfRows(const Container &c)

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

inline virtual I3TableRowDescriptionPtr CreateDescription(const Container &c)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const Container &c, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

Private Types

typedef Converter::booked_type Element

Private Members

Converter converter_

template<class converter_type, typename value_type = typename converter_type::booked_type>
class I3VectorConverter : public I3ConverterImplementation<I3Vector<value_type>>

#include <I3VectorConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

Private Types

typedef I3Vector<value_type> vector_type

Private Functions

inline virtual size_t GetNumberOfRows(const vector_type &v)

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

inline virtual I3TableRowDescriptionPtr CreateDescription(const vector_type &v)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const vector_type &v, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

Private Members

converter_type converter_

class I3WaveformConverter : public I3ConverterImplementation<I3WaveformSeriesMap>

#include <I3WaveformConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

Public Functions

I3WaveformConverter()

I3WaveformConverter(std::string atwdName, std::string fadcwaveform, bool calibrate)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

Private Functions

virtual I3TableRowDescriptionPtr CreateDescription(const I3WaveformSeriesMap &waveforms)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t FillRows(const I3WaveformSeriesMap &waveforms, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t GetNumberOfRows(const I3WaveformSeriesMap &waveforms)

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

Private Members

std::string atwdName_

std::string fadcName_

bool calibrate_

class I3WaveformSeriesMapConverter : public I3ConverterImplementation<I3WaveformSeriesMap>

#include <I3WaveformSeriesMapConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

Public Functions

I3WaveformSeriesMapConverter(bool calibrate = false, bool bookGeometry = false)

Private Functions

virtual I3TableRowDescriptionPtr CreateDescription(const I3WaveformSeriesMap &waveforms)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t FillRows(const I3WaveformSeriesMap &waveforms, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

virtual size_t GetNumberOfRows(const I3WaveformSeriesMap &waveforms)

Returns the number of rows the converter would fill for the given frame object.

The default implementation always returns 1. Override in the derived converter implementation if a different number of rows might be created.

Private Members

bool calibrate_

bool bookGeometry_

template<typename T, typename U = T>
struct iterator_traits

#include <I3TreeConverter.h>

Public Types

typedef U::const_iterator iterator_type

template<typename T>
struct iterator_traits<I3Tree<T>>

#include <I3TreeConverter.h>

Public Types

typedef I3Tree<T>::iterator iterator_type

template<class FrmObj, typename TableType, const char *unit>
class PODConverter : public I3ConverterImplementation<FrmObj>

#include <PODConverter.h>

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

Private Functions

inline virtual I3TableRowDescriptionPtr CreateDescription(const FrmObj &object)

Create a table row description based on the given object.

This function has to be implemented by the derived converter implementation.

inline virtual size_t FillRows(const FrmObj &object, I3TableRowPtr rows)

Fill a table row with the data from the given object.

This function has to be implemented by the derived converter implementation.

struct PythonConverter : public I3Converter, public boost::python::wrapper<I3Converter>

#include <PythonConverter.h>

Public Functions

inline PythonConverter()

virtual size_t GetNumberOfRows(I3FrameObjectConstPtr object)

Determine the number of rows the would be produced when converting the given object.

Allows to show an I3FrameObject to this converter to get the number of rows that this converter will produce

virtual size_t GetNumberOfRows(const I3FrameObject &object)

Determine the number of rows the would be produced when converting the given object.

Allows to show an I3FrameObject to this converter to get the number of rows that this converter will produce

virtual I3TableRowDescriptionConstPtr GetDescription(I3FrameObjectConstPtr object)

Return an I3TableRowDescription specifying the columns this converter will fill.

virtual I3TableRowDescriptionConstPtr GetDescription(const I3FrameObject &object)

Return an I3TableRowDescription specifying the columns this converter will fill.

An overload of the function above for const I3FrameObject references.

I3TableRowDescriptionConstPtr GetDescription()

I3TableRowDescriptionPtr CreateDescription(I3FrameObjectConstPtr object)

I3TableRowDescriptionPtr CreateDescription(const I3FrameObject &object)

virtual size_t Convert(I3FrameObjectConstPtr object, I3TableRowPtr rows, I3FramePtr frame = I3FramePtr())

Fill an object into the table.

Fills the object held by pointer object into rows. To allow more complex converters a pointer to the current frame can be passed along.

Parameters:

• object – The frame object to be converted

• rows – The table rows to be filled

• frame – Optional pointer to the current frame, allows direct access to all frame contents.

Returns:

The number of rows it wrote

virtual size_t Convert(const I3FrameObject &object, I3TableRowPtr rows, I3FramePtr frame = I3FramePtr())

Fill an object into the table.

An overload of the function above for const I3FrameObject references.

size_t FillRows(const I3FrameObjectConstPtr object, I3TableRowPtr rows)

virtual ConvertState CanConvert(I3FrameObjectConstPtr object)

Check if the converter can handle the given object.

Returns:

A value indicating whether the converter can handle the object, and if so whether it can do so specifically or more generically.

ConvertState CanConvert(I3FrameObjectPtr object)

I3FramePtr GetCurrentFrame()

virtual I3Frame::Stream GetStop()

SET_LOGGER ("PythonConverter")

struct TableBundle

#include <I3TableWriter.h>

Public Members

I3ConverterPtr converter

I3TablePtr table

struct TableSpec

#include <I3TableWriter.h>

Public Functions

inline TableSpec(const std::string name, I3ConverterPtr conv)

inline TableSpec(const std::string name)

inline TableSpec(I3ConverterPtr conv)

inline TableSpec()

Public Members

std::string tableName

I3ConverterPtr converter

struct TypeSpec

#include <I3TableWriter.h>

Public Functions

inline bool operator<(const TypeSpec &rhs) const

inline TypeSpec(boost::python::object t_)

inline bool check(I3FrameObjectConstPtr p) const

inline bool check(I3FrameObjectPtr p) const

Public Members

boost::python::object held_type_

namespace [anonymous]

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de $LastChangedBy$

namespace detail

Copyright (C) 2012 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

namespace I3ConverterRegistry

Functions

template<typename T>
I3ConverterPtr GetDefaultConverter()

namespace std

STL namespace.

file container_converter_detail.h

file dataclasses_container_convert.cxx

#include <vector>

#include “dataclasses_container_convert.h”

#include <icetray/I3Logging.h>

file dataclasses_container_convert.h

#include <icetray/I3PointerTypedefs.h>

#include <icetray/OMKey.h>

#include <dataclasses/TankKey.h>

#include <dataclasses/IceActKey.h>

#include <dataclasses/physics/I3Trigger.h>

#include <dataclasses/physics/I3DOMLaunch.h>

#include <dataclasses/physics/I3RecoHit.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include <dataclasses/I3TimeWindow.h>

#include <dataclasses/physics/I3MCHit.h>

#include <dataclasses/physics/I3FlasherInfo.h>

#include <tableio/I3TableRowDescription.h>

#include <tableio/I3TableRow.h>

#include <utility>

#include “pod_converter_type_mapping.h”

Defines

TABLEIO_CONVERTER_FWD_BODY

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Fabian Kislat fabian.kislat@desy.de $LastChangedBy$

TABLEIO_CONVERTER_FWD(type)

file dataclasses_IceAct_convert.cxx

#include “tableio/I3Converter.h”

#include “tableio/converter/dataclasses_IceAct_convert.h”

Defines

TABLEIO_I3MAPICEACTKEYCONVERTER_H_INCLUDED

file dataclasses_IceAct_convert.h

#include “icetray/I3Bool.h”

#include “tableio/I3Converter.h”

#include “dataclasses/I3Map.h”

#include “dataclasses/I3String.h”

#include “dataclasses/I3Vector.h”

#include “dataclasses/IceActKey.h”

#include “dataclasses/physics/I3Trigger.h”

#include “dataclasses/physics/I3IceActMaps.h”

Typedefs

typedef I3MapIceActKeyConverter<double> I3IceActDoubleMapConverter

typedef I3MapIceActKeyConverter<int32_t> I3IceActIntMapConverter

typedef I3MapIceActKeyConverter<uint32_t> I3IceActUnsignedMapConverter

typedef I3MapIceActKeyConverter<bool> I3IceActBoolMapConverter

file dataclasses_map_converters.h

#include “tableio/converter/dataclasses_container_convert.h”

#include “tableio/converter/I3MapConverter.h”

file dataclasses_vector_converters.cxx

#include “dataclasses_vector_converters.h”

file dataclasses_vector_converters.h

#include “tableio/converter/dataclasses_container_convert.h”

#include “tableio/converter/I3VectorConverter.h”

file I3BroadcastTable.cxx

#include <tableio/broadcaster/I3BroadcastTable.h>

file I3BroadcastTable.h

#include <tableio/I3Table.h>

#include <vector>

file I3BroadcastTableService.cxx

#include <tableio/broadcaster/I3BroadcastTableService.h>

#include <tableio/broadcaster/I3BroadcastTable.h>

#include <boost/foreach.hpp>

file I3BroadcastTableService.h

#include <tableio/I3TableService.h>

file I3Converter.cxx

#include <icetray/I3FrameObject.h>

#include “tableio/I3Converter.h”

file I3Converter.h

#include <string>

#include <vector>

#include <utility>

#include “icetray/IcetrayFwd.h”

#include “icetray/I3FrameObject.h”

#include “icetray/I3Frame.h”

#include “tableio/I3TableRowDescription.h”

#include “tableio/I3TableRow.h”

Typedefs

typedef uint64_t tableio_size_t

Functions

I3_FORWARD_DECLARATION(I3TableWriter)

I3_POINTER_TYPEDEFS(I3Converter)

file I3ConverterBundle.cxx

#include <icetray/I3FrameObject.h>

#include <tableio/utils/I3ConverterBundle.h>

file I3ConverterBundle.h

#include <tableio/I3Converter.h>

file I3ConverterMill.cxx

#include “tableio/detail/I3ConverterMill.h”

#include <boost/python/extract.hpp>

file I3ConverterMill.h

#include “tableio/I3Converter.h”

#include <boost/python/object.hpp>

file I3CSVTable.cxx

#include “tableio/textwriter/I3CSVTable.h”

#include “tableio/I3TableRow.h”

#include “tableio/I3TableRowDescription.h”

#include “boost/filesystem.hpp”

file I3CSVTable.h

#include “tableio/I3Table.h”

#include “tableio/I3Datatype.h”

#include <fstream>

Functions

I3_FORWARD_DECLARATION(I3TableService)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu Last changed by: $LastChangedBy$

I3_FORWARD_DECLARATION(I3TableRowDescription)

I3_FORWARD_DECLARATION(I3TableRow)

file I3CSVTableService.cxx

#include “tableio/textwriter/I3CSVTable.h”

#include “tableio/textwriter/I3CSVTableService.h”

#include “tableio/I3TableRowDescription.h”

#include <boost/filesystem.hpp>

file I3CSVTableService.h

#include “tableio/I3TableService.h”

file I3Datatype.cxx

#include “tableio/I3Datatype.h”

Functions

template<>
I3Datatype I3DatatypeFromNativeType<bool>()

Generates an I3Datatype describing a native bool.

file I3Datatype.h

#include <boost/type_traits.hpp>

#include <boost/static_assert.hpp>

#include <vector>

#include <map>

#include <string>

#include <cctype>

#include <I3/name_of.h>

Functions

template<typename T>
I3Datatype I3DatatypeFromNativeType()

Generates an I3Datatype data description object from a native type.

template<>
I3Datatype I3DatatypeFromNativeType<bool>()

Generates an I3Datatype describing a native bool.

template<typename T>
static I3Datatype I3DatatypeFromNativeType(const std::vector<std::pair<std::string, T>> &enum_labels)

Generates an I3Datatype object from an enum type.

This is an overload of the function above to treat enumerations.

Parameters:

enum_labels – Passing the labels associated with each enum value to this function allows tableio to store these labels in the output file.

file I3DirectionConverter.cxx

#include “tableio/converter/I3DirectionConverter.h”

file I3DirectionConverter.h

#include <string>

#include “tableio/I3Converter.h”

#include “dataclasses/I3Direction.h”

file I3EventHeaderConverter.cxx

#include “tableio/converter/I3EventHeaderConverter.h”

file I3EventHeaderConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/physics/I3EventHeader.h”

file I3FilterResultMapConverter.cxx

#include “tableio/converter/I3FilterResultMapConverter.h”

file I3FilterResultMapConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/physics/I3FilterResult.h”

file I3IndexColumnsGenerator.cxx

#include “tableio/converter/I3IndexColumnsGenerator.h”

#include <boost/foreach.hpp>

file I3IndexColumnsGenerator.h

#include “tableio/I3Converter.h”

#include “dataclasses/physics/I3EventHeader.h”

#include <I3/hash_map.h>

file I3MapConverter.h

#include <tableio/I3Converter.h>

#include <dataclasses/I3Map.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/geometry/I3ModuleGeo.h>

#include <icetray/OMKey.h>

#include <dataclasses/ModuleKey.h>

#include <icetray/I3Frame.h>

#include <tableio/converter/container_converter_detail.h>

#include <dataclasses/physics/I3Particle.h>

Defines

I3_MAP_CONVERTER_EXPORT(converter, docstring)

I3_MAP_CONVERTER_EXPORT_DEFAULT(converter, docstring)

file I3MapStringConverter.cxx

#include “tableio/converter/I3MapStringConverter.h”

#include “tableio/I3Converter.h”

file I3MapStringConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/I3Map.h”

Typedefs

typedef I3MapStringConverter<double> I3MapStringDoubleConverter

typedef I3MapStringConverter<int> I3MapStringIntConverter

typedef I3MapStringConverter<bool> I3MapStringBoolConverter

file I3MapStringVectorDoubleConverter.cxx

#include “tableio/converter/I3MapStringVectorDoubleConverter.h”

#include “tableio/I3Converter.h”

#include “boost/foreach.hpp”

#include <tableio/converter/container_converter_detail.h>

file I3MapStringVectorDoubleConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/I3Map.h”

file I3MemoryChunk.h

Variables

const size_t I3MEMORYCHUNK_SIZE = sizeof(I3MemoryChunk)

The amount of memory to be reserved (in the internal storage) for each table field.

file I3ParticleConverter.cxx

#include “tableio/converter/I3ParticleConverter.h”

file I3ParticleConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/physics/I3Particle.h”

file I3PositionConverter.cxx

#include “tableio/converter/I3PositionConverter.h”

file I3PositionConverter.h

#include <string>

#include “tableio/I3Converter.h”

#include “dataclasses/I3Position.h”

file I3Table.cxx

#include “tableio/I3Table.h”

#include “tableio/I3TableRow.h”

#include “tableio/I3TableRowDescription.h”

#include “tableio/I3TableService.h”

#include “tableio/I3Converter.h”

file I3Table.h

#include <string>

#include “icetray/IcetrayFwd.h”

Functions

I3_FORWARD_DECLARATION(I3TableRowDescription)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

I3_FORWARD_DECLARATION(I3TableRow)

I3_FORWARD_DECLARATION(I3EventHeader)

I3_FORWARD_DECLARATION(I3TableService)

I3_POINTER_TYPEDEFS(I3Table)

file I3TableRow.cxx

#include <cassert>

#include “tableio/I3TableRow.h”

file I3TableRow.h

#include “icetray/I3Logging.h”

#include “icetray/I3PointerTypedefs.h”

#include “tableio/I3TableRowDescription.h”

#include “tableio/I3MemoryChunk.h”

Functions

I3_FORWARD_DECLARATION(I3TableRow)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

I3_POINTER_TYPEDEFS(I3TableRow)

file I3TableRowDescription.cxx

#include “tableio/I3TableRowDescription.h”

#include <numeric>

Functions

static size_t AlignOffset(size_t offset, size_t size)

I3TableRowDescription &operator<<(I3TableRowDescription &lhs, const I3TableRowDescription &rhs)

I3TableRowDescription operator|(const I3TableRowDescription &lhs, const I3TableRowDescription &rhs)

file I3TableRowDescription.h

#include “icetray/I3Logging.h”

#include “icetray/I3PointerTypedefs.h”

#include “tableio/I3Datatype.h”

#include <string>

#include <vector>

#include <boost/unordered_map.hpp>

#include <boost/assign/list_inserter.hpp>

#include <boost/preprocessor/seq/transform.hpp>

#include “tableio/I3MemoryChunk.h”

Defines

WRAP_ELEMENTS(R, DATA, ELEM)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

MAKE_ENUM_VECTOR(VECTORNAME, CLASS, ENUM_TYPE, FIELDS)

Functions

I3_POINTER_TYPEDEFS(I3TableRowDescription)

file I3TableService.cxx

#include “tableio/I3TableService.h”

#include “tableio/I3TableRow.h”

#include “tableio/converter/I3IndexColumnsGenerator.h”

file I3TableService.h

#include <string>

#include “icetray/IcetrayFwd.h”

#include “dataclasses/physics/I3EventHeader.h”

#include “tableio/I3Table.h”

Functions

I3_FORWARD_DECLARATION(I3TableRow)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

I3_FORWARD_DECLARATION(I3Table)

I3_FORWARD_DECLARATION(I3Converter)

I3_POINTER_TYPEDEFS(I3TableService)

file I3TableTranscriber.cxx

#include <tableio/utils/I3TableTranscriber.h>

#include <tableio/I3TableRowDescription.h>

#include <tableio/I3TableRow.h>

#include <dataclasses/physics/I3EventHeader.h>

#include <boost/make_shared.hpp>

file I3TableTranscriber.h

#include <tableio/I3TableService.h>

#include <tableio/I3Table.h>

#include <tableio/converter/I3IndexColumnsGenerator.h>

file I3TableWriter.cxx

#include <icetray/I3Frame.h>

#include <dataclasses/physics/I3RecoPulse.h>

#include “tableio/I3TableWriter.h”

#include “tableio/I3TableService.h”

#include “tableio/converter/I3IndexColumnsGenerator.h”

#include <I3/name_of.h>

#include <boost/foreach.hpp>

#include <boost/make_shared.hpp>

Functions

inline I3FrameObjectConstPtr GetFrameObject(I3FramePtr frame, std::string name)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

template<typename T>
std::string name_of(const boost::shared_ptr<T> obj)

file I3TableWriter.h

#include “icetray/IcetrayFwd.h”

#include <string>

#include <set>

#include “tableio/I3Converter.h”

#include “tableio/detail/I3ConverterMill.h”

#include <boost/python.hpp>

Functions

I3_FORWARD_DECLARATION(I3TableService)

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Eike Middell eike.middell@desy.de Last changed by: $LastChangedBy$

I3_FORWARD_DECLARATION(I3Table)

I3_POINTER_TYPEDEFS(I3TableWriter)

file I3TreeConverter.h

#include <tableio/converter/container_converter_detail.h>

#include <dataclasses/I3Tree.h>

file I3VectorConverter.h

#include <tableio/I3Converter.h>

#include <dataclasses/I3Vector.h>

#include <tableio/converter/container_converter_detail.h>

file I3WaveformConverter.cxx

#include “tableio/converter/I3WaveformConverter.h”

#include “dataclasses/I3DOMFunctions.h”

#include “dataclasses/physics/I3Waveform.h”

#include “dataclasses/calibration/I3Calibration.h”

#include “dataclasses/status/I3DetectorStatus.h”

#include “icetray/I3Units.h”

#include “icetray/I3Frame.h”

file I3WaveformConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/physics/I3Waveform.h”

file I3WaveformSeriesMapConverter.cxx

#include “tableio/converter/I3WaveformSeriesMapConverter.h”

#include <dataclasses/I3DOMFunctions.h>

#include <dataclasses/physics/I3Waveform.h>

#include <dataclasses/calibration/I3Calibration.h>

#include <dataclasses/geometry/I3Geometry.h>

#include <dataclasses/status/I3DetectorStatus.h>

#include <icetray/I3Units.h>

#include <icetray/I3Frame.h>

#include <boost/foreach.hpp>

file I3WaveformSeriesMapConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/physics/I3Waveform.h”

file pod_converter_type_mapping.h

file PODConverter.cxx

#include “tableio/converter/PODConverter.h”

file PODConverter.h

#include “tableio/I3Converter.h”

#include “dataclasses/I3Double.h”

#include “icetray/I3Bool.h”

#include “icetray/I3Int.h”

Typedefs

typedef PODConverter<I3Double, double, PODConverter_NoUnit> I3DoubleConverter

typedef PODConverter<I3Int, int32_t, PODConverter_NoUnit> I3IntConverter

typedef PODConverter<I3Bool, bool, PODConverter_BoolUnit> I3BoolConverter

Variables

char PODConverter_NoUnit[] = ""

char PODConverter_BoolUnit[] = "bool"

file pybindings.h

#include “tableio/I3Converter.h”

#include <boost/python/class.hpp>

#include <boost/python/scope.hpp>

#include <boost/python/str.hpp>

#include <boost/python/dict.hpp>

#include <boost/make_shared.hpp>

Defines

I3CONVERTER_NAMESPACE(proj)

Helper macros for I3Converter pybindings

Copyright (C) 2010 The Icecube Collaboration SPDX-License-Identifier: BSD-2-Clause

$Id$

Version

$Revision$

Date

$LastChangedDate$

Author

Jakob van Santen vansanten@wisc.edu $LastChangedBy$

I3CONVERTER_EXPORT(converter, docstring)

I3CONVERTER_EXPORT_DEFAULT(converter, docstring)

I3CONVERTER_EXPORT_IMPL(converter, docstring)

I3CONVERTER_CONVERTER_OBJ(converter)

I3CONVERTER_CONVERTER_NAMESPACE(converter)

I3CONVERTER_EXPORT__WITH_CONVERTER_OBJ(converter, docstring)

I3CONVERTER_EXPORT_DEFAULT__WITH_CONVERTER_OBJ(converter, docstring)

Functions

template<typename Converter, class W, class X1, class X2, class X3>
bp::class_<W, X1, X2, X3> register_converter(bp::object &registry, bp::class_<W, X1, X2, X3> classy, bool is_default)

file PythonConverter.cxx

#include <icetray/I3FrameObject.h>

#include <tableio/converter/PythonConverter.h>

#include <boost/python.hpp>

file PythonConverter.h

#include <tableio/I3Converter.h>

#include <boost/python.hpp>

#include <icetray/I3FrameObject.h>

#include <icetray/I3Frame.h>

dir broadcaster

dir converter

dir converter

dir detail

dir icetray

dir private

dir public

dir tableio

dir tableio

dir tableio

dir textwriter

dir utils