---

file.h

Go to the documentation of this file.

#ifndef file_h
#define file_h

#include <iostream>
#include <string>
#include <list>

// compatibility check
#if __GNUC__ == 2
#define ios_base ios
#endif


class File 
{
private:

  class stream 
  {
  public:
    enum Type 
      {
        FILE_STREAM,
        MEM_STREAM
      };

  protected:

    std::string name; 

    bool valid; 

    int line; 

    int count; 

    std::iostream *io;

    std::ios_base::openmode mode; 

    Type type;

  public:
    stream( std::string name, std::ios_base::openmode mode, Type type );
    virtual ~stream();

    bool is_valid() const { return valid; }
    bool operator!() const { return !valid; }

    void operator++(){ line++; }

    void operator--(){ line--; }

    std::iostream& get_io() { return *io; }

    template <class T> void operator<<( T t ) { *io << t; }
    template <class T> void operator>>( T& t ) { *io >> t; }

    int get_refs() const { return count; }
    int add_ref() { count++; return count; }
    int sub_ref() { count--; return count; }

    std::string get_name() const { return name; }

    std::ios_base::openmode get_mode() const { return mode; }

    void set_mode( std::ios_base::openmode m ) { mode = m; }

    virtual void trunc()=0;

    int get_line() const { return line; }
    void set_line( int l ) { line =  l; }

    // some io functions
    void seekg( long pos ) { io->seekg( pos ); line=0; }
    long tellg() { return io->tellg(); }
    void seekp( long pos ) { io->seekp( pos ); line=0; }
    long tellp() { return io->tellp(); }
    int eof() { return io->eof(); }

    std::ostream& flush() { return io->flush(); }
    std::ostream& put( char c ) { return io->put( c ); }
    std::ostream& write( std::string s ) { return io->write( s.c_str(), s.size() ); }
    std::ostream& write( std::string s, std::streamsize n ) { return io->write( s.c_str(), n ); }

    std::istream& get( char& c ) { return io->get( c ); }
    std::istream& read( char* ptr, std::streamsize n ) { return io->read( ptr, n ); }
    
    void clear() { io->clear(); }

    Type get_type() { return type; }
  };

  class file_stream : public stream 
  {
  public:
    file_stream( std::string name, std::ios_base::openmode mode );
    void trunc();
  };

  class mem_stream : public stream 
  {
  public:
    mem_stream( std::string name, std::ios_base::openmode mode );
    void trunc();
  };



  class file_handler 
  {
  private:
    typedef std::list<File> file_list;
    typedef file_list::iterator file_list_it;

    file_list files; 

  public:
    bool register_file( File& file );
    bool unregister_file( File& file );

    bool get_file( std::string name, File& file );

    bool has_file( std::string name ) {
      File f;
      return get_file( name, f );
    }
  };

  stream *s; 

  static bool use_mem;   
  static bool use_tmp;   

  mutable bool valid; 

  bool real; 

  static file_handler fh;  

  std::string init_name; 

  bool nocreate;

public:
  File(); 
  File( std::string name, 
        std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out,  
        bool nocreate = false, 
        bool real = true);

  File( const File& file ); 
  ~File();
  
  void open( std::string name, 
             std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out,
             bool nocreate = false, 
             bool real = true )
  { *this = File( name, mode, nocreate, real ); }
  
  static bool use_handler(); 
  static void use_handler( bool u );

  static bool use_tmp_files(); 
  static void use_tmp_files( bool u );
  
  bool is_valid() const 
  {
    if( s )
      valid = s->is_valid();
    else
      valid = false;

    return valid;
  }

  bool operator!() const { return !is_valid(); }

  std::string get_name() const { if( is_valid() ) return s->get_name(); else return init_name; }
  
  template <class T> File& operator<<( const T t ) { *s << t; return *this; }
  template <class T> File& operator>>( T& t ) { *s >> t; return *this; }

  void seekg( long pos ) { s->seekg( pos ); }
  long tellg() { return s->tellg(); }
  void seekp( long pos ) { s->seekp( pos ); }
  long tellp() { return s->tellp(); }
  int eof() { return s->eof(); }

  std::iostream& get_io() { return s->get_io(); }

  void operator=( const File& file );

  std::ios_base::openmode get_mode() const { return s->get_mode(); }

  int get_line() const { return s->get_line(); }
  void set_line( int line ) { s->set_line( line ); }

  void operator++(){ ++(*s); }

  void operator--(){ --(*s); }

  std::ostream& flush() { return s->flush(); }
  std::ostream& put( char c ) { return s->put( c ); }
  std::ostream& write( std::string str ) { return s->write( str.c_str(), str.size() ); }
  std::ostream& write( std::string str, std::streamsize n ) { return s->write( str.c_str(), n ); }
  
  std::istream& get( char& c ) { return s->get( c ); }
  std::istream& read( char* ptr, std::streamsize n ) { return s->read( ptr, n ); }

  void clear() { s->clear(); }

  void trunc();  


  bool append( File other );

  void stats( File other ) { stats( other.get_io() ); }
  void stats( std::ostream &out );

  void dump( File other ) { dump( other.get_io() ); }
  void dump( std::ostream &out );

  static  bool fh_has_file( std::string name );

private:
  void set_mode( std::ios_base::openmode mode );
};

namespace std {

  void getline( File& file, std::string& line );
}


bool operator == ( const File& f1, const File& f2 );

#endif

---