LCSIO.h

#ifndef SIO_LCSIO_H
#define SIO_LCSIO_H 1

#include "LCIOTypes.h"

#include "SIO_record.h" 
#include "SIO_definitions.h"

#include <string>

// record and block names used in LCIO-SIO
#define LCSIO_RUNRECORDNAME    "LCRunHeader"
#define LCSIO_RUNBLOCKNAME     "RunHeader"
#define LCSIO_EVENTRECORDNAME  "LCEvent"
#define LCSIO_EVENTBLOCKNAME   "Event"
#define LCSIO_HEADERRECORDNAME "LCEventHeader"
#define LCSIO_HEADERBLOCKNAME  "EventHeader"

#define LCSIO_ACCESSRECORDNAME "LCIORandomAccess"
#define LCSIO_ACCESSBLOCKNAME  "LCIORandomAccess"
#define LCSIO_RANDOMACCESS_SIZE 136 
#define LCSIO_INDEXRECORDNAME "LCIOIndex"
#define LCSIO_INDEXBLOCKNAME  "LCIOIndex"


class SIO_stream ;

namespace SIO {

  class LCSIO ;

  class SIORecords {

    friend class LCSIO ;
  public:
    
    enum ID{
      Event=0,
      Header,
      Run,
      Access,
      Index,
      NumberOfRecords 
    } ;
    //-----------------------------------------------
    class Unpack{
    public:
      static const unsigned Event  = 0x0001 << SIORecords::Event ;
      static const unsigned Header = 0x0001 << SIORecords::Header ;
      static const unsigned Run    = 0x0001 << SIORecords::Run ;
      static const unsigned Access = 0x0001 << SIORecords::Access ;
      static const unsigned Index  = 0x0001 << SIORecords::Index ;

      static const unsigned All = 0xFFFFFFFF ; 
      
      Unpack( unsigned recordFlag ) ;
      ~Unpack() ;

    protected:
      bool _flags[ NumberOfRecords ] ;  
    };
    //-----------------------------------------------


    SIO_record* operator[](size_t idx) ;

    void setCompress( bool flag=true ) ;

  protected:
    void add(SIO_record*& rec, const char* name) ;

    SIO_record* _records[ NumberOfRecords ] ;

    SIORecords() ;
  } ;


#define LCSIO_READ( rec, pnt ) status = LCSIO::read( (rec), (pnt)  ); if( !(status & 1) ) return status;
#define LCSIO_READ_LEN( rec, pnt , len ) status = LCSIO::read( (rec), (pnt) , (len)  ); if( !(status & 1) ) return status;

#define LCSIO_WRITE( rec, pnt ) status = LCSIO::write( (rec), (pnt)  ); if( !(status & 1) ) return status;

  class LCSIO{
  
  public :
  
    static SIORecords& records() ;

//     // define some names of records and blocks
//     static const char* RUNRECORDNAME ; 
//     static const char* RUNBLOCKNAME ; 
//     static const char* EVENTRECORDNAME ; 
//     static const char* EVENTBLOCKNAME;
//     static const char* HEADERRECORDNAME ; 
//     static const char* HEADERBLOCKNAME;

     static const char* FILE_EXTENSION ;

    static const bool COMPRESSION = true ;


    static void checkVersion(int versionID ) ;

    static unsigned int read( SIO_stream* stream ,char** c , int* len=0) ;

//     /** This version checks the versionId to be able to read 'old' files with 
//      * trailing '\00' (version <= 00-02).
//      * Remove this method after a reasonable transition period...
//      */
//     static unsigned int read( SIO_stream* stream ,char** c, int versionID) ;
  
    static unsigned int write( SIO_stream* stream , int i) ;

    static unsigned int write( SIO_stream* stream , unsigned int i) ;
  
#if defined(_LP64)  || defined(__APPLE_CC__)
//    static unsigned int write( SIO_stream* stream , SIO_POINTER_DECL i) ;
    static unsigned int write( SIO_stream* stream , size_t i) ;
#endif

    static unsigned int write( SIO_stream* stream , EVENT::long64 i) ;

    static unsigned int write( SIO_stream* stream , float f) ;
  
    static unsigned int write(SIO_stream* stream , const std::string& s) ;
  
  
    static std::string getValidSIOName(const std::string& aName ) ;
    //    static const char* getValidSIOName(const std::string& aName ) ;


    static void seekStream( SIO_stream* stream , EVENT::long64 pos) ;


  private:

    static char* dummy  ;
    static int dummy_size  ;
    static int uid ;
    static const int dummy_initial_size = 1024  ;

  } ;

} // namespace 
#endif // ifndef SIO_LCSIO_H