GenericView.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 T>
class GenericView: GenericViewBase<T, T*> {
    using Super = GenericViewBase<T, T*>;
    inline GenericView(const Super& other): Super::GenericViewBase(other) {}
public:
    // Type members

    using value_type             = typename Super::value_type;
    using reference              = T&;
    using const_reference        = typename Super::const_reference;
    using pointer                = T*;
    using const_pointer          = typename Super::const_pointer;
    using iterator               = pointer;
    using const_iterator         = typename Super::const_iterator;
    using reverse_iterator       = std::reverse_iterator<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 value members

    static const size_type npos  = Super::npos;

    // Constructors

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

    inline GenericView(T* data, size_t len):
        Super::GenericViewBase(data, len) {}

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

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

    template<size_t N>
    inline GenericView(std::array<uliteral_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 iterator begin() {
        return this->m_data;
    }

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

    inline iterator end() {
        return this->m_data + this->m_size;
    }

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

    inline reverse_iterator rbegin() {
        return std::reverse_iterator<iterator>(end());
    }

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

    inline reverse_iterator rend() {
        return std::reverse_iterator<iterator>(begin());
    }

    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 reference operator[](size_type n) {
        Super::debug_bound_check(n);
        return this->m_data[n];
    }

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

    inline reference at(size_type n) {
        Super::bound_check(n);
        return this->m_data[n];
    }

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

    inline reference front() {
        Super::debug_bound_check_not_empty();
        return this->m_data[0];
    }

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

    inline reference back() {
        Super::debug_bound_check_not_empty();
        return this->m_data[size() - 1];
    }

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

    inline value_type* data() noexcept {
        return this->m_data;
    }

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

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

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

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

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

    inline GenericView slice(size_type from, size_type to = npos) const {
        return 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(GenericView<U>& lhs, GenericView<U>& rhs);
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

namespace std {
    template<class T>
    struct hash<tdc::GenericView<T>> {
        size_t operator()(const tdc::GenericView<T>& x) const {
            return hash<tdc::ConstGenericView<T>>()(x);
        }
    };
}