Definitions.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2021.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// contact: delft3d.support@deltares.nl
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
 
#pragma once
 
#include <concepts>
#include <cstdint>
#include <map>
#include <string>
#include <vector>
 
namespace meshkernel
{
    using UInt = std::uint32_t;
 
    enum class Projection
    {
        cartesian = 0,        // jsferic  = 0
        spherical = 1,        // jsferic  = 1
        sphericalAccurate = 2 // jasfer3D = 1
    };
    enum class Projection {…};
 
    const std::vector<int>& GetValidProjections();
 
    const std::vector<int>& GetValidDeletionOptions();
 
    Projection GetProjectionValue(int projection);
 
    const std::string& ProjectionToString(Projection projection);
 
    // PolygonTraversalDirection? too long
    // PolygonOrientation
    enum class TraversalDirection
    {
        Clockwise,    
        AntiClockwise 
    };
    enum class TraversalDirection {…};
 
    enum class Location
    {
        Faces = 0,  
        Nodes = 1,  
        Edges = 2,  
        Unknown = 3 
    };
    enum class Location {…};
 
    inline static std::map<Location, std::string> const LocationToString = {
        {Location::Faces, "Faces"},
        {Location::Nodes, "Nodes"},
        {Location::Edges, "Edges"},
        {Location::Unknown, "Unknown"}};
 
    enum class CurvilinearDirection
    {
        M, 
        N  
    };
    enum class CurvilinearDirection {…};
 
    enum class InterpolationDataTypes
    {
        Short = 0,  
        Float = 1,  
        Int = 2,    
        Double = 3, 
    };
    enum class InterpolationDataTypes {…};
 
    CurvilinearDirection GetCurvilinearDirectionValue(int direction);
 
    const std::string& CurvilinearDirectionToString(CurvilinearDirection direction);
 
    class Boolean
    {
    public:
        Boolean() = default;
 
        Boolean(const bool val) : m_value(val) {}
 
        Boolean& operator=(const bool val)
        {
            m_value = val;
            return *this;
        }
        Boolean& operator=(const bool val) {…}
 
        operator bool() const { return m_value; }
 
    private:
        bool m_value = false;
    };
    class Boolean {…};
 
    enum class MeshNodeType : std::int8_t
    {
        Hanging = -1, 
        Unspecified,  
        Internal,     
        Boundary,     
        Corner        
    };
    enum class MeshNodeType : std::int8_t {…};
 
} // namespace meshkernel