StreamIO.hxx

#pragma once
 
// Linux
#include <unistd.h>
 
// C++
#include <string>
#include <string_view>
 
// cosmos
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/io/iovector.hxx>
 
namespace cosmos {
 
 
class COSMOS_API StreamIO {
public: // types
 
        enum class SeekType : int {
                SET = SEEK_SET, 
                CUR = SEEK_CUR, 
                END = SEEK_END, 
 
                DATA = SEEK_DATA,
 
                HOLE = SEEK_HOLE
        };
 
public: // functions
 
        explicit StreamIO(FileDescriptor &fd) :
                        m_stream_fd{fd}
        {}
 
        StreamIO(const StreamIO&) = delete;
        StreamIO& operator=(const StreamIO&) = delete;
 
        StreamIO& operator=(StreamIO &&) noexcept {
                // simply do nothing, the fixed coupling to the FD remains and
                // should reflect the new object state.
                return *this;
        }
 
 
        size_t read(void *buf, size_t length);
 
 
        size_t write(const void *buf, size_t length);
 
        size_t write(const std::string_view data) {
                return write(data.data(), data.size());
        }
 
 
        void readAll(void *buf, size_t length);
 
        void readAll(std::string &s, size_t length) {
                s.resize(length);
                try {
                        readAll(s.data(), length);
                } catch(...) {
                        s.clear();
                        throw;
                }
        }
 
 
        void writeAll(const void *buf, size_t length);
 
        void writeAll(const std::string_view data) {
                return writeAll(data.data(), data.size());
        }
 
 
        bool read(ReadIOVector &iovec);
 
 
        bool write(WriteIOVector &iovec);
 
 
        void readAll(ReadIOVector &iovec) {
                while (!read(iovec)) {
                        ;
                }
        }
 
 
        void writeAll(WriteIOVector &iovec) {
                while (!write(iovec)) {
                        ;
                }
        }
 
        off_t seek(const SeekType type, off_t off);
 
        off_t seekFromStart(off_t off) { return seek(SeekType::SET, off); }
        off_t seekFromCurrent(off_t off) { return seek(SeekType::CUR, off); }
        off_t seekFromEnd(off_t off) { return seek(SeekType::END, off); }
 
protected: // data
 
        FileDescriptor &m_stream_fd;
};
 
} // end ns