mi32/genrcrwtxt.h

Go to the documentation of this file.

/****
 * \file mi32/genrcrwtxt.h
 * \brief Definitions for GENERICRW_TEXT class.
 *
 * \if NODOC
 * $Id: genrcrwtxt.h_v 1.19 2011/10/13 12:42:14 mju Exp $
 *
 * $Log: genrcrwtxt.h_v $
 * Revision 1.19  2011/10/13 12:42:14  mju
 * Remove redundant hdrs.
 *
 * Revision 1.18  2010/04/21 17:29:46  mju
 * Add op<< for unsigned.
 *
 * Revision 1.16  2007/03/21 22:42:21  scowan
 * Added methods to posn class.
 *
 * Revision 1.15  2006/06/14 14:30:46  mju
 * Use charencoding hdr.
 *
 * Revision 1.12  2006/04/13 16:26:12  dfriberg
 * Add readline method with max number of characters
 *
 * Revision 1.11  2005/12/28 16:51:47  scowan
 * Added method to access the approx posn in the POSN class.
 *
 * Revision 1.10  2005/09/23 19:38:40  drb
 * ReadLine (MISTRING) returns line length or -1 at EOF
 *
 * Revision 1.9  2005/03/04 23:36:02  dfriberg
 * Added LINETERMINATOR detect method
 *
 * Revision 1.1  2004/10/18 16:29:01  dfriberg
 * Initial revision
 * \endif
****/

#ifndef  INC_MI32_GENRCRWTXT_H
#define  INC_MI32_GENRCRWTXT_H

#ifndef  INC_MI32_GENERICRW_H
#include <mi32/genericrw.h>
#endif

#ifndef  INC_MI32_CHARENCODING_H
#include <mi32/charencoding.h>
#endif

#ifndef  INC_MI32_FILEACCESS_H
#include <mi32/fileaccess.h>
#endif

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class FILEPATH;
class MISTRING;
class STRUTF8;
#endif

class CLASSLIBEXPORT GENERICRW_TEXT {
   public:

      enum LINETERMINATOR {
         LINETERMINATOR_CR = 0,
         LINETERMINATOR_LF,
         LINETERMINATOR_CRLF,
         LINETERMINATOR_LFCR,
         LINETERMINATOR_Default
         };

      enum CAPABILITIES {
         CAPABILITY_None =          0x000,
         CAPABILITY_Read =          0x001,
         CAPABILITY_Write =         0x002,
         CAPABILITY_Size =          0x004,
         CAPABILITIES_All =         0x00F,
         };

   #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
   #endif

      class POSN {
         public:
            POSN (
               ) : m_posn(0) { }

            POSN (
               const POSN& rhs
               ) : m_posn(rhs.m_posn) { }
               
            POSN& operator= (
               const POSN& rhs 
               ) {
               if (&rhs != this) {
                  m_posn = rhs.m_posn; 
                  }
               return (*this);
               }

            INT64 GetApproxPosn (
               ) const { return (m_posn); }
               
            INT64 GetStorable ( 
               ) const { return (m_posn); }
               
            void SetFromStorable (
               INT64 posn
               ) { m_posn = posn; }

         private:
            INT64 m_posn;

            explicit POSN (
               INT64 posn
               ) : m_posn(posn) { }

            // Cast to INT64 - Returns actual position in data
            operator INT64 (
               ) const { return (m_posn); }

            friend class PRIV;
         };

      GENERICRW_TEXT& operator<< (
         int value
         );

      GENERICRW_TEXT& operator<< (
         unsigned value
         );

      GENERICRW_TEXT& operator<< (
         double value
         );

      GENERICRW_TEXT& operator<< (
         const char* str
         );

      GENERICRW_TEXT& operator<< (
         const MISTRING& str
         );

      GENERICRW_TEXT& operator<< (
         const STRUTF8& str
         );

      // Get file text encoding.
      CHAR_ENCODING GetEncoding (
         ) const;

      INT64 GetSize (
         ) const;

      ERRVALUE ReadAll (
         MISTRING& string
         );

      INT32 ReadLine (
         MISTRING& string,                   
         bool stripnewline = true            
         );

      INT32 ReadLine (
         MISTRING& string,                   
         bool stripnewline,                  
         INT32 maxlength                     
         );
         
      ERRVALUE ReadLine (
         STRUTF8& string,                    
         bool stripnewline = true            
         );
         
      ERRVALUE ReadLine (
         STRUTF8& string,
         bool stripnewline,
         INT32 maxlength                     
         );

      ERRVALUE Rewind (
         );

      POSN Seek (
         const POSN& posn
         );

      ERRVALUE SeekToEnd (
         );

      void SetEncoding(
         CHAR_ENCODING encoding
         );

      void SetLineTerminator(
         LINETERMINATOR terminator
         );

      POSN Tell (
         ) const;

      ERRVALUE Write (
         const MISTRING& string,             
         bool appendnewline = false          
         );

      ERRVALUE Write (
         const STRUTF8& string,              
         bool appendnewline = false          
         );

      ERRVALUE Write (
         const char* string,                 
         bool appendnewline = false          
         );

   protected:
      GENERICRW_TEXT (
         );

      virtual ~GENERICRW_TEXT (
         );

      LINETERMINATOR DetectLineTerminator ();

   private:

   #ifndef GENERATING_DOXYGEN_OUTPUT
      GENERICRW_TEXT::PRIV *m_Priv;
      friend class GENERICRW_TEXT::PRIV;
   #endif

      virtual INT64 v_GetSize() const=0;

      virtual INT64 v_Read(void *buf, INT32 numbytes, bool AllowPartial)=0;

      virtual ERRVALUE v_Write(const void *buffer, INT32 numbytes)=0;

      virtual INT64 v_Seek(
         INT64 offset, 
         GENERICRW::SEEKFROM from = GENERICRW::SEEKFROM_Beginning
         )=0;

      virtual INT64 v_Tell() const=0;

      virtual CAPABILITIES v_GetCapabilities()=0;
   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(GENERICRW_TEXT::CAPABILITIES)
#endif

#endif   // INC_MI32_GENERICRW_TEXT_H

---