StreetInfo.h

#pragma once
#include <NDEVR/Model.h>
namespace NDEVR
{
    class StreetName : public Model
    {
    public:
        StreetName(const Model& model)
            : Model(model)
        {
 
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }

        void setStreet(const String& type)
        {
            set<NDPO::uncompressed_data>(type);
        }

        StringView getStreet() const
        {
            return get<NDPO::uncompressed_data>();
        }

        static constexpr const char* ValidRegex() { return "*."; } // TODO
        static constexpr const char* TypeName() { return "street_name"; }
    };

    class SurfaceType : public Model
    {
    public:
        SurfaceType(const Model& model)
            : Model(model)
        {
 
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }

        void setSurface(const String& type)
        {
            set<NDPO::uncompressed_data>(type);
        }

        StringView getSurface() const
        {
            return get<StringView>(NDPO::uncompressed_data);
        }

        static constexpr const char* ValidRegex() { return "sad"; } // TODO
        static constexpr const char* TypeName() { return "surface_type"; }
    };

    class SurfaceCondition : public Model
    {
    public:
        SurfaceCondition(const Model& model)
            : Model(model)
        {
 
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }

        void setSurfaceCondition(const String& condition)
        {
            set(NDPO::uncompressed_data, condition);
        }

        StringView getSurfaceCondition() const
        {
            return get<StringView>(NDPO::uncompressed_data);
        }

        static constexpr const char* ValidRegex() { return "sad";/*TODO*/ }
        static constexpr const char* TypeName() { return "surface_condition"; }
 
    };

    class SpeedLimit : public Model
    {
    public:
        SpeedLimit(const Model& model)
            : Model(model)
        {
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                set<NDPN::type>(TypeName());
            }
        }

        void setSpeedLimit(const String& speed_limit)
        {
            set(NDPO::uncompressed_data, speed_limit);
        }

        StringView getSpeedLimit() const
        {
            return get<StringView>(NDPO::uncompressed_data);
        }

        static constexpr const char* TypeName() { return "speed_limit"; }
    };

    class StreetInfo : public Model
    {
    public:
        StreetInfo(const Model& model)
            : Model(model)
        {
            if (!is<NDPN::type>(TypeName()))
            {
                //setup model for first time
                createChildren(4);
                set<NDPN::type>(TypeName());
            }
        }

        StreetName streetName()
        {
            return StreetName(getChild(0));
        }

        SurfaceType surfaceType()
        {
            return SurfaceType(getChild(1));
        }

        SurfaceCondition surfaceCondition()
        {
            return SurfaceCondition(getChild(2));
        }

        SpeedLimit speedLimit()
        {
            return SpeedLimit(getChild(3));
        }

        static constexpr const char* TypeName() { return "street_info"; }
    };
}