container.h

Go to the documentation of this file.

#ifndef CONTAINER_H
#define CONTAINER_H
#pragma once
 
#include "config.h"
 
namespace original {
template <typename TYPE, typename ALLOC>
class container {
protected:
    ALLOC allocator;
 
    explicit container(ALLOC alloc = ALLOC{});
 
    TYPE* allocate(u_integer size);
 
    void deallocate(TYPE* ptr, u_integer size);
 
    template<typename O_TYPE, typename... Args>
    void construct(O_TYPE* o_ptr, Args&&... args);
 
    template<typename O_TYPE>
    void destroy(O_TYPE* o_ptr);
public:
    [[nodiscard]] virtual u_integer size() const = 0;
 
    [[nodiscard]] bool empty() const;
 
    virtual bool contains(const TYPE& e) const = 0;
 
    virtual ~container() = default;
};
 
} // namespace original
 
// ----------------- Definitions of container.h -----------------
 
template<typename TYPE, typename ALLOC>
original::container<TYPE, ALLOC>::container(ALLOC alloc)
    : allocator(std::move(alloc)) {}
 
template<typename TYPE, typename ALLOC>
TYPE* original::container<TYPE, ALLOC>::allocate(u_integer size) {
    return this->allocator.allocate(size);
}
 
template<typename TYPE, typename ALLOC>
void original::container<TYPE, ALLOC>::deallocate(TYPE *ptr, u_integer size) {
    this->allocator.deallocate(ptr, size);
}
 
template<typename TYPE, typename ALLOC>
template<typename O_TYPE, typename... Args>
void original::container<TYPE, ALLOC>::construct(O_TYPE *o_ptr, Args &&... args) {
    this->allocator.construct(o_ptr, std::forward<Args>(args)...);
}
 
template<typename TYPE, typename ALLOC>
template<typename O_TYPE>
void original::container<TYPE, ALLOC>::destroy(O_TYPE *o_ptr) {
    this->allocator.destroy(o_ptr);
}
 
template <typename TYPE, typename ALLOC>
bool original::container<TYPE, ALLOC>::empty() const {
    return this->size() == 0;
}
 
#endif //CONTAINER_H