---

ResponseFile.h

Go to the documentation of this file.

// $Id: ResponseFile.h,v 1.6 2001/08/08 01:44:05 burnett Exp $
// ResponseFile.h
//  Author:     Sawyer Gillespie
//              University of Washington, Dept. of Physics
//              hgillesp@u.washington.edu
//
//  Specification for the ResponseFile class.
//

#ifndef _H_ResponseFile_hsg
#define _H_ResponseFile_hsg

#include "instrument/DetectorConverter.h"
#include "instrument/GlastDetector.h"
#include "facilities/bpkt_streams.h"
#include <strstream>

// forward declarations
namespace xml {
  class IFile;
}

class   ResponseFile : public DetectorConverter {
 public:
  // enum
  typedef enum { none_mode = 0, ascii_mode, binary_mode, dual_mode } 
  ios_mode;

  // constructors - ResponseFile takes ownership of the ostream/istream
  //                  depending upon the owns flag
  ResponseFile(std::istream*, bool owns = false, ios_mode mode = ascii_mode);
  ResponseFile(std::ostream*, bool owns = false, ios_mode mode = ascii_mode);
  ResponseFile(const char* fname, bool read = false, 
               ios_mode mode = ascii_mode);

  virtual ~ResponseFile ();

  // operator definitions

  ResponseFile&   operator >> (GlastDetector&);
  ResponseFile&   operator << (const GlastDetector&);

  bool    read_event ();

  void    write_event ();

  void    write_event( std::vector<int> header);

  bool    good () const;

  int    mode () const;

  // version control information
  std::string version () const;
  std::string revision () const;

  // load-in paramters from an ini structure
  static void loadParameters (xml::IFile& ini);  

  int     ndet_read()const { return m_det_read;} 

  static void createFactories();

 protected:
  // setting files
  void    setin (std::istream* i, ios_mode mode, bool owns = false);
  void    setout (std::ostream* o, ios_mode mode, bool owns = false);

  // verification scheme
  bool  verify(std::istream&, ios_mode);  // verify file compatibility
  void  verify(std::ostream&, ios_mode);  // write file compatibility sequence

  // native formatting
  void    end_record ();
  void    end_event ();
  int     next_id ();
  std::string flush_record ();

  // format information
  static int  event_end_id ();
  static char record_end_char ();

  // read/write the individual GlastDetector data types
  void   backward (CsIDetector&);
  void   backward (MCTruth&);
  void   backward (Scintillator&);
  void   backward (SiDetector&);
  void   forward (const CsIDetector&);
  void   forward (const MCTruth&);
  void   forward (const Scintillator&);
  void   forward (const SiDetector&);

  // friends
  friend class CsIDetector;
  friend class MCTruth;
  friend class Scintillator;
  friend class SiDetector;

 private:
  // type declarations
  typedef std::map <GlastDetector::id_type, void*>    DataMap;

  // data members
  bpkt::istream*  m_binin;    
  std::istream*   m_stdin;    
  bool            m_ownsin;   
  bpkt::ostream*  m_binout;   
  std::ostream*   m_stdout;   
  bool            m_ownsout;  
  DataMap         m_data;     
  std::string     m_version;  
  std::string     m_revision; 

  int             m_det_read; 
  // friends
  template <class _Ty> friend ResponseFile&  operator << 
    (ResponseFile&, const _Ty&);
  template <class _Ty> friend ResponseFile&  operator >> 
    (ResponseFile&, _Ty&);

  // class wide data members
  static const char*  s_version;  // current version
  static const char*  s_revision; // current revision
};

// external operators

template <class _Ty>
ResponseFile&   operator << (ResponseFile& f, const _Ty& t) {
  if (f.m_stdout) *f.m_stdout << t << ' ';
  if (f.m_binout) *f.m_binout << t;
  return f;
}

template <class _Ty>
ResponseFile&   operator >> (ResponseFile& f, _Ty& t) {
  if (f.m_stdin) *f.m_stdin >> t;
  if (f.m_binin) *f.m_binin >> t;
  return f;
}

// inline methods

inline ResponseFile&   ResponseFile::operator >> (GlastDetector& d)
{
  d.accept (*this);
  return *this;
}

inline ResponseFile&   ResponseFile::operator << (const GlastDetector& p)
{
  if (!p.empty()) {
    if (m_stdout)   (*m_stdout) << '\n';
    (*this) << p.id();
    p.accept (*this);
    end_record ();
  }
  return *this;
}

inline bool     ResponseFile::good () const
{
  if (m_binin)   return m_binin->good();
  if (m_binout)  return m_binout->good();
  if (m_stdin) return m_stdin->good();
  if (m_stdout) return m_stdout->good();
  return false;
}

inline int ResponseFile::event_end_id ()
{
  return -1;
}

inline char ResponseFile::record_end_char ()
{
  return '|';
}

inline void ResponseFile::end_record ()
{
  // write the GlastDetector id followed by the size of the 
  // GlastDetector record.
  if (m_binout)  *(m_binout) << std::flush;
  if (m_stdout)  *(m_stdout) << record_end_char();
}

inline void ResponseFile::end_event ()
{
  if (m_stdout) *m_stdout << '\n';
  (*this) << event_end_id();
  if (m_binout) *m_binout << std::flush;
  if (m_stdout) *m_stdout << std::flush;
}

inline int ResponseFile::next_id ()
{
  int i;
  (*this) >> i;
  return i;
}

inline std::string ResponseFile::flush_record ()
{
  std::string s = "";

  if (m_binin)    m_binin->sync();
  if (m_stdin) {
    std::getline (*m_stdin, s, record_end_char());
  }

  return s;
}

inline std::string ResponseFile::version () const
{
  return m_version;
}

inline std::string ResponseFile::revision () const
{
  return m_revision;
}

inline int   ResponseFile::mode () const
{
  return ((m_binout || m_binin) ? binary_mode : none_mode) + 
    ((m_stdin || m_stdout) ? ascii_mode : none_mode);
}

#endif // _H_ResponseFile_hsg

---