GenericConstView.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>

namespace tdc {

template<class T>
class GenericView;

template<class T>
class ConstGenericView: GenericViewBase<T, const T*> {
    using Super = GenericViewBase<T, const T*>;
    inline ConstGenericView(const Super& other): Super::GenericViewBase(other) {}
    friend class GenericView<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 T* data, size_t len):
        Super::GenericViewBase(data, len) {}

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

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

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

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

    inline operator std::vector<T>() const {
        return Super::operator std::vector<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 T& other) const {
        return Super::starts_with(other);
    }

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

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

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

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

    template<typename U>
    friend bool operator==(const ConstGenericView<U>& lhs,
                           const ConstGenericView<U>& rhs);
    template<typename U>
    friend bool operator!=(const ConstGenericView<U>& lhs,
                           const ConstGenericView<U>& rhs);
    template<typename U>
    friend bool operator<(const ConstGenericView<U>& lhs,
                          const ConstGenericView<U>& rhs);
    template<typename U>
    friend bool operator<=(const ConstGenericView<U>& lhs,
                           const ConstGenericView<U>& rhs);
    template<typename U>
    friend bool operator>(const ConstGenericView<U>& lhs,
                          const ConstGenericView<U>& rhs);
    template<typename U>
    friend bool operator>=(const ConstGenericView<U>& lhs,
                           const ConstGenericView<U>& rhs);
};

template<class T>
bool operator==(const ConstGenericView<T>& lhs, const ConstGenericView<T>& rhs) {
    return ConstGenericView<T>::op_eq(lhs, rhs);
}

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

template<class T>
bool operator<(const ConstGenericView<T>& lhs, const ConstGenericView<T>& rhs) {
    return ConstGenericView<T>::op_less(lhs, rhs);
}

template<class T>
bool operator<=(const ConstGenericView<T>& lhs, const ConstGenericView<T>& rhs) {
    return ConstGenericView<T>::op_less_eq(lhs, rhs);
}

template<class T>
bool operator>(const ConstGenericView<T>& lhs, const ConstGenericView<T>& rhs) {
    return ConstGenericView<T>::op_greater(lhs, rhs);
}

template<class T>
bool operator>=(const ConstGenericView<T>& lhs, const ConstGenericView<T>& rhs) {
    return ConstGenericView<T>::op_greater_eq(lhs, rhs);
}

template<class T>
void swap(ConstGenericView<T>& lhs, ConstGenericView<T>& rhs) {
    using Super = typename ConstGenericView<T>::Super;
    return swap((Super&) lhs, (Super&) rhs);
}

}

namespace std {
    template<class T>
    struct hash<tdc::ConstGenericView<T>>
    {
        size_t operator()(const tdc::ConstGenericView<T>& x) const {
            std::size_t seed = 0;
            std::hash<T> hasher;
            for (const auto& v : x) {
                seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
            }
            return seed;
        }
    };
}