containerAdapter.h

Go to the documentation of this file.

#ifndef CONTAINERADAPTER_H
#define CONTAINERADAPTER_H
#include "baseList.h"
#include "types.h"
#include "printable.h"
#include "comparable.h"
#include "hash.h"
 
 
namespace original {
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    class containerAdapter
            : public printable,
              public container<TYPE, ALLOC<TYPE>>,
              public comparable<containerAdapter<TYPE, SERIAL, ALLOC>>,
              public hashable<containerAdapter<TYPE, SERIAL, ALLOC>> {
    protected:
        SERIAL<TYPE, ALLOC<TYPE>> serial_;
 
        explicit containerAdapter(const SERIAL<TYPE, ALLOC<TYPE>>& serial);
 
    public:
        [[nodiscard]] u_integer size() const override;
 
        void swap(containerAdapter& other) noexcept;
 
        void clear();
 
        bool contains(const TYPE &e) const override;
 
        integer compareTo(const containerAdapter &other) const override;
 
        [[nodiscard]] u_integer toHash() const noexcept override;
 
        [[nodiscard]] std::string className() const override;
 
        [[nodiscard]] std::string toString(bool enter) const override;
 
        ~containerAdapter() override = default;
    };
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    containerAdapter<TYPE, SERIAL, ALLOC>::containerAdapter(const SERIAL<TYPE, ALLOC<TYPE>>& serial)
            : serial_(serial) {}
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    auto containerAdapter<TYPE, SERIAL, ALLOC>::size() const -> u_integer
    {
        return serial_.size();
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    void containerAdapter<TYPE, SERIAL, ALLOC>::swap(containerAdapter& other) noexcept
    {
        if (this == &other)
            return;
        serial_.swap(other.serial_);
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    auto containerAdapter<TYPE, SERIAL, ALLOC>::clear() -> void {
        serial_.clear();
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    auto containerAdapter<TYPE, SERIAL, ALLOC>::contains(const TYPE &e) const -> bool {
        return serial_.contains(e);
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    auto containerAdapter<TYPE, SERIAL, ALLOC>::compareTo(const containerAdapter& other) const -> integer
    {
        return serial_.compareTo(other.serial_);
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    u_integer containerAdapter<TYPE, SERIAL, ALLOC>::toHash() const noexcept
    {
        return this->serial_.toHash();
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    auto containerAdapter<TYPE, SERIAL, ALLOC>::className() const -> std::string {
        return "containerAdapter";
    }
 
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    requires ExtendsOf<baseList<TYPE, ALLOC<TYPE>>, SERIAL<TYPE, ALLOC<TYPE>>>
    auto containerAdapter<TYPE, SERIAL, ALLOC>::toString(const bool enter) const -> std::string {
        std::stringstream ss;
        ss << this->className() << "(";
        bool first = true;
        for (const auto e : this->serial_)
        {
            if (!first) ss << ", ";
            ss << printable::formatString(e);
            first = false;
        }
        ss << ")";
        if (enter) ss << "\n";
        return ss.str();
    }
}
 
namespace std {
    template <typename TYPE,
              template <typename, typename> typename SERIAL,
              template <typename> typename ALLOC>
    void swap(original::containerAdapter<TYPE, SERIAL, ALLOC>& lhs, // NOLINT
              original::containerAdapter<TYPE, SERIAL, ALLOC>& rhs) noexcept {
        lhs.swap(rhs);
    }
}
 
 
#endif //CONTAINERADAPTER_H