QIODevice.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                                Base i/o device                                *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003 by Niall Douglas.   All Rights Reserved.            *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code 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.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef QIODEVICE_H
#define QIODEVICE_H

#include "fxdefs.h"

namespace FX {

class FXACL;

enum QIODeviceFlags
{
    IO_ReadOnly=    0x0001,     
    IO_WriteOnly=   0x0002,     
    IO_ReadWrite=   0x0003,     
    IO_Append=      0x0004,     
    IO_Truncate=    0x0008,     

    IO_Translate=   0x0010,
    IO_ShredTruncate=0x080,
    IO_ModeMask=    0x00ff,     

    IO_Raw=         0x0100,     
    IO_QuietSocket= 0x0200,     
    IO_DontUnlink=  0x0400,     
    IO_NoAutoUTF=   0x0800,     
    IO_Open=        0x1000,     
    IO_StateMask=   0xf000      
};

class FXAPI QIODevice
{
public:
    typedef FXfval Offset;
    enum CRLFType
    {
        Default=0,          
        Unix=1,             
        MacOS=2,            
        MSDOS=3             
    };
    enum UnicodeType
    {
        NoTranslation=0,    
        UTF8=1,             
        UTF16=2,            
        UTF16LE=3,          
        UTF32=4,            
        UTF32LE=5           
    };
private:
    FXuint mymode;
    CRLFType myCRLFType;
    UnicodeType myUnicodeType;
protected:
    QIODevice(const QIODevice &o) : mymode(o.mymode), myCRLFType(Default), myUnicodeType(NoTranslation), ioIndex(o.ioIndex) { }
    QIODevice &operator=(const QIODevice &o) { mymode=o.mymode; myCRLFType=o.myCRLFType; myUnicodeType=o.myUnicodeType; ioIndex=o.ioIndex; return *this; }
    FXfval ioIndex;
public:
    QIODevice() : mymode(0), myCRLFType(Default), myUnicodeType(NoTranslation), ioIndex(0) { }
    virtual ~QIODevice() { }

    FXuint flags() const { return mymode; }
    FXuint mode() const { return mymode & IO_ModeMask; }
    FXuint state() const { return mymode & IO_StateMask; }
    CRLFType crlfFormat() const { return myCRLFType; }
    void setCRLFFormat(CRLFType type) { myCRLFType=type; }
    UnicodeType unicodeTranslation() const { return myUnicodeType; }
    void setUnicodeTranslation(UnicodeType type) { myUnicodeType=type; }
    bool isBuffered() const { return IO_Raw!=(mymode & IO_Raw); }
    bool isRaw() const { return IO_Raw==(mymode & IO_Raw); }
    bool isTranslated() const { return IO_Translate==(mymode & IO_Translate); }
    bool isUTF16Translated() const { return isTranslated() && UTF16==(myUnicodeType & UTF16); }
    bool isUTF32Translated() const { return isTranslated() && UTF32==(myUnicodeType & UTF32); }
    bool isReadable() const { return IO_ReadOnly==(mymode & IO_ReadOnly); }
    bool isWriteable() const { return IO_WriteOnly==(mymode & IO_WriteOnly); }
    bool isWritable() const { return isWriteable(); }
    bool isReadWrite() const { return IO_ReadWrite==(mymode & IO_ReadWrite); }
    bool isClosed() const { return IO_Open!=(mymode & IO_Open); }
    bool isInactive() const { return isClosed(); }
    bool isOpen() const { return IO_Open==(mymode & IO_Open); }
    virtual bool isSynchronous() const { return false; }

    virtual bool open(FXuint mode)=0;
    virtual void close()=0;
    virtual void flush()=0;
    virtual FXfval size() const=0;
    virtual void truncate(FXfval size)=0;
    virtual FXfval at() const;
    virtual bool at(FXfval newpos);
    virtual bool atEnd() const;
    virtual const FXACL &permissions() const;
    virtual void setPermissions(const FXACL &);

    virtual FXuval readBlock(char *data, FXuval maxlen)=0;
    FXuval readBlock(FXuchar *data, FXuval maxlen) { return readBlock((char *) data, maxlen); }
    virtual FXuval writeBlock(const char *data, FXuval maxlen)=0;
    FXuval writeBlock(const FXuchar *data, FXuval maxlen) { return writeBlock((char *) data, maxlen); }
    virtual FXuval readLine(char *data, FXuval maxlen);
    virtual FXuval readBlockFrom(char *data, FXuval maxlen, FXfval pos)=0;
    FXuval readBlockFrom(FXuchar *data, FXuval maxlen, FXfval pos) { return readBlockFrom((char *) data, maxlen, pos); }
    virtual FXuval writeBlockTo(FXfval pos, const char *data, FXuval maxlen)=0;
    FXuval writeBlockTo(FXfval pos, const FXuchar *data, FXuval maxlen) { return writeBlockTo(pos, (char *) data, maxlen); }

    virtual int getch();
    virtual int putch(int c);
    virtual int ungetch(int c)=0;
public:
    static UnicodeType determineUnicodeType(FXuchar *data, FXuval len) throw();
    static FXuval applyCRLF(FXuchar *FXRESTRICT output, const FXuchar *FXRESTRICT input, FXuval outputlen, FXuval &inputlen, CRLFType crlftype=Default, UnicodeType utftype=NoTranslation);
    static FXuval removeCRLF(FXuchar *FXRESTRICT output, const FXuchar *FXRESTRICT input, FXuval outputlen, FXuval &inputlen, UnicodeType utftype=NoTranslation);
    FXfval shredData(FXfval offset, FXfval len=(FXfval)-1);
protected:
    void setFlags(int f) { mymode=f; }
    void setMode(int m) { mymode=(mymode & ~IO_ModeMask)|m; }
    void setState(int s) { mymode=(mymode & ~IO_StateMask)|s; }
    friend FXAPI FXStream &operator<<(FXStream &s, QIODevice &i);
    friend FXAPI FXStream &operator>>(FXStream &s, QIODevice &i);
};

FXAPI FXStream &operator<<(FXStream &s, QIODevice &i);
FXAPI FXStream &operator>>(FXStream &s, QIODevice &i);


} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.