NET_IODevice.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_IODevice.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __NET_IODEVICE_H__
#define __NET_IODEVICE_H__

#include "NET_API.h"

#include <UT/UT_ErrorCode.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_EnumHelper.h>

template <typename T>
class UT_Array;

/// Bit flags for how the device should behave.
/// NotOpen: Device is not open
/// ReadOnly: Device is open for reading
/// WriteOnly: Device is open for writing
/// ReadWrite: Device is open for reading and writing
/// Append: Device is in append mode so all data is written to EOF
/// Truncate: All earlier contents of the device are lost.
/// Unbuffered: Any buffer in the device is bypassed.
/// NewOnly: Fail if the the file already exists.
/// ExistingOnly: Fail if the file opened does not already exist.
enum class NET_IODeviceOpenMode : uint32
{
    NotOpen = 0,
    ReadOnly = 1 << 0,
    WriteOnly = 1 << 1,
    ReadWrite = ReadOnly | WriteOnly,
    Append = 1 << 2,
    Truncate = 1 << 3,
    Unbuffered = 1 << 4,
    NewOnly = 1 << 5,
    ExistingOnly = 1 << 6
};
UT_ENABLE_ENUM_BIT_FLAGS(NET_IODeviceOpenMode);

class NET_API NET_IODevice
{
public:
    using OpenMode = NET_IODeviceOpenMode;

    virtual ~NET_IODevice() = default;
    UT_NON_COPYABLE(NET_IODevice);

    virtual bool atEnd() const { return pos() >= size();}
    virtual exint bytesAvailable() const = 0;
    virtual exint read(char* data, exint max_size) { return 0; }
    virtual UT_Array<char> read(exint max_size);
    virtual UT_Array<char> readAll();
    virtual bool seek(exint pos) { return true; }
    virtual void flush() {}
    virtual exint size() const { return 0; }
    virtual exint write(const char* data, exint max_size) { return 0; }
    virtual exint write(const char* data) { return 0; }
    virtual exint write(const UT_Array<char>& data) { return 0; }
    virtual exint pos() const = 0;
    virtual void close()
    {
        myMode = OpenMode::NotOpen;
        myError = UT_ErrorCode();
    }
    virtual bool open(OpenMode mode)
    {
        if (mode == OpenMode::Append)
            mode |= OpenMode::ReadWrite;
        myMode = mode;
        return true;
    }
    virtual bool isSequential() const { return false; }
    const UT_ErrorCode& error() const { return myError; }

    const UT_StringHolder& mime() const { return myMime; }
    void setMime(const UT_StringHolder& mime) { myMime = mime;}

    OpenMode mode() const { return myMode; }
    bool isReadable() const
    {
        return static_cast<uint32>(myMode)
               & static_cast<uint32>(OpenMode::ReadOnly);
    }
    bool isWriteable() const
    {
        return static_cast<uint32>(myMode)
               & static_cast<uint32>(OpenMode::WriteOnly);
    }
    bool isOpen() const
    {
        return myMode != OpenMode::NotOpen;
    }

protected:
    NET_IODevice() = default;
    UT_ErrorCode myError;
    UT_StringHolder myMime;
    OpenMode myMode = OpenMode::NotOpen;
};

#endif // __NET_IODEVICE_H__