/home/gian/Progetti/falcon/core/include/falcon/stream.h

Go to the documentation of this file.

/*
   FALCON - The Falcon Programming Language.
   FILE: file_base.h

   Short description
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: mar nov 2 2004

   -------------------------------------------------------------------
   (C) Copyright 2004: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

#ifndef flc_stream_H
#define flc_stream_H

#include <falcon/setup.h>
#include <falcon/types.h>
#include <falcon/falcondata.h>
#include <falcon/string.h>
#include <falcon/vm_sys.h>

#define FALCON_READAHEAD_BUFFER_BLOCK  32

namespace Falcon {


class FALCON_DYN_CLASS Stream: public FalconData
{
protected:
   uint32 *m_rhBuffer;
   uint32 m_rhBufferSize;
   uint32 m_rhBufferPos;

   void pushBuffer( uint32 chr );

   bool popBuffer( uint32 &chr );

   bool bufferEmpty() const { return m_rhBufferPos == 0; }

public:
   typedef enum {
      t_undefined = 0,
      t_file = 1,
      t_stream = 2,
      t_membuf = 3,
      t_network = 4,
      t_proxy = 5
   } t_streamType;

   typedef enum {
      t_none = 0,
      t_open = 0x1,
      t_eof = 0x2,
      t_error = 0x4,
      t_unsupported = 0x8,
      t_invalid = 0x10,
      t_interrupted = 0x20

   } t_status ;


protected:
   t_streamType m_streamType;
   t_status m_status;
   int32 m_lastMoved;

   Stream( t_streamType streamType ):
      m_rhBuffer( 0 ),
      m_rhBufferSize( 0 ),
      m_rhBufferPos( 0 ),
      m_streamType( streamType ),
      m_status( t_none ),
      m_lastMoved( 0 )
   {}

   typedef enum {
      ew_begin,
      ew_cur,
      ew_end
   } e_whence;

   friend class Transcoder;

public:

   Stream( const Stream &other );

   t_streamType type() const { return m_streamType; }
   virtual t_status status() const { return m_status; }
   void status( t_status s ) { m_status = s; }

   uint32 lastMoved() const { return m_lastMoved; }

   void reset();
   bool good() const;
   bool bad() const;
   bool open() const;
   bool eof() const;
   bool unsupported() const;
   bool invalid() const;
   bool error() const;
   bool interrupted() const;

   virtual ~Stream();

   virtual void gcMark( uint32 mark ) {}
   virtual bool isStreamBuffer() const { return false; }
   virtual bool isTranscoder() const { return false; }

   virtual int32 read( void *buffer, int32 size );

   virtual int32 write( const void *buffer, int32 size );

   virtual bool close();
   virtual int64 tell();
   virtual bool truncate( int64 pos=-1 );
   virtual bool errorDescription( ::Falcon::String &description ) const;

   virtual int32 readAvailable( int32 msecs_timeout, const Sys::SystemData *sysData = 0 );

   virtual int32 writeAvailable( int32 msecs_timeout, const Sys::SystemData *sysData = 0 );

   int64 seekBegin( int64 pos ) {
      return seek( pos, ew_begin );
   }

   int64 seekCurrent( int64 pos ) {
      return seek( pos, ew_cur );
   }

   int64 seekEnd( int64 pos ) {
      return seek( pos, ew_end );
   }
   
   virtual int64 seek( int64 pos, e_whence w );

   virtual int64 lastError() const;

   virtual bool get( uint32 &chr ) = 0;

   virtual bool readString( String &target, uint32 size );

   virtual bool put( uint32 chr );

   virtual bool writeString( const String &source, uint32 begin=0, uint32 end = csh::npos );

   void unget( uint32 chr ) { pushBuffer( chr ); }

   void unget( const String &target );

   bool readAhead( uint32 &chr );

   bool readAhead( String &target, uint32 size );

   void discardReadAhead( uint32 count = 0 );

   virtual bool flush();

   virtual FalconData *clone() const;
};


inline Stream::t_status operator|( const Stream::t_status &elem1, const Stream::t_status &elem2)
{
   return static_cast<Stream::t_status>(
      static_cast<unsigned int>(elem1) | static_cast<unsigned int>(elem2) );
}

inline Stream::t_status operator&( const Stream::t_status &elem1, const Stream::t_status &elem2)
{
   return static_cast<Stream::t_status>(
      static_cast<unsigned int>(elem1) & static_cast<unsigned int>(elem2) );
}

inline Stream::t_status operator^( const Stream::t_status &elem1, const Stream::t_status &elem2)
{
   return static_cast<Stream::t_status>(
      static_cast<unsigned int>(elem1) ^ static_cast<unsigned int>(elem2) );
}

inline Stream::t_status operator~( const Stream::t_status &elem1 )
{
   return static_cast<Stream::t_status>( ~ static_cast<unsigned int>(elem1) );
}

inline void Stream::reset()
{
   status( status() &
         static_cast<t_status>(~static_cast<unsigned int>(t_error|t_unsupported|t_invalid)) );
   m_lastMoved = 0;
}

inline bool Stream::good() const
      { return (status() &( t_error | t_unsupported | t_invalid )) == 0; }
inline bool Stream::bad() const
      { return (status() &( t_error | t_unsupported | t_invalid )) != 0; }

inline bool Stream::open() const
   { return (status() & t_open ) != 0; }
inline bool Stream::eof() const
   { return (status() & t_eof ) != 0; }
inline bool Stream::unsupported() const
   { return (status() & t_unsupported ) != 0; }
inline bool Stream::invalid() const
   { return (status() & t_invalid ) != 0; }
inline bool Stream::error() const
   { return ( status() & t_error ) != 0; }
inline bool Stream::interrupted() const
   { return ( status() & t_interrupted ) != 0; }

} //end of Falcon namespace

#endif

/* end of file_base.h */

---