cmtkTypedStream.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2009 Torsten Rohlfing
//
//  Copyright 2004-2011 SRI International
//
//  This file is part of the Computational Morphometry Toolkit.
//
//  http://www.nitrc.org/projects/cmtk/
//
//  The Computational Morphometry Toolkit is free software: you can
//  redistribute it and/or modify it under the terms of the GNU General Public
//  License as published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  The Computational Morphometry Toolkit is distributed in the hope that it
//  will be useful, but WITHOUT ANY WARRANTY; without even the implied
//  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License along
//  with the Computational Morphometry Toolkit.  If not, see
//  <http://www.gnu.org/licenses/>.
//
//  $Revision: 2752 $
//
//  $LastChangedDate: 2011-01-17 11:33:31 -0800 (Mon, 17 Jan 2011) $
//
//  $LastChangedBy: torstenrohlfing $
//
*/

#ifndef __cmtkTypedStream_h_included_
#define __cmtkTypedStream_h_included_

#include <cmtkconfig.h>

#include <Base/cmtkTypes.h>

#include <stack>
#include <stdio.h>

#include <zlib.h>

#ifndef NULL
#define NULL 0
#endif

#include <string>

namespace
cmtk
{



typedef enum 
{
  TYPEDSTREAM_READ,
  TYPEDSTREAM_WRITE,
  TYPEDSTREAM_WRITE_ZLIB,
  TYPEDSTREAM_APPEND
} TypedStreamMode;

typedef enum 
{
  TYPEDSTREAM_ERROR,
  TYPEDSTREAM_OK
} TypedStreamCondition;

typedef enum 
{
  TYPEDSTREAM_ERROR_NONE,
  TYPEDSTREAM_ERROR_UNKNOWN,
  TYPEDSTREAM_ERROR_SYSTEM,
  TYPEDSTREAM_ERROR_FORMAT,
  TYPEDSTREAM_ERROR_ARG,
  TYPEDSTREAM_ERROR_MODE,
  TYPEDSTREAM_ERROR_TYPE,
  TYPEDSTREAM_ERROR_LIMIT,
  TYPEDSTREAM_ERROR_LEVEL,
  TYPEDSTREAM_ERROR_INVALID,
  TYPEDSTREAM_ERROR_MAX
} TypedStreamStatus;

typedef enum 
{
  TYPEDSTREAM_TYPE_INT,
  TYPEDSTREAM_TYPE_BOOL,
  TYPEDSTREAM_TYPE_BINARYBOOL,
  TYPEDSTREAM_TYPE_FLOAT,
  TYPEDSTREAM_TYPE_DOUBLE,
  TYPEDSTREAM_TYPE_STRING
} TypedStreamType;

typedef enum 
{
  TYPEDSTREAM_EOF,
  TYPEDSTREAM_BEGIN,
  TYPEDSTREAM_END,
  TYPEDSTREAM_KEY,
  TYPEDSTREAM_VALUE,
  TYPEDSTREAM_COMMENT
} TypedStreamToken;

typedef enum 
{
  TYPEDSTREAM_DEBUG_OFF,
  TYPEDSTREAM_DEBUG_ON
} TypedStreamDebugFlag;

#define TYPEDSTREAM_LIMIT_BUFFER        1024

#define TYPEDSTREAM_FLUSH true

#define TYPEDSTREAM_NOFLUSH false

class TypedStream 
{
public:
  TypedStream();

  TypedStream( const char* filename, const TypedStreamMode mode );

  TypedStream( const char* dir, const char* archive, const TypedStreamMode mode );

  virtual ~TypedStream();

  void Open( const char* filename, const TypedStreamMode mode );

  void Open( const char* dir, const char* archive, const TypedStreamMode mode );

  void Close();

  TypedStreamCondition Seek( const char* section , 
                             const bool forward = false );

  TypedStreamCondition Rewind();

  int IsValid() 
  {
    return (this->File != NULL) || (this->GzFile != NULL); 
  }

  TypedStreamStatus GetStatus() const 
  { 
    return this->Status; 
  }

  TypedStreamCondition Begin( const char* section = NULL );

  TypedStreamCondition End( const bool flush = false );

  bool ReadBool( const char* key , 
                 const bool defaultValue = false ,
                 const bool forward = false );

  TypedStreamCondition ReadBoolArray( const char* key , 
                                      byte *const array , 
                                      const int size , 
                                      const bool forward = false );
  
  int ReadInt( const char* key , 
               const int defaultValue = 0 , 
               const bool forward = false );

  TypedStreamCondition ReadIntArray( const char* key , 
                                     int *const array , 
                                     const int size , 
                                     const bool forward = false );
  
  float ReadFloat( const char* key , 
                   const float defaultValue = 0 , 
                   const bool forward = false );

  TypedStreamCondition ReadFloatArray( const char* key , 
                                       float *const array , 
                                       const int size , 
                                       const bool forward = false );

  double ReadDouble( const char* key ,
                     const double defaultValue = 0 , 
                     const bool forward = false );

  TypedStreamCondition ReadDoubleArray( const char* key , 
                                        double *const array , 
                                        const int size , 
                                        const bool forward = false );
  
  Types::Coordinate ReadCoordinate( const char* key , 
                                    const Types::Coordinate defaultValue = 0 , 
                                    const bool forward = false ) 
  {
#ifdef CMTK_COORDINATES_DOUBLE
    return this->ReadDouble( key, defaultValue, forward );
#else
    return this->ReadFloat( key, defaultValue, forward );
#endif
  }
  
  Types::DataItem ReadItem( const char* key , 
                            const Types::DataItem defaultValue = 0 , 
                            const bool forward = false ) 
  {
#ifdef CMTK_DATA_DOUBLE
    return this->ReadDouble( key, defaultValue, forward );
#else
    return this->ReadFloat( key, defaultValue, forward );
#endif
  }
  
  TypedStreamCondition ReadCoordinateArray( const char* key , 
                                            Types::Coordinate *const array , 
                                            const int size , 
                                            const bool forward = false )
  {
#ifdef CMTK_COORDINATES_DOUBLE
    return this->ReadDoubleArray( key, array, size, forward );
#else
    return this->ReadFloatArray( key, array, size, forward );
#endif
  }

  TypedStreamCondition ReadItemArray( const char* key , 
                                      Types::DataItem *const array , 
                                      const int size , 
                                      const bool forward = false ) 
  {
#ifdef CMTK_DATA_DOUBLE
    return this->ReadDoubleArray( key, array, size, forward );
#else
    return this->ReadFloatArray( key, array, size, forward );
#endif
  }

  char* ReadString( const char* key , 
                    const char* defaultValue = NULL , 
                    const bool forward = false );

  TypedStreamCondition WriteBool( const char* key , 
                                  const bool value  );

  TypedStreamCondition WriteInt( const char* key , 
                                 const int value  );

  TypedStreamCondition WriteFloat( const char* key , 
                                   const float value  );

  TypedStreamCondition WriteDouble( const char* key , 
                                    const double value  );

  TypedStreamCondition WriteCoordinate( const char* key , 
                                        const Types::Coordinate value  ) 
  {
#ifdef CMTK_COORDINATES_FLOAT
    return this->WriteFloat( key, value );
#else
    return this->WriteDouble( key, value );
#endif
  }
  
  TypedStreamCondition WriteItem( const char* key , 
                                  const Types::DataItem value  ) 
  {
#ifdef CMTK_DATA_FLOAT
    return this->WriteFloat( key, value );
#else
    return this->WriteDouble( key, value );
#endif
  }
  
  TypedStreamCondition WriteString( const char* key , 
                                    const char* value  );

  TypedStreamCondition WriteString( const char* key , 
                                    const std::string& value  );

  TypedStreamCondition WriteComment( const char* fmt , ... );

  TypedStreamCondition WriteComment( const int argc , const char* argv[]  );

  TypedStreamCondition WriteComment( int argc , char* argv[]  );

  TypedStreamCondition WriteIntArray( const char* key , 
                                      const int* array , 
                                      const int size ,
                                      const int valuesPerLine = 10  );

  TypedStreamCondition WriteBoolArray( const char* key , 
                                       const byte* array , 
                                       const int size , 
                                       const int valuesPerLine = 10  );

  TypedStreamCondition WriteFloatArray( const char* key, 
                                        const float* array , 
                                        const int size ,
                                        const int valuesPerLine = 10  );

  TypedStreamCondition WriteDoubleArray( const char* key , 
                                         const double* array , 
                                         const int size ,
                                         const int valuesPerLine = 10  );

  TypedStreamCondition WriteCoordinateArray( const char* key, 
                                             const Types::Coordinate* array , 
                                             const int size ,
                                             const int valuesPerLine = 10  )
  { 
#ifdef CMTK_COORDINATES_DOUBLE
    return this->WriteDoubleArray( key, array, size, valuesPerLine );
#else
    return this->WriteFloatArray( key, array, size, valuesPerLine );
#endif
  }
  
  TypedStreamCondition WriteItemArray( const char* key , 
                                       const Types::DataItem* array , 
                                       const int size , 
                                       const int valuesPerLine = 10  )
  { 
#ifdef CMTK_DATA_DOUBLE
    return this->WriteDoubleArray( key, array, size, valuesPerLine );
#else
    return this->WriteFloatArray( key, array, size, valuesPerLine );
#endif
  }

  void SetDebugFlag( const TypedStreamDebugFlag debugFlag = TYPEDSTREAM_DEBUG_ON  )
  { 
    DebugFlag = debugFlag;
  }
  
private:
  void InitInternals();

  FILE *File;

  gzFile GzFile;

  TypedStreamMode Mode;

  TypedStreamStatus Status;

  int PrecisionFloat;

  int PrecisionDouble;

  char Buffer[TYPEDSTREAM_LIMIT_BUFFER];

  char* BufferKey;

  char* BufferValue;

  std::stack<int> LevelStack;

  TypedStreamCondition GenericReadArray( const char* key , 
                                         const int type , 
                                         void *const array , 
                                         const int arraySize , 
                                         const bool forward = false  );
  
  TypedStreamToken ReadLineToken();

  static int StringCmp( const char* s1, const char* s2 );

  char* StringSplit( char* s1  ) const;

  mutable char* SplitPosition;

  static const char* GetTypedStreamIdent() 
  {
    return "! TYPEDSTREAM 1.1\n";
  }
  
  TypedStreamDebugFlag DebugFlag;
  
  void DebugOutput( const char* format , ... );
};


} // namespace cmtk


#endif // #ifndef __cmtkTypedstream_h_included_