/home/jeroen/FOX/fox/fox-1.7.33/include/FXIO.h

/********************************************************************************
*                                                                               *
*                       A b s t r a c t   I / O   C l a s s                     *
*                                                                               *
*********************************************************************************
* Copyright (C) 2005,2012 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or modify          *
* it under the terms of the GNU Lesser General Public License as published by   *
* the Free Software Foundation; either version 3 of the License, or             *
* (at your option) any later version.                                           *
*                                                                               *
* This library is distributed in the hope that it will be useful,               *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 *
* GNU Lesser General Public License for more details.                           *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public License      *
* along with this program.  If not, see <http://www.gnu.org/licenses/>          *
********************************************************************************/
#ifndef FXIO_H
#define FXIO_H



namespace FX {


class FXAPI FXIO {
protected:
  FXuint access;
private:
  FXIO(const FXIO&);
  FXIO &operator=(const FXIO&);
protected:
  FXIO();
  FXIO(FXuint m);
public:

  enum {

    NoAccess     = 0,                    
    ReadOnly     = 1,                    
    WriteOnly    = 2,                    
    ReadWrite    = ReadOnly|WriteOnly,   
    Append       = 4,                    
    Truncate     = 8,                    
    Create       = 16,                   
    Exclusive    = 32,                   
    NonBlocking  = 64,                   
    Executable   = 128,                  
    OwnHandle    = 256,                  
    NoAccessTime = 512,                  
    Inheritable  = 1024,                 

    Reading      = ReadOnly,                    
    Writing      = ReadWrite|Create|Truncate    
    };

  enum {
    Begin   = 0,                
    Current = 1,                
    End     = 2                 
    };

  enum {

    OtherExec      = 0x00001,                   
    OtherWrite     = 0x00002,                   
    OtherRead      = 0x00004,                   
    OtherReadWrite = OtherRead|OtherWrite,      
    OtherFull      = OtherReadWrite|OtherExec,  

    GroupExec      = 0x00008,                   
    GroupWrite     = 0x00010,                   
    GroupRead      = 0x00020,                   
    GroupReadWrite = GroupRead|GroupWrite,      
    GroupFull      = GroupReadWrite|GroupExec,  

    OwnerExec      = 0x00040,                   
    OwnerWrite     = 0x00080,                   
    OwnerRead      = 0x00100,                   
    OwnerReadWrite = OwnerRead|OwnerWrite,      
    OwnerFull      = OwnerReadWrite|OwnerExec,  

    AllRead        = OtherRead|GroupRead|OwnerRead,     
    AllWrite       = OtherWrite|GroupWrite|OwnerWrite,  
    AllExec        = OtherExec|GroupExec|OwnerExec,     
    AllReadWrite   = AllRead|AllWrite,                  
    AllFull        = AllReadWrite|AllExec,              

    Hidden         = 0x00200,   
    Directory      = 0x00400,   
    File           = 0x00800,   
    SymLink        = 0x01000,   

    SetUser        = 0x02000,   
    SetGroup       = 0x04000,   
    Sticky         = 0x08000,   

    Character      = 0x10000,   
    Block          = 0x20000,   
    Socket         = 0x40000,   
    Fifo           = 0x80000    
    };

public:

  FXbool isReadable() const;

  FXbool isWritable() const;

  FXuint mode() const { return access; }

  virtual FXbool isOpen() const;

  virtual FXbool isSerial() const;

  virtual FXlong position() const;

  virtual FXlong position(FXlong offset,FXuint from=FXIO::Begin);

  virtual FXival readBlock(void* data,FXival count);

  virtual FXival writeBlock(const void* data,FXival count);

  virtual FXlong truncate(FXlong size);

  virtual FXbool flush();

  virtual FXbool eof();

  virtual FXlong size();

  virtual FXbool close();

  virtual ~FXIO();
  };

}

#endif