identity.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_IDENTITY_H_
#define SYDEVS_IDENTITY_H_
 
#include <sydevs/core/number_types.h>
#include <ostream>
 
namespace sydevs {
 
 
template<typename U>
class identity 
{
public:
    constexpr identity();
 
    constexpr explicit identity(int64 index);
 
    constexpr identity(const identity&)  = default;  
    identity& operator=(const identity&) = default;  
    identity(identity&&)                 = default;  
    identity& operator=(identity&&)      = default;  
    ~identity()                          = default;  
 
    constexpr bool valid() const;   
    constexpr int64 index() const;  
 
    identity& operator++();              
    identity  operator++(int);           
    identity& operator--();              
    identity  operator--(int);           
 
    identity& operator+=(int64 rhs);  
    identity& operator-=(int64 rhs);  
 
    constexpr const identity operator+() const;  
    
    constexpr const identity operator+(int64 rhs) const;  
    constexpr const identity operator-(int64 rhs) const;  
 
    constexpr bool operator==(identity rhs) const;  
    constexpr bool operator!=(identity rhs) const;  
    constexpr bool operator<(identity rhs) const;   
    constexpr bool operator>(identity rhs) const;   
    constexpr bool operator<=(identity rhs) const;  
    constexpr bool operator>=(identity rhs) const;  
 
protected:
    static constexpr int64 nan_int64 = std::numeric_limits<int64>::min();
 
private:
    int64 index_;
};
 
 
template<typename U>
constexpr identity<U>::identity()
    : index_(nan_int64)
{
}
 
    
template<typename U>
constexpr identity<U>::identity(int64 index)
    : index_(index)
{
}
 
    
template<typename U>
constexpr bool identity<U>::valid() const
{
    return index_ != nan_int64;
}
 
 
template<typename U>
constexpr int64 identity<U>::index() const
{
    return index_;
}
 
 
template<typename U>
identity<U>& identity<U>::operator++()
{
    if (valid()) {
        ++index_;
    }
    return *this;
}
 
 
template<typename U>
identity<U> identity<U>::operator++(int)
{
    auto old = *this;
    ++(*this);
    return old;
}
 
 
template<typename U>
identity<U>& identity<U>::operator--()
{
    if (valid()) {
        --index_;
    }
    return *this;
}
 
 
template<typename U>
identity<U> identity<U>::operator--(int)
{
    auto old = *this;
    --(*this);
    return old;
}
 
 
template<typename U>
identity<U>& identity<U>::operator+=(int64 rhs)
{
    *this = *this + rhs;
    return *this;
}
 
 
template<typename U>
identity<U>& identity<U>::operator-=(int64 rhs)
{
    *this = *this - rhs;
    return *this;
}
 
 
template<typename U>
constexpr const identity<U> identity<U>::operator+() const
{
    return *this;
}
 
 
template<typename U>
constexpr const identity<U> identity<U>::operator+(int64 rhs) const
{
    return valid() ? identity<U>(index_ + rhs) : identity<U>();
}
 
 
template<typename U>
constexpr const identity<U> identity<U>::operator-(int64 rhs) const
{
    return valid() ? identity<U>(index_ - rhs) : identity<U>();
}
 
 
template<typename U>
constexpr bool identity<U>::operator==(identity rhs) const
{
    return index_ == rhs.index_;
}
 
 
template<typename U>
constexpr bool identity<U>::operator!=(identity rhs) const
{
    return index_ != rhs.index_;
}
 
 
template<typename U>
constexpr bool identity<U>::operator<(identity rhs) const
{
    return index_ < rhs.index_;
}
 
 
template<typename U>
constexpr bool identity<U>::operator>(identity rhs) const
{
    return index_ > rhs.index_;
}
 
 
template<typename U>
constexpr bool identity<U>::operator<=(identity rhs) const
{
    return index_ <= rhs.index_;
}
 
 
template<typename U>
constexpr bool identity<U>::operator>=(identity rhs) const
{
    return index_ >= rhs.index_;
}
 
    
template<typename U>
constexpr const identity<U> operator+(int64 lhs, identity<U> rhs)
{
    return rhs + lhs;
}
 
 
template<typename U>
inline std::ostream& operator<<(std::ostream& os, const identity<U>& rhs)
{
    if (!rhs.valid()) {
        os << "{}";
    }
    else {
        os << "{" << rhs.index() << "}";
    }
    return os;
}
 
 
}  // namespace
 
#endif