---

miodevice.cc

Go to the documentation of this file.

#include <sys/types.h>  // For stat()
#include <sys/stat.h>   // For stat()
#include <unistd.h>     // For stat()
#include <fcntl.h>      // For open()
#include <errno.h>

#include "magic/miodevice.h"

BEGIN_NAMESPACE (MagiC);

//                                                                           //
//                 ---  ___  ___               o                             //
//                  |  |   | |  \   ___           ___   ___                  //
//                  |  |   | |   | /   ) |   | | |   \ /   )                 //
//                  |  |   | |   | |---   \ /  | |     |---                  //
//                 _|_ `___´ |__/   \__    V   |  \__/  \__                  //
//                                                                           //

/*****************************************************************************/
IODevice::IODevice ()
{
    mType = 0;
    mMode = 0;
    mState = 0;
    mStatus = 0;
}

IODevice::~IODevice ()
{
}

bool IODevice::isDirectAccess () const
{
    return false;
}

bool IODevice::isSequentialAccess () const
{
    return false;
}

bool IODevice::isSynchronous () const
{
    return mMode & IO_Raw;
}

bool IODevice::isAsynchronous () const
{
    return !(mMode & IO_Raw);
}

bool IODevice::open (int mode   )
{
    MUST_OVERLOAD;
    return false;
}

void IODevice::close ()
{
    MUST_OVERLOAD;
}

void IODevice::flush ()
{
    MUST_OVERLOAD;
}

uint IODevice::size () const
{
    MUST_OVERLOAD;
    return 0;
}

int IODevice::at () const
{
    MUST_OVERLOAD;
    return 0;
}

bool IODevice::atEnd () const
{
    MUST_OVERLOAD;
    return true;
}

bool IODevice::seek (int position   )
{
    return false;
}

bool IODevice::reset ()
{
    return true;
}

int IODevice::readBlock (char* data,        
                         uint maxlen         )
    throw (device_not_open)
{
    MUST_OVERLOAD;
    return 0;
}

int IODevice::writeBlock (
    const char* data,   
    uint len)           
    throw (device_not_open)
{
    MUST_OVERLOAD;
    return 0;
}

int IODevice::readLine (
    char* data,         
    uint maxlen)        
    throw (device_not_open)
{
    int pos = 0; // Current position in the data buffer.

    // Read until the maximum length (minus 1 for the terminating zero) is
    // reached, or the end of file is reached.
    for (pos=0; !atEnd() && pos< int(maxlen)-1; pos++) {
        char ch = getch();
        data[pos] = ch;
        if (ch == '\n')
            break;
    }
    data[pos+1] = '\0'; // Terminate the string properly.

    return 0;
}

int IODevice::writeBlock (const String& str  )
    throw (device_not_open)
{
    return writeBlock ((const char*) str, str.length());
}

Ref<String> IODevice::readAll ()
    throw (device_not_open)
{
    Ref<String> result = new String ();
    char buffer[1024];

    while (!atEnd()) {
        int bytesread = readBlock (buffer, 1024);
        if (bytesread == 0)
            break;
        result->append (buffer, bytesread);
    }
    
    return result;
}

List<String>* IODevice::readLines ()
    throw (device_not_open)
{
    List<String>* result = new List<String> ();
    
    return result;
}

int IODevice::getch ()
    throw (device_not_open)
{
    MUST_OVERLOAD;
    return 0;
}

void IODevice::putch (char)
    throw (device_not_open)
{
    MUST_OVERLOAD;
}

/*****************************************************************************/
void IODevice::ungetch (char)
    throw (device_not_open)
{
    MUST_OVERLOAD;
}



//                                                                           //
//                              ----- o |                                    //
//                              |       |  ___                               //
//                              |---  | | /   )                              //
//                              |     | | |---                               //
//                              |     | |  \__                               //
//                                                                           //

File::File (FILE* file )
        : IODevice ()
{
    mName       = "";
    mpFile      = file;
    mFd         = fileno (mpFile);

    // We assume that the FILE is already opened.
    setOpen ();
}

File::File (const String& name  ,
            int mode            )
    throw (open_failure)
        : IODevice ()
{
    mName   = name;
    mpFile  = NULL;
    mFd     = 0;

    if (mode) {
        // The device must be opened either readable or writable or both
        if (! ((mode & IO_Readable) || (mode & IO_Writable)))
            throw open_failure (i18n("File '%1' must be opened either readable or writable or both; mode was %2.")
                                .arg(mName).arg(mode));
        
        // Open the file
        if (! open (mode))
            throw open_failure (i18n("Opening file '%1' with flags %2 failed for some reason.")
                                .arg(mName).arg(mode));
        setOpen ();
    }
}

bool File::exists () const throw (system_failure)
{
    struct stat statbuf; // For storing the status information about the file.

    // Get the file status
    int result = stat ((CONSTR) mName, &statbuf);

    if (result != 0) {
        // File does not exist
        if (errno == ENOENT)
            return false;

        // Some other error. Can't handle it cleanly.
        throw system_failure (i18n("System error '%1' while checking the existence of file '%2'.")
                              .arg(strerror(errno)).arg(mName));
    }
    
    return true; // File exists.
}

bool File::remove ()
{
    int result = ::remove ((CONSTR) mName);
    if (result != 0)
        return true;
    else
        return false;
}

/*******************************************************************************
 *
**/
bool File::open (int mode)
{
    if (isOpen())
        close ();

    // Translate mode to flags for the system open function.
    String fopenMode = translateToFOpenMode (mode);
    if (fopenMode.isEmpty())
        return false; // Failed
    
    // Try to open using the standard C open
    FILE* file = fopen ((CONSTR) mName, (CONSTR) fopenMode);

#ifdef IODEV_USE_EXCEPTIONS
    if (!file) {
        // Error state, errno has been set
        
        if (errno == EINVAL)
            throw invalid_flags (i18n("Invalid mode flags '%1' for opening file '%2'.")
                                 .arg(fopenMode).arg(mName));
        if (errno == ENOENT)
            throw file_not_found (i18n("File '%2' not found.")
                                  .arg(mName));
            
        throw open_failure (i18n("Error '%1' while trying to open file '%2'.")
                            .arg(strerror(errno)).arg(mName));
    }
#else
    if (!file)
        return false; // Failed
#endif

    // Set object state to open
    mpFile  = file;
    mFd     = fileno (mpFile);
    setMode (mode);
    setOpen ();

    return true; // Succeeded
}

/*******************************************************************************
 *
**/
void File::close ()
{
#ifdef IODEV_USE_EXCEPTIONS
    if (! mpFile)
        throw device_not_open (i18n ("File not open when closing file '%1'.").arg(mName));
#else
    if (! mpFile)
        return;
#endif

    // Close with the system call
    fclose (mpFile);

    // Set object state to closed.
    mpFile = NULL;
    mFd    = 0;
    setState (IO_Open, false);
}

/*******************************************************************************
 *
**/
void File::flush ()
{
    if (! mpFile)
        throw device_not_open (i18n ("File not open when flushing file '%1'.").arg(mName));

    fflush (mpFile);
}

uint File::size () const
{
    struct stat statbuf; // For storing the status information about the file.

    // Get the file status
    int callResult = stat ((CONSTR) mName, &statbuf);

    if (!callResult)
        throw system_failure (i18n("System error '%1' while checking the size of file '%1'.")
                              .arg(strerror(errno)).arg(mName));

    return statbuf.st_size;
}

/*******************************************************************************
 *
**/
int File::at () const
{
    if (!isOpen())
        throw device_not_open (i18n ("File not open when inquiring the current position in file '%1'.").arg(mName));

    int position = ftell (mpFile);
    if (position < 0)
        throw system_failure (i18n("System error '%1' while inquiring the current position in file '%1'.")
                              .arg(strerror(errno)).arg(mName));

    return position;
}

/*******************************************************************************
 *
**/
bool File::seek (int position)
{
    if (!isOpen ())
        throw device_not_open (i18n ("File not open when inquiring the current position in file '%1'.").arg(mName));

    int callResult = fseek (mpFile, (long) position, SEEK_SET);

    if (!callResult)
        return false;

    return true;
}

bool File::atEnd () const
{
    if (mpFile)
        return feof (mpFile);
    else
        return true;
}

int File::readBlock (char* data,    
                     uint maxlen    )
    throw (device_not_open)
{
    ASSERT (data && maxlen>0);
    if (atEnd())
        return 0;

    // TODO: Error handling
    int bytesread = fread (data, 1, maxlen, mpFile);

    if (feof(mpFile))
        setState (IO_EOS);

    return bytesread;
}

/*******************************************************************************
 *
**/
int File::readLine (char* data,     
                    uint maxlen     )
    throw (device_not_open)
{
    ASSERT (data && maxlen>0);
    if (atEnd())
        return 0;

    // TODO: Error handling
    fgets (data, maxlen, mpFile);

    if (feof(mpFile))
        setState (IO_EOS);

    return strlen (data); // Calculate bytes read
}

int File::readLine (String& buffer, 
                    int maxlen      )
    throw (device_not_open)
{
    if (atEnd())
        return 0;

    if (!isOpen())
        throw device_not_open (i18n ("File not open when reading a line from file '%1'.").arg(mName));

    // TODO: Error handling
    int bytesread = fgetS (mpFile, buffer);

    if (feof(mpFile))
        setState (IO_EOS);

    return bytesread;
}

int File::writeBlock (const char* data, 
                      uint len          )
    throw (device_not_open)
{
    if (!isOpen())
        throw device_not_open (i18n ("File not open when writing to file '%1'.").arg(mName));

    // TODO: Error handling
    int result = fwrite (data, 1, len, mpFile);

    return result;
}

/*******************************************************************************
 *
**/
int File::getch ()
    throw (device_not_open)
{
    if (!isOpen())
        throw device_not_open (i18n ("File not open when reading a from file '%1'.").arg(mName));

    // TODO: Error handling
    int result = ::fgetc(mpFile);
    
    if (result == EOF) {
        setState (IO_EOS);
        result = 0;
        return (-1);
    }
    
    return result;
}

/*******************************************************************************
 *
**/
void File::putch (char ch)
    throw (device_not_open)
{
    if (!isOpen())
        throw device_not_open (i18n ("File not open when writing to file '%1'.").arg(mName));

    // int status = 
    fputc (ch, mpFile);
    // TODO: Error handling
}

void File::ungetch (char ch)
    throw (device_not_open)
{
    if (!isOpen())
        throw device_not_open (i18n ("File not open when ungetting from file '%1'.").arg(mName));
    
    // If at EOS, return to open state.
    if (state() & IO_EOS)
        setState (IO_EOS, false);

    // int status = 
    ungetc (ch, mpFile);
    // TODO: Error handling
}

/*******************************************************************************
 *
**/
int File::handle ()
{
    return mFd;
}

String File::translateToFOpenMode (int mode ) throw (invalid_flags)
{
    if (mode & IO_Readable)
        if (mode & IO_Writable)
            if (mode & IO_Append)
                return "a+";            // Open for RW, do not truncate, position at EOF
            else
                if (mode & IO_Truncate)
                    return "w+";        // Open for RW, truncate, position at BOF
                else
                    return "r+";        // Open for RW, do not truncate, position at BOF
        else
            return "r";                 // Open for R, position at BOF
    else
        if (mode & IO_Writable)
            if (mode & IO_Append)
                return "a";             // Open for W, do not truncate, position at EOF
            else
                return "w";             // Open for W, truncate, position at BOF

    return ""; // This would actually be an error state.
}

int File::translateToOpenMode (int mode ) throw (invalid_flags)
{
    int sysmode = 0;
    if (mode & IO_Readable)
        if (mode & IO_Writable)
            sysmode |= O_RDWR;
        else
            sysmode |= O_RDONLY;
    else
        if (mode & IO_Writable)
            sysmode |= O_WRONLY;
        else
            return false; // Failed

    if (mode & IO_Append)
        sysmode |= O_APPEND;

    if (mode & IO_Truncate)
        sysmode |= O_TRUNC;

    return sysmode;
}



//                                                                           //
//                       ----                                                //
//                       |   )        __  __  ___                            //
//                       |---  |   | /   /   /   ) |/\                       //
//                       |   ) |   | +-- +-- |---  |                         //
//                       |___   \__! |   |    \__  |                         //
//                                   |   |                                   //

Buffer::Buffer (int mode)
{
    mpBuffer    = new String();
    mPosition   = 0;
    mOwnBuffer  = true;

    // Try to open, if mode was given
    if (mode)
        if (! open (mode))
            throw open_failure (i18n("Opening Buffer device with flags %1 failed for some reason.")
                                .arg(mode));
}

Buffer::Buffer (String& buffer, int mode)
{
    mpBuffer    = &buffer;
    mPosition   = 0;
    mOwnBuffer  = false;

    // Try to open, if mode was given
    if (mode)
        if (! open (mode))
            throw open_failure (i18n("Opening Buffer device with flags %1 failed for some reason.")
                                .arg(mode));
}

Buffer::~Buffer ()
{
    if (mOwnBuffer)
        delete mpBuffer;
}

bool Buffer::open (int mode)
{
    setMode (mode);
    setOpen ();

    // This basicly resets position, etc.
    reset ();

    if (mode & IO_Truncate)
        mpBuffer->empty ();

    if (mode & IO_Append)
        mPosition = mpBuffer->length ();

    return true;
}

bool Buffer::reset ()
{
    if (!IODevice::reset ())
        return false;

    mPosition = 0;
    return true;
}

bool Buffer::atEnd () const
{
    if ((uint) mPosition >= size())
        return true;
    else
        return false;
}

int Buffer::readBlock (char* data, uint maxlen)
    throw (device_not_open)
{
    if ((uint) mPosition >= size())
        return 0;

    int remains = mpBuffer->length() - mPosition;           // How far is the end of buffer
    int readcount = ((uint) remains > maxlen)? maxlen : remains;    // How many bytes will actually be read

    memcpy (data, ((const char*) *mpBuffer) + mPosition, readcount);

    mPosition += readcount;
    return readcount;
}

int Buffer::writeBlock (const char* data, uint len)
    throw (device_not_open)
{
    mpBuffer->replace (mPosition, data, len); 
    mPosition += len;
    return len;
}

int Buffer::readLine (char* data, uint maxlen)
    throw (device_not_open)
{
    if ((uint) mPosition >= size())
        return 0;

    int  remains    = mpBuffer->length() - mPosition;               // How far is the end of buffer
    int  maxread    = ((uint) remains > maxlen)? maxlen : remains;  // How many bytes can actually be read
    uint newlinePos = mPosition;

    // Find the next newline
    for (uint i=0; i < (uint) maxread; i++)
        if ((*mpBuffer)[newlinePos++] == '\n')
            break;

    // How much was actually read
    int readcount = newlinePos - mPosition;

    // Copy everything up to the newline to the result buffer.
    memcpy (data, ((const char*) *mpBuffer) + mPosition, newlinePos-mPosition);
    data[readcount] = '\x00';

    // Move position pointer to new position
    mPosition = newlinePos;

    return readcount;
}

int Buffer::writeBlock (const String& str)
    throw (device_not_open)
{
    mpBuffer->append (str);
    return str.length();
}

int Buffer::getch ()
    throw (device_not_open)
{
    if ((uint) mPosition >= size())
        return -1; // EOS

    // TODO: Should we increment?
    return (*mpBuffer)[uint(mPosition)];
}

void Buffer::putch (char c)
    throw (device_not_open)
{
    // Use reserved buffer if possible, otherwise append (grow the
    // buffer).
    if ((uint) mPosition >= size()) {
        // No room in buffer, append.
        mpBuffer->append (c);
        mPosition++;
    } else
        (*mpBuffer)[uint(mPosition++)] = c;
}

void Buffer::ungetch (char c)
    throw (device_not_open)
{
    if (mPosition==0)
        return;

    // Go back one character, and put the character there.
    (mpBuffer)[--mPosition] = c;
}

END_NAMESPACE;

---