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"
 
 
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>>{
    protected:
        SERIAL<TYPE, ALLOC<TYPE>> serial_;

        explicit containerAdapter(const SERIAL<TYPE, ALLOC<TYPE>>& serial);
 
    public:
        [[nodiscard]] u_integer size() const override;

        void clear();

        bool contains(const TYPE &e) const override;

        integer compareTo(const containerAdapter &other) const 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>>>
    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>>>
    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();
    }
}
 
#endif //CONTAINERADAPTER_H