range.h

Go to the documentation of this file.

#pragma once
#ifndef SYDEVS_RANGE_H_
#define SYDEVS_RANGE_H_

#include <sydevs/core/number_types.h>
#include <stdexcept>

namespace sydevs {


class range
{
public:
    constexpr range();

private:
    constexpr range(int64 start_limit, int64 stop_limit, int64 stride, bool after, bool before);

public:
    constexpr range(const range&)  = default;  
    range& operator=(const range&) = default;  
    range(range&&)                 = default;  
    range& operator=(range&&)      = default;  
    ~range()                       = default;  

    constexpr int64 start() const;   
    constexpr int64 stop() const;    
    constexpr int64 stride() const;  

    constexpr range start_at(int64 limit) const;     
    constexpr range start_after(int64 limit) const;  

    constexpr range stop_at(int64 limit) const;      
    constexpr range stop_before(int64 limit) const;  

    constexpr range stride_by(int64 stride) const;  

private:
    int64 start_limit_;
    int64 stop_limit_;
    int64 stride_;
    bool after_;
    bool before_;
};


constexpr range::range()
    : start_limit_(0)
    , stop_limit_(std::numeric_limits<int64>::max())
    , stride_(1)
    , after_(false)
    , before_(false)
{
}


constexpr range::range(int64 start_limit, int64 stop_limit, int64 stride, bool after, bool before)
    : start_limit_(start_limit)
    , stop_limit_(stop_limit)
    , stride_(stride)
    , after_(after)
    , before_(before)
{
}


constexpr int64 range::start() const
{
    return start_limit_ + (after_ ? 2*int64(stride_ > 0) - 1 : 0);
}


constexpr int64 range::stop() const
{
    return stop_limit_ + (before_ ? 2*int64(stride_ < 0) - 1 : 0);
}


constexpr int64 range::stride() const
{
    return stride_;
}


constexpr range range::start_at(int64 limit) const
{
    return range(limit, stop_limit_, stride_, false, before_);
}


constexpr range range::start_after(int64 limit) const
{
    return range(limit, stop_limit_, stride_, true, before_);
}


constexpr range range::stop_at(int64 limit) const
{
    return range(start_limit_, limit, stride_, after_, false);
}


constexpr range range::stop_before(int64 limit) const
{
    return range(start_limit_, limit, stride_, after_, true);
}


constexpr range range::stride_by(int64 stride) const
{
    return range(start_limit_, 
                 (stride_ > 0 && stride < 0 && stop_limit_ == std::numeric_limits<int64>::max()) ? std::numeric_limits<int64>::min() :
                 (stride_ < 0 && stride > 0 && stop_limit_ == std::numeric_limits<int64>::min()) ? std::numeric_limits<int64>::max() :
                                                                                                   stop_limit_, 
                 stride, 
                 after_, 
                 before_);
}


}  // namespace

#endif