l4file.hpp

#if !defined(__SYSTEM_L4_L4FILE_HPP__)
#define __SYSTEM_L4_L4FILE_HPP__

//
// L4 includes
//
#include <l4/env/errno.h>
#include <l4/env/env.h>

//
// local includes
//
#include "core/util/noncopyable.hpp"
#include "core/util/likely.hpp"
#include "core/util/c++0x.hpp"
#include "core/system/file.hpp"
#include "dataspace.hpp"

struct l4file : public file, private noncopyable
{
  protected:
    struct dataspace dataspace;
    bool readonly;

    uint8_t *_data;
    offset_t _size;

  public:
    //
    // constructors & destructor
    //
    inline l4file(void)
        : _data(nullptr), _size(0)
    {}

    inline l4file(const std::string &filename, const bool readonly=false)
        : readonly(readonly), _data(nullptr), _size(0)
    {
        open(filename, readonly);
    }

    virtual inline ~l4file(void)
    {
        close();
    }

    //
    // open & close functions
    //
    virtual int open(const std::string &filename, bool readonly=false);
    virtual int close(void);

    //
    // query functions
    //
    virtual inline const char *name(void) const
    {
        return is_open() ? dataspace.name() : nullptr;
    }

    virtual inline bool is_open(void) const
    {
        return _data != nullptr;
    }

    virtual inline bool is_readonly(void) const
    {
        return readonly;
    }

    virtual inline offset_t size(void) const
    {
        return is_open() ? _size : -1;
    }

    //
    // I/O functions
    //
    virtual inline offset_t read(uint8_t *buffer, offset_t offset, offset_t number)
    {
        if (!is_open()) return -L4_EOPEN;
        if (offset + number > size()) return -L4_EINVAL;
        memcpy(buffer, data(offset), number);
        return number;
    }

    virtual inline offset_t write(uint8_t *buffer, offset_t offset, offset_t number)
    {
        if (!is_open()) return -L4_EOPEN;
        if (readonly) return -L4_EROFS;
        if (offset + number > size()) return -L4_EINVAL;
        memcpy(data(offset), buffer, number);
        return number;
    }

    virtual inline int flush(void)
    {
        if (!is_open()) return -L4_EOPEN;
        return 0;
    }

    //
    // specific for l4file
    //
    inline uint8_t *data(offset_t offset=0) const
    {
        return _data + offset;
    }

  protected:
    //
    // L4 file provider helper functions
    //
    static const l4env_infopage_t *get_l4env_infopage(void);
};

#endif

// ***** end of source ***** //