iterationStream.h

Go to the documentation of this file.

#ifndef ITERATIONSTREAM_H
#define ITERATIONSTREAM_H
 
#include <sstream>
#include "comparable.h"
#include "hash.h"
#include "printable.h"
#include "iterable.h"
#include "types.h"
 
namespace original {
    template<typename TYPE, typename DERIVED>
    class iterationStream : public printable,
                            public iterable<TYPE>,
                            public comparable<iterationStream<TYPE, DERIVED>>,
                            public hashable<iterationStream<TYPE, DERIVED>> {
    protected:
        [[nodiscard]] std::string elementsString() const;
 
    public:
        integer compareTo(const iterationStream &other) const override;
 
        [[nodiscard]] u_integer toHash() const noexcept override;
 
        [[nodiscard]] std::string className() const override;
 
        [[nodiscard]] std::string toString(bool enter) const override;
    };
}
 
template<typename TYPE, typename DERIVED>
auto original::iterationStream<TYPE, DERIVED>::elementsString() const -> std::string
{
    std::stringstream ss;
    ss << "(";
    bool first = true;
    for (const auto it = this->begin(); it.isValid(); ++it) {
        if (!first) {
            ss << ", ";
        }
        ss << formatString(it.get());
        first = false;
    }
    ss << ")";
    return ss.str();
}
 
template<typename TYPE, typename DERIVED>
auto original::iterationStream<TYPE, DERIVED>::compareTo(const iterationStream &other) const -> integer {
    const auto this_it = this->begin();
    const auto other_it = other.begin();
    for (; this_it.isValid() && other_it.isValid(); ++this_it, ++other_it) {
        if constexpr (Comparable<TYPE>){
            if (*this_it != *other_it)
                return *this_it < *other_it ? -1 : 1;
        }
    }
    return this_it.isValid() - other_it.isValid();
}
 
template <typename TYPE, typename DERIVED>
original::u_integer original::iterationStream<TYPE, DERIVED>::toHash() const noexcept
{
    u_integer seed = 0;
    for (const auto& elem : *this) {
        hash<TYPE>::hashCombine(seed, elem);
    }
    return seed;
}
 
template<typename TYPE, typename DERIVED>
auto original::iterationStream<TYPE, DERIVED>::className() const -> std::string {
    return "iterationStream";
}
 
template<typename TYPE, typename DERIVED>
auto original::iterationStream<TYPE, DERIVED>::toString(const bool enter) const -> std::string
{
    std::stringstream ss;
    ss << this->className() << this->elementsString();
    if (enter) ss << "\n";
    return ss.str();
}
 
#endif //ITERATIONSTREAM_H