---

FileDescriptor

/*
 * NOTE: "zlib/libpng" style License
 *
 *                 ----=== s t d n e t ===----
 *
 * Copyright (c) 2002 Warwick Molloy   w-molloy@users.sf.net
 *
 * Copyright (c) 2002 Stdnet Community
 * HTTP://Sourceforge.net/projects/stdnet
 *
 * All references to "software" refer to the stdnet.
 *
 * This software is provided 'as-is', without any express or
 * implied warranty. In no event will the authors be held liable
 * for any damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it
 * and redistribute it freely, subject to the following
 * restrictions:
 *
 * 1.  The origin of this software must not be misrepresented;
 *     you must not claim that you wrote the original software.
 *     If you use this software in a product, an acknowledgment
 *     in the product documentation would be appreciated but
 *     is not required.
 *
 * 2.  Altered source versions must be plainly marked as such,
 *     and must not be misrepresented as being the original
 *     software.
 *
 * 3.  This notice may not be removed or altered from any source
 *     distribution.
 */

#ifndef __system_platform_FileDescriptor__
#define __system_platform_FileDescriptor__

#include <stdio.h>

namespace stdbase {
    namespace system {
        namespace platform {

class FileDescriptor
{
public:
    enum Flags
    {
        CLOSED  =   0,

        READ    =   0x0001,
        WRITE   =   0x0002,
        RDWRMASK=   0x0003, // -- read/write mask
        
        BIN     =   0x0004,
        TEXT    =   0x0008,
        TYPEMASK=   0x000C, // -- content type mask
        
        CREATE  =   0x0010, //    create new file (write)
        APPEND  =   0x0020, //    append to existing (write)
        OPEN    =   0x0040, //    open at start of exist (read)
        OPNMASK =   0x0070, // -- open method mask

        // -- combinations --
        //
        CREATE_WRITE_BIN    =   CREATE | WRITE | BIN,
        CREATE_WRITE_TEXT   =   CREATE | WRITE | TEXT,

        APPEND_WRITE_BIN    =   APPEND | WRITE | BIN,
        APPEND_WRITE_TEXT   =   APPEND | WRITE | TEXT,

        CREATE_RDWR_BIN     =   CREATE | READ | WRITE | BIN,
        CREATE_RDWR_TEXT    =   CREATE | READ | WRITE | TEXT,

        APPEND_RDWR_BIN     =   APPEND | WRITE | BIN,
        APPEND_RDWR_TEXT    =   APPEND | WRITE | TEXT,

        OPEN_READ_BIN       =   OPEN   | READ | BIN,
        OPEN_READ_TEXT      =   OPEN   | READ | TEXT
        
    };

    struct  StdOut  {};
    struct  StdErr  {};
    struct  StdIn   {};
    
public:
    FileDescriptor() : file(0), constraints(CLOSED) {};
    ~FileDescriptor() { close(); }

    inline bool    isOpen();
    
    inline bool    open( char * name, Flags f);

    inline bool    open( StdOut );
    
    inline bool    open( StdErr );

    inline bool    open( StdIn );

    inline bool    close();
    
    inline bool    write( char * buffer, int len);

    inline int     read( char * buffer, int max);

    inline bool    flush();

    inline bool     eof();

private:
    FILE *  file;
    Flags   constraints;

public:
    static FileDescriptor   stdinFileDescriptor;
    static FileDescriptor   stdoutFileDescriptor;
    static FileDescriptor   stderrFileDescriptor;

private:
    FileDescriptor( StdIn ) : file(0), constraints(CLOSED)
    { open( StdIn() ); }
    
    FileDescriptor( StdOut) : file(0), constraints(CLOSED)
    { open( StdOut() ); }

    FileDescriptor( StdErr ) : file(0), constraints(CLOSED)
    { open( StdErr() ); }
};

bool FileDescriptor::
    isOpen()
{
    return constraints != CLOSED;
}

bool FileDescriptor::
    open( char * name, Flags f)
{
    int     index = 0;
    char    extra[ 10];

    //  If the file is already open (file != 0) then set fail.
    bool    fail = (file != 0) ? true : false;
    
    if ( (f & RDWRMASK) == READ && ! fail)
    {
        extra[index++] = 'r';
    }
    else if ( (f & RDWRMASK) == WRITE)
    {
        extra[index++] = 'w';
    }
    else
    {
        fail = true;
    }

    if ( (f & TYPEMASK) == BIN && ! fail)
    {
        extra[index++] = 'b';
    }
    else if ( (f & TYPEMASK) == TEXT && ! fail)
    {
        extra[index++] = 't';
    }
    else
    {
        fail = true;
    }
    
    if ( (f & OPNMASK) == APPEND && ! fail)
    {
        extra[index++] = 'a';
    }
    else if ( (f & OPNMASK) == CREATE && ! fail)
    {
        //extra[index++] = '+';
    }
    else if ( (f & OPNMASK) == OPEN && ! fail )
    {
        //  nothing to do but not fail.
    }
    else
    {
        fail = true;
    }
    extra[index] = 0;
    
    if ( ! fail )
    {
        file = fopen( name, extra);
        if ( file != 0 )
        {
            constraints = f;
        }
    }
    return file != 0 && ! fail;
}

bool FileDescriptor::
    open( StdOut )
{
    file = stdout;
    constraints = WRITE;
    return true;
}

bool FileDescriptor::
    open( StdErr )
{
    file = stderr;
    constraints = WRITE;
    return true;
}

bool FileDescriptor::
    open( StdIn )
{
    file = stdin;
    constraints = READ;
    return true;
}

bool FileDescriptor::
    close()
{
    if ( file == 0 )
        return false;

    return fclose( file ) == 0;
}

bool FileDescriptor::
    write( char * buffer, int len)
{
    if ( file == 0 )
        return false;
    
    return fwrite( static_cast<void*>( buffer ), 1, len, file ) > 0;
}

int FileDescriptor::
    read( char * buffer, int max)
{
    if ( file == 0)
        return 0;
    return fread( static_cast<void*>(buffer), 1, max, file);
}

bool FileDescriptor::
    flush()
{
    if ( file == 0 )
        return false;
    fflush( file );
    return true;
}

bool FileDescriptor::
    eof()
{
    if ( file == 0 )
        return false;
    return feof( file ) > 0;
}

        } // -- end platform --
    } // ------ end system --
} // ---------- end stdbase --

#endif      //  __system_platform_FileDescriptor__

---