AbstractH5Attribute | |
AbstractImportDelegateFactory | Abstract base class to inherit from when creating custom ImportDelegateFactories |
MXA::Endian::ByteSwapper | |
DataExportProperties | Base class for Data Exporters |
DataImportXmlParser | This class will parse a Data Import XML configuration file using a SAX like parsing algorithm based on the expat parser |
DataSourcePathBuilder | Utility class to help build up parts of a path |
DataSourcePathIndexSection | Represents the index value (a number) of a data source path |
DataSourcePathTextSection | Represents the text section of a Data Source path |
DIR | |
dirent | |
ExpatEvtHandler | Base class to handle Expat Events |
ExpatParser | C++ wrapper around the Expat parser library |
MXA::Endian::FromBigToSystem | |
MXA::Endian::FromLittleToSystem | |
MXA::Endian::FromSystemToBig | |
MXA::Endian::FromSystemToLittle | |
H5Attribute | Class that holds some static convenience methods |
H5AttributeWriter | Writes Attributes for a dataset to an HDF5 data file |
H5BmpImportDelegate | A generic Import Delegate that imports TIFF images into an HDF5 data file |
H5BmpImportDelegateFactory | Factory Class to generate H5BmpImportDelegate Objects |
H5BmpIO | General IO class for Bmp images |
H5DataModelReader | This class is responsible for the actual reading of the data model from the HDF5 data file |
H5DataModelWriter | Writes the DataModel to an HDF5 file |
H5Dataset | This class encapsulates an HDF5 dataset as it appears in a data file. The actual data is read into an IMXAArray instance and each attribute is its own IMXAArray instance |
H5DOperations | |
H5Image | Reimplementation of the H5IM API from the HDF5 High Level API set |
H5Lite | Class to bring together some high level methods to read/write data to HDF5 files |
H5MXADataFile | |
H5MXARequiredMetaData | Concrete implmentation of the IRequiredMetaData virtual class |
H5MXAUtilities | Utility methods that combine hdf5 functions with MXA objects |
H5SOperations | |
H5TiffImportDelegate | A generic Import Delegate that imports TIFF images into an HDF5 data file |
H5TiffImportDelegateFactory | Factory Class to generate H5TiffImportDelegate Objects |
H5TiffIO | General IO class for TIFF images |
H5TOperations | |
H5Utilities | General Utilities for working with the HDF5 data files and API |
IAttribute | Base class for attributes. This is used becase subclasses are usually templated |
IAttributeHelper | Abstract Class that defines an interface for a helper class for Attributes. The duty of the helper class is to convert the actual attribute value to a string |
IAttributeWriter | Writes an IAttribute to the underlying data storage |
IDataDimension | The formal interface description for a DataDimension |
IDataDimensionWriter | Formal Interface description for classes wanting to implement DataDimension serialization capabilities |
IDataFile | Represents an MXAData File object and the various operations that can be performed on that file |
IDataFileIO | Pure Virtual class that combines IFileWriter and IFileReader classes |
IDataImport | Abstract class that formally declares the methods used when implementing a class to import data into the underlying data storage |
IDataModel | Formally defines the methods that subclasses will need to implement when creating new MXADataModel implementations and those implementations want to be compatible with this code base |
IDataModelReader | Interface that defines what methods a class must implement to write a data model to a file |
IDataModelWriter | Abstract class that formally defines the interface that subclasses must implement to be able to write data models to files or other media |
IDataRecord | Abstract class defining the DataRecord public interface |
IDataRecordWriter | The interface that defines the method to implement in order to write a data record to a file |
IDataset | Pure virtual class that represents a dataset with appropriate attributes so that the data could be written to an underlying data file. Currently HDF5 |
IDataSource | Interface that defines the methods of a "Data Source" Object |
IFileIODelegate | This is the interface that delegates need to implement in order to serialize/deserialize the model from a data file |
IFileReader | Defines a basic file reading interface |
IFileWriter | Defines a basic file writing interface |
IH5Operations | This is meant to be a superclass that encapsulates certain HDF5 open/close operations. The idea is to instantiate a class each time you need to do an open/close operation, then put the class on a stack. At the end of a series of operations, you can 'pop' each class from the stack and then call 'close' and the HDF5 object will be closed, thus saving resource leaks. The thinking was to combine this with the boost::shared_ptr and create a std::stack<boost::shared_ptr<IH5Operations*> >. That way you can just 'pop' each pointer from the stack and the destructor would be called on the object |
IImportDelegate | Formally defines the methods that subclasses need to implement to create a delegate to import data sources into HDF5 data files |
IImportProperty | |
ImportDelegateManager | This is a Singleton class that exists to register Data Import Factory classes |
IMXAArray | This class holds a raw pointer to some allocated data that can be stored into or read from an HDF5 data file. The class design was borrowed heavily from the vtkDataArray class from www.vtk.org. The work was all performed by those individuals. I have merely changed a few methods to meet my specific needs |
INode | Interface declaration for objects that want to implement a "Tree" type data structure |
IRequiredMetaData | This class holds all the required meta data that is used by the MXADataModel and is included in each data file |
IStringSection | Abstract superclass that defines the methods to generate strings from the formatting information |
ISupportFile | Formal Interface for managing arbitrary files that will be added to the HDF5 file |
ITiffTagExtractor | Abstract Base class for classes wishing to extract the contents from specific Tiff Tags from the image file |
MXA2DArray< T > | This class represents a generic 2D array of data |
MXAArrayTemplate< T > | Template class for wrapping raw arrays of data |
MXAAsciiStringData | |
MXABMPDIBHeader | This holds the Bitmap info header values. Only V3 headers are supported |
MXABMPFileHeader | This holds the bitmap file header values |
MXABmpIO | This class Handles the Reading of Windows Bitmap files (.bmp) |
MXADataDimension | A concrete implementation of the IDataDimension Abstract Class |
MXADataImport | Concrete implementation of the IDataImport abstract class and controls the main import loop |
MXADataModel | Main class used to work with the DataModel paradigm |
MXADataRecord | This class holds the required and any extended information about a data record. Data records can have any number of children but only one parent |
MXADataSource | This class holds the information needed to read data from a source and store that data into the underlying data storage for the MXA Data Model (HDF5 or XML) |
MXAFILEREADER_CLASS_NAME | |
MXAFileSystemPath | The class allows for some interrogation of the file system regarding the existance of files or directories and also allows for the creation and deletion of files or directories from the filesystem |
MXAFILEWRITER_CLASS_NAME | |
MXALogger | MXALogger is a wrapper class around the actual implementation class. MXALogger should be used to log debug information into a log file or to std::cout |
MXALogger_Implementation | The actual implementation of the logging class. This class should NEVER be instantiated by a program. Use 'MXALogger' instead |
MXANode | This class is a concrete implementation of the INode abstract class. It is meant to be subclassed by other classes that need to maintain parent/child relationships |
MXARGBImage | This class represents a 2D array of rgb values. The data is written to the data file using the H5Image protocol. This means that some extra attributes are written to the dataset in addition to the data. If this is NOT what you want then use the generic MXA2DArray class instead |
MXASupportFile | This class serves as a container to hold the necessary information to read either the meta data about a support file from the HDF5 file or read the file from the filesystem |
NumberAttributeHelper< T > | |
RequiredMetaData | Concrete implmentation of the IRequiredMetaData virtual class |
MXA::Endian::Detail::ReverseBytes< sizeof(uint16) > | |
MXA::Endian::Detail::ReverseBytes< sizeof(uint32) > | |
MXA::Endian::Detail::ReverseBytes< sizeof(uint64) > | |
StringAttributeHelper | Some helper classes for Attributes |
StringUtils | Just some convenience utilities for dealing with strings |
MXA::RTTI::Typed | |
VectorAttributeHelper< T > | |
vtkHDF5 | Bridge code to read HDF5 data objects into vtk data structures |
XMLDataModelReader | This class is a concrete implementation of the IDataModelReader abstract class. This class is responsible for reading a data model from an XML File |
XMLDataModelWriter | Concrete implementation of IDataModelWriter that is used to write the data model to an XML file |
XMLIODelegate | Concrete implementation of the IFileIODelegate interface. This class supports reading/writing of the data model and data to and from XML files |
XMLMXAAttributeWriter | Delegate type class that writes attributes to an xml file |
XMLUserMetaDataWriter | This class writes User meta data from the data model to an xml file |