FXIO.h

/********************************************************************************
*                                                                               *
*                       A b s t r a c t   I / O   C l a s s                     *
*                                                                               *
*********************************************************************************
* Copyright (C) 2005,2024 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 {
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    
    };

  enum {
    Error  = -1,                
    Again  = -2,                
    Broken = -3                 
    };

protected:
  FXIO();
private:
  FXIO(const FXIO&);
  FXIO &operator=(const FXIO&);
public:

  virtual FXbool isOpen() const;

  virtual FXbool isSerial() const;

  virtual FXuint mode() const;

  virtual FXbool mode(FXuint m);

  virtual FXuint perms() const;

  virtual FXbool perms(FXuint p);

  virtual FXlong position() const;

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

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

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

  FXbool readChar(FXchar& ch);

  FXbool writeChar(FXchar ch);

  virtual FXlong truncate(FXlong sz);

  virtual FXbool flush();

  virtual FXint eof();

  virtual FXlong size();

  virtual FXbool close();

  virtual ~FXIO();
  };

}

#endif