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

Go to the documentation of this file.

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

   Short description
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: ven ago 18 2006

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

   See LICENSE file for licensing details.
*/

#ifndef flc_fstream_H
#define flc_fstream_H

#include <falcon/stream.h>

namespace Falcon {

class FALCON_DYN_CLASS FileSysData: public BaseAlloc
{
protected:
   FileSysData() {}
public:
   virtual ~FileSysData() {}
   virtual FileSysData *dup() = 0;
};

class FALCON_DYN_CLASS BaseFileStream: public Stream
{
public:
    typedef enum {
      e_omReadWrite,
      e_omReadOnly,
      e_omWriteOnly
   } t_openMode;

   typedef enum  {
      e_smExclusive,
      e_smShareRead,
      e_smShareFull
   } t_shareMode;

   typedef enum {
      e_aOtherRead = 04,
      e_aOtherWrite = 02,
      e_aOtherExecute = 01,
      e_aGroupRead = 040,
      e_aGroupWrite = 020,
      e_aGroupExecute = 010,
      e_aUserRead = 0400,
      e_aUserWrite = 0200,
      e_aUserExecute = 0100,

      e_aAll = 0777,
      e_aReadOnly = 0444,
      e_aHidden = 0600
   } t_attributes;

protected:

   FileSysData *m_fsData;

   virtual int64 seek( int64 pos, Stream::e_whence whence );

public:
   BaseFileStream( t_streamType streamType, FileSysData *fsdata ):
      Stream( streamType ),
      m_fsData( fsdata )
   {}

   BaseFileStream( const BaseFileStream &other );

   virtual ~BaseFileStream();

   virtual bool close();
   virtual int32 read( void *buffer, int32 size );
   virtual int32 write( const void *buffer, int32 size );
   virtual int64 tell();
   virtual bool truncate( int64 pos = - 1);
   virtual bool errorDescription( ::Falcon::String &description ) const;
   const FileSysData *getFileSysData() const { return m_fsData; }
   virtual int64 lastError() const;
   virtual bool put( uint32 chr );
   virtual bool get( uint32 &chr );
   virtual int32 readAvailable( int32 msecs_timeout, const Sys::SystemData *sysData = 0 );

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

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

   void setError( int64 errorCode );

   virtual FalconData *clone() const;
};

class FALCON_DYN_CLASS FileStream: public BaseFileStream
{
public:
   FileStream( FileSysData *fsdata ):
      BaseFileStream( t_file, fsdata )
   {
      status( t_open );
   }

   FileStream();

   virtual void setSystemData( const FileSysData &data );

   virtual bool open( const String &filename, t_openMode mode=e_omReadOnly, t_shareMode share=e_smExclusive );

   virtual bool create( const String &filename, t_attributes mode,  t_shareMode share=e_smExclusive);

};

class FALCON_DYN_CLASS StdStream: public BaseFileStream
{
   virtual int64 seek( int64 pos, Stream::e_whence whence ) {
      m_status = t_unsupported;
      return -1;
   }

public:
   StdStream( FileSysData *fsdata ):
      BaseFileStream( t_stream, fsdata )
   {
      status( t_open );
   }

   virtual ~StdStream()
   {}

/*   virtual int64 tell() {
      m_status = t_unsupported;
      return -1;
   }
*/
   virtual bool truncate( int64 pos=-1 ) {
      m_status = t_unsupported;
      return false;
   }
};

class FALCON_DYN_CLASS InputStream: public StdStream
{
public:

   InputStream( FileSysData *fsdata ):
      StdStream( fsdata )
   {}

   virtual int32 write( const void *buffer, int32 size ) {
      m_status = t_unsupported;
      return -1;
   }

};

class FALCON_DYN_CLASS OutputStream: public StdStream
{
public:

   OutputStream( FileSysData *fsdata ):
      StdStream( fsdata )
   {}

   virtual int32 read( void *buffer, int32 size ) {
      m_status = t_unsupported;
      return -1;
   }
};

class FALCON_DYN_CLASS StdInStream: public InputStream
{
public:
   StdInStream();
};

class FALCON_DYN_CLASS StdOutStream: public OutputStream
{
public:
   StdOutStream();
};

class FALCON_DYN_CLASS StdErrStream: public OutputStream
{
public:
   StdErrStream();
};

class FALCON_DYN_CLASS RawStdInStream: public InputStream
{
public:
   RawStdInStream();
};

class FALCON_DYN_CLASS RawStdOutStream: public OutputStream
{
public:
   RawStdOutStream();
};

class FALCON_DYN_CLASS RawStdErrStream: public OutputStream
{
public:
   RawStdErrStream();
};

inline BaseFileStream::t_attributes operator|(  BaseFileStream::t_attributes one, BaseFileStream::t_attributes two)
{
   return (BaseFileStream::t_attributes) ( ((uint32)one) | ((uint32)two) );
}

inline BaseFileStream::t_attributes operator&(  BaseFileStream::t_attributes one, BaseFileStream::t_attributes two)
{
   return (BaseFileStream::t_attributes) ( ((uint32)one) & ((uint32)two) );
}

inline BaseFileStream::t_attributes operator^(  BaseFileStream::t_attributes one, BaseFileStream::t_attributes two)
{
   return (BaseFileStream::t_attributes) ( ((uint32)one) & ((uint32)two) );
}

}

#endif

/* end of fstream.h */

---