Input.hpp

Go to the documentation of this file.

#pragma once

#include <cstddef>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#include <iterator>
#include <memory>

#include <tudocomp/util.hpp>

#include <tudocomp/io/Path.hpp>
#include <tudocomp/io/InputRestrictions.hpp>
#include <tudocomp/io/InputAlloc.hpp>
#include <tudocomp/io/IOUtil.hpp>
#include <tudocomp/io/ViewStream.hpp>

namespace tdc {namespace io {
    class InputView;
    class InputStream;

    class Input {
    public:
        static constexpr size_t npos = -1;
    private:
        class Variant {
            InputSource m_source;
            InputAllocHandle m_handle;
            InputRestrictions m_input_restrictions;
            size_t m_from = 0;
            size_t m_to = npos;
            mutable size_t m_escaped_size_cache = npos;
        protected:
            inline void set_escaped_size(size_t size) const {
                m_escaped_size_cache = size;
            }
            inline Variant(const Variant& other,
                           size_t from,
                           size_t to): Variant(other) {
                m_from = from;
                m_to = to;
                m_escaped_size_cache = npos;
            }
            inline Variant(const Variant& other,
                           const InputRestrictions& restrictions): Variant(other) {
                m_input_restrictions = restrictions;
                m_escaped_size_cache = npos;
            }
        public:
            inline Variant(const InputSource& src): m_source(src) {}

            inline const InputAllocHandle& alloc() const {
                return m_handle;
            }

            inline const InputRestrictions& restrictions() const {
                return m_input_restrictions;
            }

            inline size_t from() const {
                return m_from;
            }

            inline size_t to() const {
                return m_to;
            }

            inline bool to_unknown() const {
                return m_to == npos;
            }

            inline bool escaped_size_unknown() const {
                return m_escaped_size_cache == npos;
            }

            inline size_t escaped_size() const {
                DCHECK(!escaped_size_unknown());
                return m_escaped_size_cache;
            }

            inline const InputSource source() const {
                return m_source;
            }

            inline std::shared_ptr<Variant> slice(size_t from, size_t to) const;
            inline std::shared_ptr<Variant> restrict(const InputRestrictions& rest) const;
            inline size_t size() const;
            inline InputView as_view() const;
            inline InputStream as_stream() const;
        };

        friend class InputStream;
        friend class InputStreamInternal;
        friend class InputView;

        std::shared_ptr<Variant> m_data;
    public:
        inline Input():
            m_data(std::make_shared<Variant>(InputSource(""_v))) {}

        inline Input(const Input& other):
            m_data(other.m_data) {}

        inline Input(Input&& other):
            m_data(std::move(other.m_data)) {}

        Input(Path&& path):
            m_data(std::make_shared<Variant>(InputSource(path.path))) {}

        Input(const string_ref& buf):
            m_data(std::make_shared<Variant>(View(buf))) {}

        Input(const std::vector<uint8_t>& buf):
            Input(string_ref(buf)) {}

        Input(std::istream& stream):
            m_data(std::make_shared<Variant>(InputSource(&stream))) {}

        Input& operator=(Input&& other) {
            m_data = std::move(other.m_data);
            return *this;
        }

        Input& operator=(const Input& other) {
            Input cpy(other);
            *this = std::move(cpy);
            return *this;
        }

        static Input from_path(std::string path) {
            return Input(Path { path });
        }

        static Input from_memory(const std::vector<uint8_t>& buf) {
            return Input(buf);
        }

        static Input from_memory(const string_ref buf) {
            return Input(buf);
        }

        inline InputView as_view() const;

        inline InputStream as_stream() const;

        inline size_t size() const {
            return m_data->size();
        }

        inline Input(const Input& other, size_t from, size_t to = npos):
            m_data(other.m_data->slice(from, to)) {}

        inline Input(const Input& other, const InputRestrictions& restrictions):
            m_data(other.m_data->restrict(restrictions)) {}
    };

}}

#include <tudocomp/io/InputView.hpp>
#include <tudocomp/io/InputStream.hpp>
#include <tudocomp/io/InputSize.hpp>

namespace tdc {namespace io {
    inline InputView Input::as_view() const {
        return m_data->as_view();
    }

    inline InputStream Input::as_stream() const {
        return m_data->as_stream();
    }
}}