BaseValues.hpp

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: BaseValues
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/LibAssert.h>
#include <limits>
#include <cinttypes>
#include <type_traits>
namespace NDEVR
{
    class BaseValues
    {};

    typedef int8_t sint01;

    typedef int16_t sint02;

    typedef int32_t sint04;

    typedef int64_t sint08;

    typedef uint8_t uint01;

    typedef uint16_t uint02;

    typedef uint32_t uint04;

    typedef uint64_t uint08;

    typedef float fltp04;

    typedef double fltp08;

    template<class t_enum_type>
    struct eint04
    {
        static_assert(std::is_enum_v<t_enum_type>);
        t_enum_type v;
        constexpr eint04(t_enum_type e)
            : v(e)
        {
        }
        constexpr operator uint04() const { return static_cast<uint04>(static_cast<std::underlying_type_t<t_enum_type>>(v)); }
        constexpr operator t_enum_type() const { return v; }
    };
    template<class t_enum_type>
    struct eint01
    {
        static_assert(std::is_enum_v<t_enum_type>);
        t_enum_type v;
        constexpr eint01(t_enum_type e)
            : v(e)
        {
        }
        constexpr operator uint01() const { return static_cast<uint01>(static_cast<std::underlying_type_t<t_enum_type>>(v)); }
        constexpr operator t_enum_type() const { return v; }
    };
    typedef wchar_t wchar;

    enum DimensionValues : uint01
    {
          X = 0
        , A = 0
        , Y = 1
        , B = 1
        , Z = 2
        , C = 2
        , W = 3
        , D = 3
    };

    enum GeodeticValues : uint01
    {
        LAT = 0,
        LON = 1,
        ALT = 2
    };

 
    enum LocationValues : uint01
    {
          MIN = 0
        , MAX = 1
    };

    enum IntersectionTypes
    {
          e_outside = 0//Outside means completely outside the other shape, not touching the boundary.
        , e_inside//Entirely inside (but may touch the boundary) of the shape.
        , e_mixed//The shape is neither completely inside or outside the shape. 
    };

    enum InterpolationValues
    {
          e_nearest_neighbor
        , e_linear
        , e_bicubic
    };

    template<class t_type>
    struct Constant
    {
        static const t_type Invalid; //The reserved Invalid value of the object, typically 0xFF...
        static const t_type Min; //The minimum value the object type can take on.
        static const t_type Max; //The maximum value the object type can take on.
    };
    
    template<> constexpr const bool Constant<bool>::Invalid = false;
    template<> constexpr const bool Constant<bool>::Max = true;
    template<> constexpr const bool Constant<bool>::Min = false;
 
    template<> constexpr const sint01 Constant<sint01>::Invalid = -128;
    template<> constexpr const sint01 Constant<sint01>::Max =  127;
    template<> constexpr const sint01 Constant<sint01>::Min = -127;
 
    template<> constexpr const uint01 Constant<uint01>::Invalid = 255;
    template<> constexpr const uint01 Constant<uint01>::Max = 254;
    template<> constexpr const uint01 Constant<uint01>::Min = 0;
 
    template<> constexpr const sint02 Constant<sint02>::Invalid = -32768;
    template<> constexpr const sint02 Constant<sint02>::Max =  32767;
    template<> constexpr const sint02 Constant<sint02>::Min = -32767;
 
    template<> constexpr const uint02 Constant<uint02>::Invalid = 65535;
    template<> constexpr const uint02 Constant<uint02>::Max = 65534;
    template<> constexpr const uint02 Constant<uint02>::Min = 0;
 
    template<> constexpr const sint04 Constant<sint04>::Invalid = 0x80000000;
    template<> constexpr const sint04 Constant<sint04>::Max =  2147483647;
    template<> constexpr const sint04 Constant<sint04>::Min = -2147483647;
 
    template<> constexpr const uint04 Constant<uint04>::Invalid = 4294967295UL;
    template<> constexpr const uint04 Constant<uint04>::Max = 4294967294UL;
    template<> constexpr const uint04 Constant<uint04>::Min = 0;
 
    template<> constexpr const sint08 Constant<sint08>::Invalid = 0x8000000000000000;
    template<> constexpr const sint08 Constant<sint08>::Max =  9223372036854775807LL;
    template<> constexpr const sint08 Constant<sint08>::Min = -9223372036854775807LL;
 
    template<> constexpr const uint08 Constant<uint08>::Invalid = 18446744073709551615ULL;
    template<> constexpr const uint08 Constant<uint08>::Max = 18446744073709551614ULL;
    template<> constexpr const uint08 Constant<uint08>::Min = 0;
 
    template<> constexpr const fltp04 Constant<fltp04>::Invalid = std::numeric_limits<fltp04>::quiet_NaN();
    template<> constexpr const fltp04 Constant<fltp04>::Max = std::numeric_limits<fltp04>::infinity();
    template<> constexpr const fltp04 Constant<fltp04>::Min = -std::numeric_limits<fltp04>::infinity();
 
    template<> constexpr const fltp08 Constant<fltp08>::Invalid = std::numeric_limits<fltp08>::quiet_NaN();
    template<> constexpr const fltp08 Constant<fltp08>::Max = std::numeric_limits<fltp08>::infinity();
    template<> constexpr const fltp08 Constant<fltp08>::Min = -std::numeric_limits<fltp08>::infinity();
    
    template<class t_to, class t_from>
    constexpr t_to cast(t_from value)
    {
        return static_cast<t_to>(value);
    }

    template<>
    constexpr uint04 cast(fltp04 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }

    template<>
    constexpr uint04 cast(fltp08 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }

    template<>
    constexpr uint04 cast(sint04 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }

    template<>
    constexpr uint04 cast(sint08 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }

    template<class t_to, class t_from>
    constexpr t_to& rcast(t_from& value)
    {
        static_assert(sizeof(t_to) <= sizeof(t_from), "Bad rcast conversion");
        return *((t_to*)(&value));
    }
    template<class t_to, class t_from>
    constexpr const t_to& rcast(const t_from& value)
    {
        static_assert(sizeof(t_to) <= sizeof(t_from), "Bad rcast conversion");
        return *((const t_to*)(&value));
    }
    #define UNUSED(expr) do { (void)(expr); } while (0)
 
 
    static_assert(sizeof(bool) == 1, "Bad bool size");
    static_assert(sizeof(char) == 1, "Bad char size");
    //static_assert(sizeof(wchar) == 4, "Bad bool size");
    static_assert(sizeof(float) == 4, "Bad float size");
    static_assert(sizeof(double) == 8, "Bad double size");
 
    static_assert(sizeof(fltp04) == 4, "Bad fltp04 size");
    static_assert(sizeof(fltp08) == 8, "Bad fltp08 size");
 
    static_assert(sizeof(uint01) == 1, "Bad int size");
    static_assert(sizeof(uint02) == 2, "Bad int size");
    static_assert(sizeof(uint04) == 4, "Bad int size");
    static_assert(sizeof(uint08) == 8, "Bad int size");
 
    static_assert(sizeof(sint01) == 1, "Bad int size");
    static_assert(sizeof(sint02) == 2, "Bad int size");
    static_assert(sizeof(sint04) == 4, "Bad int size");
    static_assert(sizeof(sint08) == 8, "Bad int size");
};
 
#include "BaseFunctions.hpp"