properties.h

Go to the documentation of this file.

// Copyright (c) 2018, Smart Projects Holdings Ltd
// All rights reserved.
// See LICENSE file for license details.

#ifndef _UGCS_VSM_PROPERTIES_H_
#define _UGCS_VSM_PROPERTIES_H_

#include <ugcs/vsm/exception.h>
#include <ugcs/vsm/singleton.h>

#include <istream>
#include <map>

namespace ugcs {
namespace vsm {

class Properties {
public:
    typedef std::shared_ptr<Properties> Ptr;

    VSM_DEFINE_EXCEPTION(Exception);
    VSM_DEFINE_DERIVED_EXCEPTION(Exception, Parse_exception);
    VSM_DEFINE_DERIVED_EXCEPTION(Exception, Not_found_exception);
    VSM_DEFINE_DERIVED_EXCEPTION(Exception, Not_convertible_exception);

    template <typename... Args>
    static Ptr
    Get_instance(Args &&... args)
    {
        return singleton.Get_instance(std::forward<Args>(args)...);
    }

    Properties();

    void
    Load(std::istream &stream);

    bool
    Exists(const std::string &key) const;

    std::string
    Get(const std::string &key) const;

    int32_t
    Get_int(const std::string &key) const;

    double
    Get_float(const std::string &key) const;

    void
    Set_description(const std::string &key, const std::string &description);

    void
    Set(const std::string &key, const std::string &value);

    void
    Set(const std::string &key, int32_t value);

    void
    Set(const std::string &key, double value);

    void
    Delete(const std::string &key);

    void
    Store(std::ostream &stream);

private:
    class Property {
    public:
        std::string str_repr;
        int32_t int_repr;
        double float_repr;
        bool int_valid:1,
             float_valid:1;
        std::string description;
        int seq_number = -1;

        Property(std::string &&value);

        Property(int32_t value);

        Property(double value);
    };

    typedef std::map<std::string, Property> Table_type;

    Table_type table;

public:
    class Iterator {
    public:
        Iterator(const Table_type::const_iterator &iterator,
                 const Table_type::const_iterator &end_iterator,
                 const std::string &prefix = std::string(),
                 char separator = '.'):
             table_iterator(iterator),
             table_end(end_iterator),
             prefix(prefix),
             separator(separator)
        {
            _NextProp();
        }

        std::string
        operator *() const
        {
            if (table_iterator == table_end) {
                VSM_EXCEPTION(ugcs::vsm::Internal_error_exception,
                              "Dereferencing end iterator");
            }
            return table_iterator->first;
        }

        const std::string *
        operator->() const
        {
            if (table_iterator == table_end) {
                VSM_EXCEPTION(ugcs::vsm::Internal_error_exception,
                              "Dereferencing end iterator");
            }
            return &table_iterator->first;
        }

        bool
        operator ==(const Iterator &it) const
        {
            return table_iterator == it.table_iterator;
        }

        bool
        operator !=(const Iterator &it) const
        {
            return !(*this == it);
        }

        void
        operator++();

        void
        operator++(int)
        {
            ++(*this);
        }

        std::string
        operator[](size_t comp_idx);

        int
        Get_count();

    private:
        Table_type::const_iterator table_iterator, table_end;
        std::string prefix;
        char separator;

        void
        _NextProp();
    };

    Iterator
    begin(const std::string &prefix = std::string(), char separator = '.') const
    {
        return Iterator(table.begin(), table.end(), prefix, separator);
    }

    Iterator
    end() const
    {
        return Iterator(table.end(), table.end());
    }

private:
    static Singleton<Properties> singleton;

    int last_sequence_number = 0;

    std::string trailer;

    const Property &
    Find_property(const std::string &key) const;

    Property *
    Find_property(const std::string &key);

    static std::string
    Escape(const std::string &str, bool is_key = false);
};

} /* namespace vsm */
} /* namespace ugcs */

#endif /* _UGCS_VSM_PROPERTIES_H_ */