Slice.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Core/Types.hpp"
#include "NumCpp/Utils/num2str.hpp"
 
namespace nc
{
    //================================================================================
    class Slice
    {
    public:
        //====================================Attributes==============================
        int32 start{ 0 };
        int32 stop{ 1 };
        int32 step{ 1 };
 
        //============================================================================
        constexpr Slice() = default;
 
        //============================================================================
        constexpr explicit Slice(int32 inStop) noexcept :
            stop(inStop)
        {
        }
        constexpr explicit Slice(int32 inStop) noexcept : {…}
 
        //============================================================================
        constexpr Slice(int32 inStart, int32 inStop) noexcept :
            start(inStart),
            stop(inStop)
        {
        }
        constexpr Slice(int32 inStart, int32 inStop) noexcept : {…}
 
        //============================================================================
        constexpr Slice(int32 inStart, int32 inStop, int32 inStep) noexcept :
            start(inStart),
            stop(inStop),
            step(inStep)
        {
        }
        constexpr Slice(int32 inStart, int32 inStop, int32 inStep) noexcept : {…}
 
        //============================================================================
        bool operator==(const Slice& inOtherSlice) const noexcept
        {
            return start == inOtherSlice.start && stop == inOtherSlice.stop && step == inOtherSlice.step;
        }
        bool operator==(const Slice& inOtherSlice) const noexcept {…}
 
        //============================================================================
        bool operator!=(const Slice& inOtherSlice) const noexcept
        {
            return !(*this == inOtherSlice);
        }
        bool operator!=(const Slice& inOtherSlice) const noexcept {…}
 
        //============================================================================
        [[nodiscard]] std::string str() const
        {
            std::string out =
                "[" + utils::num2str(start) + ":" + utils::num2str(stop) + ":" + utils::num2str(step) + "]\n";
            return out;
        }
        [[nodiscard]] std::string str() const {…}
 
        //============================================================================
        void print() const
        {
            std::cout << *this;
        }
        void print() const {…}
 
        //============================================================================
        void makePositiveAndValidate(uint32 inArraySize)
        {
            if (start < 0)
            {
                start += static_cast<int32>(inArraySize);
            }
            if (start > static_cast<int32>(inArraySize - 1))
            {
                THROW_INVALID_ARGUMENT_ERROR("Invalid start value for array of size " + utils::num2str(inArraySize));
            }
 
            if (stop < 0)
            {
                stop += static_cast<int32>(inArraySize);
            }
            if (stop > static_cast<int32>(inArraySize))
            {
                THROW_INVALID_ARGUMENT_ERROR("Invalid stop value for array of size " + utils::num2str(inArraySize));
            }
 
            if (start < stop)
            {
                if (step < 0)
                {
                    THROW_INVALID_ARGUMENT_ERROR("Invalid slice values [" + utils::num2str(start) + ", " +
                                                 utils::num2str(stop) + ", " + utils::num2str(step) + ']');
                }
            }
 
            if (stop < start)
            {
                if (step > 0)
                {
                    THROW_INVALID_ARGUMENT_ERROR("Invalid slice values [" + utils::num2str(start) + ", " +
                                                 utils::num2str(stop) + ", " + utils::num2str(step) + ']');
                }
 
                std::swap(start, stop);
                step *= -1;
            }
        }
        void makePositiveAndValidate(uint32 inArraySize) {…}
 
        //============================================================================
        uint32 numElements(uint32 inArraySize)
        {
            makePositiveAndValidate(inArraySize);
 
            uint32 num = 0;
            for (int32 i = start; i < stop; i += step)
            {
                ++num;
            }
            return num;
        }
        uint32 numElements(uint32 inArraySize) {…}
 
        //============================================================================
        std::vector<uint32> toIndices(uint32 inArrayDimSize)
        {
            std::vector<uint32> indices;
            indices.reserve(numElements(inArrayDimSize));
            for (int32 i = start; i < stop; i += step)
            {
                indices.push_back(static_cast<uint32>(i));
            }
            return indices;
        }
        std::vector<uint32> toIndices(uint32 inArrayDimSize) {…}
 
        //============================================================================
        friend std::ostream& operator<<(std::ostream& inOStream, const Slice& inSlice)
        {
            inOStream << inSlice.str();
            return inOStream;
        }
        friend std::ostream& operator<<(std::ostream& inOStream, const Slice& inSlice) {…};
    };
    class Slice {…};
} // namespace nc