serial.h

Go to the documentation of this file.

#ifndef SERIAL_H
#define SERIAL_H
 
#include "container.h"
 
namespace original {

    template <typename TYPE, typename ALLOC>
    class serial : public container<TYPE, ALLOC> {
    protected:
        using container<TYPE, ALLOC>::container;

        [[nodiscard]] bool indexOutOfBound(integer index) const;

        [[nodiscard]] integer parseNegIndex(integer index) const;
 
    public:
        virtual TYPE get(integer index) const = 0;

        virtual TYPE getBegin() const;

        virtual TYPE getEnd() const;

        virtual TYPE operator[](integer index) const;

        virtual TYPE& operator[](integer index) = 0;

        virtual void set(integer index, const TYPE& e) = 0;

        virtual u_integer indexOf(const TYPE& e) const = 0;

        bool contains(const TYPE& e) const override;
    };
}
 
// -------------------- Definitions of serial.h --------------------
 
template<typename TYPE, typename ALLOC>
auto original::serial<TYPE, ALLOC>::indexOutOfBound(const integer index) const -> bool
{
    integer parsed_index = this->parseNegIndex(index);
    return parsed_index < 0 || parsed_index >= this->size();
}
 
template<typename TYPE, typename ALLOC>
auto original::serial<TYPE, ALLOC>::parseNegIndex(integer index) const -> integer {
    return index >= 0 ? index : this->size() + index;
}
 
template<typename TYPE, typename ALLOC>
auto original::serial<TYPE, ALLOC>::getBegin() const -> TYPE {
    return this->get(0);
}
 
template<typename TYPE, typename ALLOC>
auto original::serial<TYPE, ALLOC>::getEnd() const -> TYPE {
    return this->get(-1);
}
 
template<typename TYPE, typename ALLOC>
auto original::serial<TYPE, ALLOC>::operator[](const integer index) const -> TYPE
{
    return this->get(index);
}
 
template<typename TYPE, typename ALLOC>
auto original::serial<TYPE, ALLOC>::contains(const TYPE &e) const -> bool
{
    return this->indexOf(e) != this->size();
}
 
#endif //SERIAL_H