BaseValues.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Dummy class to ensure creation of an include file around core root values
 
    **/
    class BaseValues
    {};
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing a 1 byte, signed integer. 
    -Can represent exact integer values -127 through 127.
    -Byte value 0XFF (integer value: -128) is considered invalid and reserved.
    **/
    typedef int8_t sint01;
 
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing a 2 byte, signed integer.
    -Can represent exact integer values -32767 through 32767.
    -Byte value 0XFFFF (integer value: -32768) is considered invalid and reserved.
    **/
    typedef int16_t sint02;
 
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing a 4 byte, signed integer.
    -Can represent exact integer values -2147483647 through 2147483647.
    -Byte value 0XFFFFFFFF (integer value: -2147483648) is considered invalid and reserved.
    **/
    typedef int32_t sint04;
 
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing an 8 byte, signed integer
    -Can represent exact integer values -9223372036854775807 through 9223372036854775807.
    -Byte value 0XFFFFFFFFFFFFFFFF (integer value: -9223372036854775808) is considered invalid and reserved.
    **/
    typedef int64_t sint08;
 
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing a 1 byte, unsigned integer
    -Can represent exact integer values 0 through 254.
    -Byte value 0XFF (integer value: 255) is considered invalid and should normally be reserved. Note that
    it can be used with caution.
    -Note that subtracting 1 from 0 will result in 0xFF, the reserved invalid value. 
    **/
    typedef uint8_t uint01;
 
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing a 2 byte, unsigned integer
    -Can represent exact integer values 0 through 65534.
    -Byte value 0xFFFF (integer value: 65535) is considered invalid and reserved.
    -Note that subtracting 1 from 0 will result in 0xFFFF, the reserved invalid value.
    **/
    typedef uint16_t uint02;
 
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing a 4 byte, unsigned integer
    -Can represent exact integer values 0 through 4294967294.
    -Byte value 0xFFFFFFFF (integer value: 4294967295) is considered invalid and reserved.
    -Note that subtracting 1 from 0 will result in 0xFFFFFFFF, the reserved invalid value.
    **/
    typedef uint32_t uint04;
 
    /**--------------------------------------------------------------------------------------------------
    \brief -Defines an alias representing an 8 byte, unsigned integer
    
    -Can represent exact integer values 0 through 18446744073709551614.
    -Byte value 0XFFFFFFFFFFFFFFFF (integer value: 18446744073709551615) is considered invalid and 
     reserved.
    -Note that subtracting 1 from 0 will result in 0XFFFFFFFFFFFFFFFF, the reserved invalid value.
    **/
    typedef uint64_t uint08;
 
    /**--------------------------------------------------------------------------------------------------
    \brief Defines an alias representing a 4 byte floating-point number
    Bit layout is as follows: 
        -Sign: 1 bit at position 31 determines whether or not the value is positive or negative.
         0 denotes a positive number, and 1 denotes a negative number
        -Exponent: 8 bits stored in position 30–23 The exponent field needs to represent both positive 
         and negative exponents. To do this, a bias is added to the actual exponent in order to get 
         the stored exponent. This value is 127. 
         Thus, an exponent of zero means that 127 is stored in the exponent field.
         A stored value of 200 indicates an exponent of (200–127), or 73. For reasons 
         exponents of −127 (all 0s) and +128 (all 1s) are reserved for special numbers.
        -Fraction: 23 bits stored in positions 22–00. The mantissa, also known as the significand, 
         represents the precision bits of the number.  It is composed of an implicit leading bit 
         (left of the radix point) and the fraction bits (to the right of the radix point).
    Note that positive and negative infinity are reserved as max and min. However precision changes
        for large and small numbers. Precision is greatest around 0.
    \warning Note that Invalid is reserved as invalid values. Using == will not work for these values.
 
    **/
    typedef float fltp04;
 
    /**--------------------------------------------------------------------------------------------------
    \brief Defines an alias representing an 8 byte floating-point number.
 
    Bit layout is as follows: 
        -Sign: 1 bit at position 63 determines whether or not the value is positive or negative.
         0 denotes a positive number, and 1 denotes a negative number
        -Exponent: 11 bits stored in position 62–52. The exponent field needs to represent both positive 
         and negative exponents. To do this, a bias is added to the actual exponent in order to get 
         the stored exponent. This value is 1023. 
         Thus, an exponent of zero means that 1023 is stored in the exponent field.
         A stored value of 200 indicates an exponent of (200–1023), or -823. For reasons 
         exponents of all 0s and all 1s are reserved for special numbers.
        -Fraction: 52 bits stored in positions 51–00. The mantissa, also known as the significand, 
         represents the precision bits of the number.  It is composed of an implicit leading bit 
         (left of the radix point) and the fraction bits (to the right of the radix point).
    Note that positive and negative infinity are reserved as max and min. However precision changes
        for large and small numbers. Precision is greatest around 0.
    \warning Note that Invalid is reserved as invalid values. Using == will not work for these values.
 
    **/
    typedef double fltp08;
 
    /**--------------------------------------------------------------------------------------------------
    \brief Allias for wchar_t, a value that represents a character of two bytes in size.
 
    **/
    typedef wchar_t wchar;
 
    /**--------------------------------------------------------------------------------------------------
    \brief Values that represent dimension values. 
 
    Note these are used throughout the code to make things more readable. For example, for a vertex
        we can access it via vertex[Z] instead of vertex[2] which overall contributes to total readability.
    Typically for shapes (Triangles, LineSegments, etc) we access the nodes via A, B, C. triangle.vertex(A)
        for example. For points we typically use X, Y, Z triangle.vertex(A)[X] = triangle.vertex(B)[X]
    **/
    enum DimensionValues : uint01
    {
          X = 0
        , A = 0
        , Y = 1
        , B = 1
        , Z = 2
        , C = 2
        , W = 3
        , D = 3
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Values that represent dimension values for geodic dimensions.
    Represents latitude, longitude, and altitude.
    **/
    enum GeodeticValues : uint01
    {
        LAT = 0,
        LON = 1,
        ALT = 2
    };
    /**--------------------------------------------------------------------------------------------------
 
    \brief Values that represent location values.
    
    Note these are used throughout the code to make things more readable as above. For example, for example
         in point pairs with a max and a min, or in a bounds object.
    **/
 
    enum LocationValues : uint01
    {
          MIN = 0
        , MAX = 1
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Used for classifying shape intersections. 
 
    Values include:
        - Outside means completely outside the other shape, not touching the boundary.
        - Inside means entirely inside (but may touch the boundary) of the shape.
        - Mixed means the shape is neither completely inside or outside the shape. 
    These values are used heavily in the intersection class.
    **/
    enum IntersectionTypes
    {
          outside = 0//Outside means completely outside the other shape, not touching the boundary.
        , inside//Entirely inside (but may touch the boundary) of the shape.
        , mixed//The shape is neither completely inside or outside the shape. 
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Values that represent interpolation functions. Useful in large or complicated geological or time
        based data sets.
    **/
    enum InterpolationValues
    {
          nearest_neighbor
        , e_linear
        , bicubic
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Defines for a given type (such as sint04, fltp08, UUID, etc) a maximum, minimum, and reserved
        'invalid' value.
    **/
    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();
    
    /**
    \brief Casts the given value. Is equivalent to static_cast except allows for the option of special cases by
        specializing the template
    
    static_cast is used for cases where you want to reverse an implicit conversion, with a few restrictions 
        and additions.
 
    cast performs no runtime checks.
    
    This should be used if you know that you refer to an object of a specific type,
        and thus a check would be unnecessary.
 
    \param[in] value -  The value to cast.
    \return The value cast to the specified type.
    **/
    template<class t_to, class t_from>
    constexpr t_to cast(t_from value)
    {
        return static_cast<t_to>(value);
    }
 
    /**
    \brief Casts the given value. Is equivalent to static_cast except allows for the option of special cases by
        specializing the template
 
    static_cast is used for cases where you want to reverse an implicit conversion, with a few restrictions
        and additions.
 
    In debug mode, cast performs runtime check to ensure value is positve prior to casting
 
    This should be used if you know that you refer to an object of a specific type,
        and thus a check would be unnecessary.
 
    \param[in] value - The value to cast.
    \return The value cast to the usigned.
    **/
    template<>
    constexpr uint04 cast(fltp04 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    /**
    \brief Casts the given value. Is equivalent to static_cast except allows for the option of special cases by
        specializing the template
 
    static_cast is used for cases where you want to reverse an implicit conversion, with a few restrictions
        and additions.
 
    In debug mode, cast performs runtime check to ensure value is positve prior to casting
 
    This should be used if you know that you refer to an object of a specific type,
        and thus a check would be unnecessary.
 
    \param[in] value - The value to cast.
    \return The value cast to the usigned.
    **/
    template<>
    constexpr uint04 cast(fltp08 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    /**
    \brief Casts the given value. Is equivalent to static_cast except allows for the option of special cases by
        specializing the template
 
    static_cast is used for cases where you want to reverse an implicit conversion, with a few restrictions
        and additions.
 
    In debug mode, cast performs runtime check to ensure value is positve prior to casting
 
    This should be used if you know that you refer to an object of a specific type,
        and thus a check would be unnecessary.
 
    \param[in] value - The value to cast.
    \return The value cast to the usigned.
    **/
    template<>
    constexpr uint04 cast(sint04 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    /**
    \brief Casts the given value. Is equivalent to static_cast except allows for the option of special cases by
        specializing the template
 
    static_cast is used for cases where you want to reverse an implicit conversion, with a few restrictions
        and additions.
 
    In debug mode, cast performs runtime check to ensure value is positve prior to casting
 
    This should be used if you know that you refer to an object of a specific type,
        and thus a check would be unnecessary.
 
    \param[in] value - The value to cast.
    \return The value cast to the usigned.
    **/
    template<>
    constexpr uint04 cast(sint08 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    /**
    \brief Casts the given value. Is equivalent to reinterpret_cast except allows for the option of special cases by
        specializing the template
    
    Allows any pointer to be converted into any other pointer type. Also allows any integral type to be
    converted into any pointer type and vice versa.
 
    Author: Tyler Parke
 
    Date: 2017-09-04
 
    \param[in] value -  The value to cast.
    \return The value cast to the specified type.
    **/
    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));
    }
 
    #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"