io_request.h

Go to the documentation of this file.

// Copyright (c) 2018, Smart Projects Holdings Ltd
// All rights reserved.
// See LICENSE file for license details.

#ifndef _UGCS_VSM_IO_REQUEST_H_
#define _UGCS_VSM_IO_REQUEST_H_

#include <ugcs/vsm/io_stream.h>
#include <ugcs/vsm/utils.h>

namespace ugcs {
namespace vsm {

class Io_request: public Request {
    DEFINE_COMMON_CLASS(Io_request, Request)

public:
    Io_request(Io_stream::Ptr stream, Io_stream::Offset offset,
            Io_result& result_arg):
        stream(stream), offset(offset), result_arg(result_arg)
    {}

    Io_stream::Ptr
    Get_stream() const
    {
        return stream;
    }

    Io_stream::Offset &
    Offset()
    {
        return offset;
    }

    void
    Set_result_arg(
            Io_result result,
            const Request::Locker& lock = Request::Locker())
    {
        Request::Locker local_lock;
        if (lock) {
            ASSERT(Lock(false).mutex() == lock.mutex());
        } else {
            local_lock = Lock();
        }
        if (Is_completion_handler_present()) {
            result_arg = result;
        }
        last_result = result;
    }

    Io_result
    Get_last_result()
    {
        return last_result;
    }

private:
    Io_stream::Ptr stream;

    Io_stream::Offset offset;

    Io_result &result_arg;

    Io_result last_result = Io_result::OTHER_FAILURE;

    virtual void
    Destroy() override
    {
        stream = nullptr;
    }
};

class Write_request : public Io_request
{
public:
    typedef std::shared_ptr<Write_request> Ptr;

    template <typename... Args>
    Write_request(Io_buffer::Ptr buffer, Args &&... args):
        Io_request(std::forward<Args>(args)...), buffer(buffer)
    {}

    template <typename... Args>
    static Ptr
    Create(Args &&... args)
    {
        return std::make_shared<Write_request>(std::forward<Args>(args)...);
    }

    Io_buffer::Ptr &
    Data_buffer()
    {
        return buffer;
    }

private:
    Io_buffer::Ptr buffer;
};

class Read_request : public Io_request
{
public:
    typedef std::shared_ptr<Read_request> Ptr;

    template <typename... Args>
    Read_request(Io_buffer::Ptr& buffer_arg, size_t max_to_read, size_t min_to_read,
                 Args &&... args):
        Io_request(std::forward<Args>(args)...),
        buffer_arg(buffer_arg), max_to_read(max_to_read), min_to_read(min_to_read)
    {}

    template <typename... Args>
    static Ptr
    Create(Args &&... args)
    {
        return std::make_shared<Read_request>(std::forward<Args>(args)...);
    }

    void
    Set_buffer_arg(
            Io_buffer::Ptr buffer,
            const Request::Locker& lock = Request::Locker())
    {
        Request::Locker local_lock;
        if (lock) {
            ASSERT(Lock(false).mutex() == lock.mutex());
        } else {
            local_lock = Lock();
        }
        if (Is_completion_handler_present()) {
            buffer_arg = buffer;
        }
        last_read_buffer = buffer;
    }

    Io_buffer::Ptr
    Get_last_read_buffer()
    {
        return last_read_buffer;
    }

    size_t
    Get_max_to_read() const
    {
        return max_to_read;
    }

    size_t
    Get_min_to_read() const
    {
        return min_to_read;
    }

private:
    Io_buffer::Ptr &buffer_arg;

    Io_buffer::Ptr last_read_buffer;

    size_t max_to_read,
           min_to_read;
};

} /* namespace vsm */
} /* namespace ugcs */

#endif /* _UGCS_VSM_IO_REQUEST_H_ */