framefast/frameio.hh

/*----------------------------------------------------------------------*/
/*                                                                      */
/* Module Name: frameio                                                 */
/*                                                                      */
/* Module Description: Frame IO routines                                */
/*                                                                      */
/* Revision History:                                                    */
/* Rel   Date     Programmer    Comments                                */
/* 0.1   26Sep00  D. Sigg       First release                           */
/*                                                                      */
/* Documentation References:                                            */
/*      Man Pages: framefast.html                                       */
/*      References: none                                                */
/*                                                                      */
/* Author Information:                                                  */
/* Name          Telephone       Fax             e-mail                 */
/* Daniel Sigg   (509) 372-8132  (509) 372-8137  sigg_d@ligo.mit.edu    */
/*                                                                      */
/*                                                                      */
/*                      -------------------                             */
/*                                                                      */
/*                             LIGO                                     */
/*                                                                      */
/*        THE LASER INTERFEROMETER GRAVITATIONAL WAVE OBSERVATORY.      */
/*                                                                      */
/*                     (C) The LIGO Project, 1999.                      */
/*                                                                      */
/*                                                                      */
/* Caltech                              MIT                             */
/* LIGO Project MS 51-33                LIGO Project NW-17 161          */
/* Pasadena CA 91125                    Cambridge MA 01239              */
/*                                                                      */
/* LIGO Hanford Observatory             LIGO Livingston Observatory     */
/* P.O. Box 1970 S9-02                  19100 LIGO Lane Rd.             */
/* Richland WA 99352                    Livingston, LA 70754            */
/*                                                                      */
/*----------------------------------------------------------------------*/

#ifndef _LIGO_FRAMEIO_H
#define _LIGO_FRAMEIO_H


#include <time.h>
#include <string>


namespace framefast {




   class basic_frame_storage {
   public:
      basic_frame_storage () {
      }
      virtual ~basic_frame_storage() {
      }
      virtual void reset() = 0;
      virtual const char* data() const = 0;
      virtual int size() const = 0;
      virtual bool empty() const {
         return data() != 0; }
   
      const char* name() const {
         return fName.c_str(); }
      void setname (const char* n) {
         fName = n ? n : ""; }
   protected:
      std::string       fName;
   
   private:
      basic_frame_storage (const basic_frame_storage&);
      basic_frame_storage& operator= (const basic_frame_storage&);
   };


   class memory_frame_storage : public basic_frame_storage {
   public:
      memory_frame_storage (const char* data, int len, bool own = true) 
      : fOwn (own), fData (data), fLength (len) {
      }
      virtual ~memory_frame_storage() {
         reset(); }
      virtual void reset();
      virtual const char* data() const {
         return fData; }
      virtual int size() const {
         return fLength; }
   
   protected:
      bool              fOwn;
      const char*       fData;
      int               fLength;
   };


   class file_frame_storage : public memory_frame_storage {
   public:
      explicit file_frame_storage (const char* filename = 0) 
      : memory_frame_storage (0, 0) {
         if (filename) load (filename); }
      bool load (const char* filename);
   };


   class mmap_frame_storage : public basic_frame_storage {
   public:
      explicit mmap_frame_storage (const char* filename = 0) 
      : fAddr (0), fLength (0) {
         if (filename) map (filename); }
      virtual ~mmap_frame_storage() {
         reset(); }
      virtual void reset();
      virtual const char* data() const {
         return fAddr; }
      virtual int size() const {
         return fLength; }
      bool map (const char* filename);
   
   protected:
      const char*       fAddr;
      int               fLength;
   };


   class frame_storage_ptr {
   public:
      frame_storage_ptr () : fFrame (0) {
      }
      explicit frame_storage_ptr (basic_frame_storage* frame) : 
      fFrame (frame) {
      }
      frame_storage_ptr (const frame_storage_ptr& fptr) {
         fFrame = fptr.release(); }
      frame_storage_ptr& operator= (const frame_storage_ptr& fptr) {
         if (this != &fptr) {
            reset(); fFrame = fptr.release(); }
         return *this; }
      ~frame_storage_ptr () {
         reset(); }
      void set (basic_frame_storage* frame) {
         reset(); fFrame = frame; }
      void reset () {
         if (fFrame) delete fFrame; fFrame = 0; }
      basic_frame_storage* release () const {
         basic_frame_storage* frame = fFrame; fFrame = 0; 
         return frame; }
      const char* data () const {
         return fFrame ? fFrame->data() : 0; }
      int size () const {
         return fFrame ? fFrame->size() : 0; }
      const char* name () const {
         return fFrame ? fFrame->name() : 0; }
   
   protected:
      mutable basic_frame_storage*      fFrame;
   };



   class basic_frameout {
   public:
      struct src_dest_t {
         const char*    fAddr;
         int            fLen;
      };
   
      basic_frameout() : fSofar (0) {
      }
      virtual ~basic_frameout() {
      }
      virtual bool open (int len = 0) = 0;
      virtual void close() = 0;
      virtual bool write (const char* p, int len) = 0;
      virtual bool write (const src_dest_t* s, int slen) {
         for (int i = 0; i < slen; i++) {
            if (!write (s[i].fAddr, s[i].fLen))
               return false; }
         return true; }
      virtual int length() const {
         return fSofar; }
   
   protected:
      int               fSofar;
   };


   class memory_out : public basic_frameout, public memory_frame_storage {
   public:
      memory_out (char* data = 0, int maxsize = 0, bool own = false)
      : memory_frame_storage (data, maxsize, own) {
      }
      virtual ~memory_out () {
         close (); }
      virtual bool open (int len = 0);
      virtual void close() {
      }
      virtual bool write (const char* p, int len);
      virtual bool write (const src_dest_t* s, int slen) {
         return basic_frameout::write (s, slen); }
   };


   class desc_out : public basic_frameout {
   public:
      desc_out (int filedesc) : fd (filedesc) {
      }
      virtual bool open (int len = 0) {
         return true; }
      virtual void close() {
      }
      virtual bool write (const char* p, int len);
      virtual bool write (const src_dest_t* s, int slen);
   
   protected:
      int               fd;
   };


   class file_out : public desc_out {
   public:
      file_out (const char* filename) 
      : desc_out (-1), fFilename (filename) {
      }
      virtual ~file_out () {
         close (); }
      virtual bool open (int len = 0);
      virtual void close();
   
   protected:
      std::string       fFilename;
   };



}

#endif  // _LIGO_FRAMEIO_H

---