InMemoryParameter.h

Go to the documentation of this file.

#pragma once

#include <swarmio/services/keyvalue/Target.h>
#include <swarmio/data/Variant.pb.h>
#include <swarmio/data/discovery/Schema.pb.h>

namespace swarmio::simulator 
{
    class InMemoryParameter final : public services::keyvalue::Target
    {
        private:

            data::Variant _value;

            data::discovery::Type _type;

            bool _readOnly;

            std::string _path;

        public:
            
            InMemoryParameter(const std::string& path, bool value, bool readOnly = false)
                : _readOnly(readOnly), _path(path)
            {
                _type = data::discovery::Type::BOOL;
                _value.set_bool_value(value);
            }

            InMemoryParameter(const std::string& path, const std::string& value, bool readOnly = false)
                : _readOnly(readOnly), _path(path)
            {
                _type = data::discovery::Type::STRING;
                _value.set_string_value(value);
            }

            InMemoryParameter(const std::string& path, const char* value, bool readOnly = false)
                : _readOnly(readOnly), _path(path)
            {
                _type = data::discovery::Type::STRING;
                _value.set_string_value(value);
            }

            InMemoryParameter(const std::string& path, int value, bool readOnly = false)
                : _readOnly(readOnly), _path(path)
            {
                _type = data::discovery::Type::INT;
                _value.set_int_value(value);
            }

            InMemoryParameter(const std::string& path, double value, bool readOnly = false)
                : _readOnly(readOnly), _path(path)
            {
                _type = data::discovery::Type::DOUBLE;
                _value.set_double_value(value);
            }

            virtual data::Variant Get(const std::string& path) override
            {
                if (path == _path)
                {
                    return _value;
                }
                else
                {
                    throw Exception("In memory parameter queried for unknown resource path.");
                }
            }

            virtual void Set(const std::string& path, const data::Variant& value) override
            {
                if (path == _path)
                {    
                    if (_readOnly)
                    {
                        throw Exception("Parameter is read-only.");
                    }                   
                    else
                    {
                        switch (value.value_case())
                        {
                            case data::Variant::ValueCase::kBoolValue:
                                if (_type == data::discovery::Type::BOOL)
                                {
                                    _value = value;
                                }
                                else
                                {
                                    throw Exception("Invalid type for parameter.");
                                }
                                break;

                            case data::Variant::ValueCase::kDoubleValue:
                                if (_type == data::discovery::Type::DOUBLE)
                                {
                                    _value = value;
                                }
                                else
                                {
                                    throw Exception("Invalid type for parameter.");
                                }
                                break;

                            case data::Variant::ValueCase::kIntValue:
                                if (_type == data::discovery::Type::INT)
                                {
                                    _value = value;
                                }
                                else
                                {
                                    throw Exception("Invalid type for parameter.");
                                }
                                break;

                            case data::Variant::ValueCase::kStringValue:
                                if (_type == data::discovery::Type::STRING)
                                {
                                    _value = value;
                                }
                                else
                                {
                                    throw Exception("Invalid type for parameter.");
                                }
                                break;

                            default:
                                throw Exception("Unknown type for parameter.");
                        }  
                    }
                    
                }
                else
                {
                    throw Exception("In memory parameter queried for unknown resource path.");
                }
            }

            virtual data::discovery::Field GetFieldDescriptor(const std::string& path) const override
            {
                if (path == _path)
                {    
                    data::discovery::Field field;
                    field.set_type(_type);
                    return field;
                }
                else
                {
                    throw Exception("In memory parameter queried for unknown resource path.");
                }
            }

            virtual bool CanWrite(const std::string& path) const noexcept override
            {
                if (path == _path)
                {    
                    return !_readOnly;  
                }
                else
                {
                    return false;
                }
            }

            virtual bool CanRead(const std::string& path) const noexcept override
            {
                if (path == _path)
                {    
                    return true;
                }
                else
                {
                    return false;
                }
            }

            const std::string& GetPath() const
            {
                return _path;
            }
    };
}