GenericConstU8View.hpp

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <cmath>
#include <cstddef>
#include <fstream>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <iomanip>
#include <cstring>
#include <glog/logging.h>
#include <functional>

#include <tudocomp/pre_header/GenericViewBase.hpp>
#include <tudocomp/util/GenericConstView.hpp>

namespace tdc {

template<>
class ConstGenericView<uliteral_t>: GenericViewBase<uliteral_t, const uliteral_t*> {
    using Super = GenericViewBase<uliteral_t, const uliteral_t*>;
    inline ConstGenericView(const Super& other): Super::GenericViewBase(other) {}
    friend class GenericView<uliteral_t>;

    using Super::op_eq;
    using Super::op_not_eq;
    using Super::op_greater;
    using Super::op_greater_eq;
    using Super::op_less;
    using Super::op_less_eq;
public:
    using value_type             = typename Super::value_type;
    using const_reference        = typename Super::const_reference;
    using const_pointer          = typename Super::const_pointer;
    using const_iterator         = typename Super::const_iterator;
    using const_reverse_iterator = typename Super::const_reverse_iterator;
    using difference_type        = typename Super::difference_type;
    using size_type              = typename Super::size_type;

    static const size_type npos  = Super::npos;

    inline ConstGenericView():
        Super::GenericViewBase() {}

    inline ConstGenericView(const uliteral_t* data, size_t len):
        Super::GenericViewBase(data, len) {}

    inline ConstGenericView(const ConstGenericView& other):
        Super::GenericViewBase(other) {}

    inline ConstGenericView(const GenericView<uliteral_t>& other):
        ConstGenericView(other.data(), other.size()) {}

    inline ConstGenericView(const std::vector<uliteral_t>& other):
        Super::GenericViewBase(other.data(), other.size()) {}

    template<size_t N>
    inline ConstGenericView(const std::array<uliteral_t, N>& other):
        Super::GenericViewBase(other.data(), other.size()) {}

    inline operator std::vector<uliteral_t>() const {
        return Super::operator std::vector<uliteral_t>();
    }

    inline const_iterator begin() const {
        return Super::begin();
    }

    inline const_iterator end() const {
        return Super::end();
    }

    inline const_reverse_iterator rbegin() const {
        return Super::rbegin();
    }

    inline const_reverse_iterator rend() const {
        return Super::rend();
    }

    inline const_iterator cbegin() const {
        return Super::cbegin();
    }

    inline const_iterator cend() const {
        return Super::cend();
    }

    inline const_reverse_iterator crbegin() const {
        return Super::crbegin();
    }

    inline const_reverse_iterator crend() const {
        return Super::crend();
    }

    inline size_type size() const {
        return Super::size();
    }

    inline size_type max_size() const {
        return Super::max_size();
    }

    inline bool empty() const {
        return Super::empty();
    }

    inline const_reference operator[](size_type pos) const {
        return Super::operator[](pos);
    }

    inline const_reference at(size_type pos) const {
        return Super::at(pos);
    }

    inline const_reference front() const {
        return Super::front();
    }

    inline const_reference back() const {
        return Super::back();
    }

    inline const value_type* data() const noexcept {
        return Super::data();
    }

    inline void pop_back() {
        Super::pop_back();
    }

    inline void pop_front() {
        Super::pop_front();
    }

    inline void swap(ConstGenericView& other) {
        Super::swap(other);
    }

    inline void clear() {
        Super::clear();
    }

    inline ConstGenericView substr(size_type pos, size_type len = npos) const {
        return ConstGenericView(Super::substr(pos, len));
    }

    inline ConstGenericView slice(size_type from, size_type to = npos) const {
        return ConstGenericView(Super::slice(from, to));
    }

    inline void remove_prefix(size_type n) {
        return Super::remove_prefix(n);
    }

    inline void remove_suffix(size_type n) {
        return Super::remove_suffix(n);
    }

    inline bool starts_with(const uliteral_t& other) const {
        return Super::starts_with(other);
    }

    inline bool starts_with(const ConstGenericView<uliteral_t>& other) const {
        return Super::starts_with(other);
    }

    inline bool ends_with(const uliteral_t& other) const {
        return Super::ends_with(other);
    }

    inline bool ends_with(const ConstGenericView<uliteral_t>& other) const {
        return Super::ends_with(other);
    }

    template<class U>
    friend void swap(ConstGenericView<U>& lhs, ConstGenericView<U>& rhs);

    friend bool operator==(const ConstGenericView<uliteral_t>& lhs,
                           const ConstGenericView<uliteral_t>& rhs);
    friend bool operator!=(const ConstGenericView<uliteral_t>& lhs,
                           const ConstGenericView<uliteral_t>& rhs);
    friend bool operator<(const ConstGenericView<uliteral_t>& lhs,
                          const ConstGenericView<uliteral_t>& rhs);
    friend bool operator<=(const ConstGenericView<uliteral_t>& lhs,
                           const ConstGenericView<uliteral_t>& rhs);
    friend bool operator>(const ConstGenericView<uliteral_t>& lhs,
                          const ConstGenericView<uliteral_t>& rhs);
    friend bool operator>=(const ConstGenericView<uliteral_t>& lhs,
                           const ConstGenericView<uliteral_t>& rhs);

    // string extensions

    inline ConstGenericView(const std::string& other):
        ConstGenericView((const uliteral_t*) other.data(), other.size()) {}

    inline ConstGenericView(const char* other):
        ConstGenericView((const uliteral_t*) other, strlen(other)) {}

    inline ConstGenericView(const char* data, size_t len):
        ConstGenericView((const uliteral_t*) data, len) {}

    inline operator std::string() const {
        return std::string(cbegin(), cend());
    }

};

inline bool operator==(const ConstGenericView<uliteral_t>& lhs,
                       const ConstGenericView<uliteral_t>& rhs) {
    return ConstGenericView<uliteral_t>::op_eq(lhs, rhs);
}

inline bool operator!=(const ConstGenericView<uliteral_t>& lhs,
                       const ConstGenericView<uliteral_t>& rhs) {
    return ConstGenericView<uliteral_t>::op_not_eq(lhs, rhs);
}

inline bool operator<(const ConstGenericView<uliteral_t>& lhs,
                      const ConstGenericView<uliteral_t>& rhs) {
    return ConstGenericView<uliteral_t>::op_less(lhs, rhs);
}

inline bool operator<=(const ConstGenericView<uliteral_t>& lhs,
                       const ConstGenericView<uliteral_t>& rhs) {
    return ConstGenericView<uliteral_t>::op_less_eq(lhs, rhs);
}

inline bool operator>(const ConstGenericView<uliteral_t>& lhs,
                      const ConstGenericView<uliteral_t>& rhs) {
    return ConstGenericView<uliteral_t>::op_greater(lhs, rhs);
}

inline bool operator>=(const ConstGenericView<uliteral_t>& lhs,
                       const ConstGenericView<uliteral_t>& rhs) {
    return ConstGenericView<uliteral_t>::op_greater_eq(lhs, rhs);
}

inline std::ostream& operator<<(std::ostream& os,
                                const ConstGenericView<uliteral_t>& v) {
    os.write((const char*) v.data(), v.size());
    return os;
}

inline ConstGenericView<uliteral_t> operator "" _v(const char* str, size_t n)
{
    return ConstGenericView<uliteral_t>(str, n);
}

}