parameters.h

// Copyright Maciej Sobczak 2008-2022.
// This file is part of YAMI4.
// See the package-level LICENSE.txt file.
 
#ifndef YAMICPP_PARAMETERS_H_INCLUDED
#define YAMICPP_PARAMETERS_H_INCLUDED
 
#include "parameter_entry.h"
#include "parameter_type.h"
#include "serializable.h"
#include <yami4-core/dll.h>
#include <yami4-core/parameter_iterator.h>
#include <memory>
#include <ostream>
#include <string>
 
namespace yami
{
 
namespace core
{
class parameters;
} // namespace core
 
class DLL parameters : public serializable
{
public:
    parameters();
 
    explicit parameters(core::parameters * external);
 
    parameters(const parameters & other);
 
    void operator=(const parameters & other);
 
    void swap(parameters & other);
 
    ~parameters() {}
 
    // single-value operations
 
    void set_boolean(const std::string & name, bool value);
    void set_boolean(const char * name, bool value);
 
    bool get_boolean(const std::string & name) const;
    bool get_boolean(const char * name) const;
 
    void set_integer(const std::string & name, int value);
    void set_integer(const char * name, int value);
 
    int get_integer(const std::string & name) const;
    int get_integer(const char * name) const;
 
    void set_long_long(const std::string & name, long long value);
    void set_long_long(const char * name, long long value);
 
    long long get_long_long(const std::string & name) const;
    long long get_long_long(const char * name) const;
 
    void set_word(const std::string & name, unsigned int value);
    void set_word(const char * name, unsigned int value);
 
    unsigned int get_word(const std::string & name) const;
    unsigned int get_word(const char * name) const;
 
    void set_long_long_word(const std::string & name, unsigned long long value);
    void set_long_long_word(const char * name, unsigned long long value);
 
    unsigned long long get_long_long_word(const std::string & name) const;
    unsigned long long get_long_long_word(const char * name) const;
 
    void set_double_float(const std::string & name, double value);
    void set_double_float(const char * name, double value);
 
    double get_double_float(const std::string & name) const;
    double get_double_float(const char * name) const;
 
    void set_string(const std::string & name, const std::string & value);
    void set_string(const char * name, const char * value);
 
    void set_string_shallow(const std::string & name,
        const char * value, std::size_t value_length);
    void set_string_shallow(const char * name, std::size_t name_length,
        const char * value, std::size_t value_length);
 
    std::string get_string(const std::string & name) const;
    std::string get_string(const char * name) const;
 
    const char * get_string(const std::string & name,
        std::size_t & length) const;
    const char * get_string(const char * name,
        std::size_t & length) const;
 
    void set_binary(const std::string & name,
        const void * value, std::size_t value_length);
    void set_binary(const char * name,
        const void * value, std::size_t value_length);
 
    void set_binary_shallow(const std::string & name,
        const void * value, std::size_t value_length);
    void set_binary_shallow(const char * name, std::size_t name_length,
        const void * value, std::size_t value_length);
 
    const void * get_binary(const std::string & name,
        std::size_t & length) const;
    const void * get_binary(const char * name,
        std::size_t & length) const;
 
    // array operations
 
    void set_boolean_array(const std::string & name,
        const bool * values, std::size_t array_length);
    void set_boolean_array(const char * name,
        const bool * values, std::size_t array_length);
 
    void set_boolean_array_shallow(const std::string & name,
        const bool * values, std::size_t array_length);
    void set_boolean_array_shallow(const char * name,
        const bool * values, std::size_t array_length);
 
    bool * get_boolean_array(const std::string & name,
        std::size_t & array_length) const;
    bool * get_boolean_array(const char * name,
        std::size_t & array_length) const;
 
    void set_integer_array(const std::string & name,
        const int * values, std::size_t array_length);
    void set_integer_array(const char * name,
        const int * values, std::size_t array_length);
 
    void set_integer_array_shallow(const std::string & name,
        const int * values, std::size_t array_length);
    void set_integer_array_shallow(const char * name,
        const int * values, std::size_t array_length);
 
    int * get_integer_array(const std::string & name,
        std::size_t & array_length) const;
    int * get_integer_array(const char * name,
        std::size_t & array_length) const;
 
    void set_long_long_array(const std::string & name,
        const long long * values, std::size_t array_length);
    void set_long_long_array(const char * name,
        const long long * values, std::size_t array_length);
 
    void set_long_long_array_shallow(const std::string & name,
        const long long * values, std::size_t array_length);
    void set_long_long_array_shallow(const char * name,
        const long long * values, std::size_t array_length);
 
    long long * get_long_long_array(const std::string & name,
        std::size_t & array_length) const;
    long long * get_long_long_array(const char * name,
        std::size_t & array_length) const;
 
    void set_word_array(const std::string & name,
        const unsigned int * values, std::size_t array_length);
    void set_word_array(const char * name,
        const unsigned int * values, std::size_t array_length);
 
    void set_word_array_shallow(const std::string & name,
        const unsigned int * values, std::size_t array_length);
    void set_word_array_shallow(const char * name,
        const unsigned int * values, std::size_t array_length);
 
    unsigned int * get_word_array(const std::string & name,
        std::size_t & array_length) const;
    unsigned int * get_word_array(const char * name,
        std::size_t & array_length) const;
 
    void set_long_long_word_array(const std::string & name,
        const unsigned long long * values, std::size_t array_length);
    void set_long_long_word_array(const char * name,
        const unsigned long long * values, std::size_t array_length);
 
    void set_long_long_word_array_shallow(const std::string & name,
        const unsigned long long * values, std::size_t array_length);
    void set_long_long_word_array_shallow(const char * name,
        const unsigned long long * values, std::size_t array_length);
 
    unsigned long long * get_long_long_word_array(const std::string & name,
        std::size_t & array_length) const;
    unsigned long long * get_long_long_word_array(const char * name,
        std::size_t & array_length) const;
 
    void set_double_float_array(const std::string & name,
        const double * values, std::size_t array_length);
    void set_double_float_array(const char * name,
        const double * values, std::size_t array_length);
 
    void set_double_float_array_shallow(const std::string & name,
        const double * values, std::size_t array_length);
    void set_double_float_array_shallow(const char * name,
        const double * values, std::size_t array_length);
 
    double * get_double_float_array(const std::string & name,
        std::size_t & array_length) const;
    double * get_double_float_array(const char * name,
        std::size_t & array_length) const;
 
    void create_string_array(const std::string & name,
        std::size_t array_length);
    void create_string_array(const char * name, std::size_t array_length);
 
    void set_string_in_array(const std::string & name, std::size_t index,
        const std::string & value);
    void set_string_in_array(const char * name, std::size_t index,
        const char * value);
 
    std::size_t get_string_array_length(const std::string & name) const;
    std::size_t get_string_array_length(const char * name) const;
 
    std::string get_string_in_array(const std::string & name,
        std::size_t index) const;
    std::string get_string_in_array(const char * name,
        std::size_t index) const;
 
    const char * get_string_in_array(const std::string & name,
        std::size_t index, std::size_t & length) const;
    const char * get_string_in_array(const char * name,
        std::size_t index, std::size_t & length) const;
 
    void create_binary_array(const std::string & name,
        std::size_t array_length);
    void create_binary_array(const char * name, std::size_t array_length);
 
    void set_binary_in_array(const std::string & name, std::size_t index,
        const void * value, std::size_t value_length);
    void set_binary_in_array(const char * name, std::size_t index,
        const void * value, std::size_t value_length);
 
    std::size_t get_binary_array_length(const std::string & name) const;
    std::size_t get_binary_array_length(const char * name) const;
 
    const void * get_binary_in_array(const std::string & name,
        std::size_t index, std::size_t & length) const;
    const void * get_binary_in_array(const char * name,
        std::size_t index, std::size_t & length) const;
 
    // support for data nesting
 
    core::parameters * create_nested_parameters(const std::string & name);
    core::parameters * create_nested_parameters(const char * name);
 
    core::parameters * get_nested_parameters(const std::string & name) const;
    core::parameters * get_nested_parameters(const char * name) const;
 
    void create_nested_array(const std::string & name,
        std::size_t array_length);
    void create_nested_array(const char * name, std::size_t array_length);
 
    std::size_t get_nested_array_length(const std::string & name) const;
    std::size_t get_nested_array_length(const char * name) const;
 
    core::parameters * get_nested_in_array(const std::string & name,
        std::size_t index) const;
    core::parameters * get_nested_in_array(const char * name,
        std::size_t index) const;
 
    // inspection
 
    std::size_t size() const;
 
    parameter_type type(const std::string & name) const;
    parameter_type type(const char * name) const;
 
    class iterator
    {
    public:
        iterator() : empty_(true), it_() {}
        iterator(core::parameter_iterator it) : empty_(false), it_(it) {}
 
        bool operator==(const iterator & rhs) const
        {
            // this is enough for the input iterator,
            // because the user cannot legally have two iterators
            // in the middle of the collection and therefore the comparison
            // can be used only to check for the end-of-sequence condition
            return empty_ && rhs.empty_;
        }
 
        bool operator!=(const iterator & rhs) const
        {
            return operator==(rhs) == false;
        }
 
        iterator & operator++()
        {
            if (it_.has_next())
            {
                it_.move_next();
            }
            else
            {
                empty_ = true;
            }
 
            return *this;
        }
 
        iterator operator++(int)
        {
            iterator old(*this);
            operator++();
            return old;
        }
 
        parameter_entry operator*() const
        {
            parameter_entry entry;
            entry.entry_ = it_.current();
            return entry;
        }
 
    private:
        friend class parameters;
        bool empty_;
        core::parameter_iterator it_;
    };
 
    iterator begin() const;
 
    iterator end() const;
 
    bool find(const std::string & name, parameter_entry & entry) const;
    bool find(const char * name, parameter_entry & entry) const;
 
    // cleanup
 
    void remove(const std::string & name);
    void remove(const char * name);
 
    void remove(iterator it);
 
    void merge_from(const parameters & other);
 
    void clear();
 
    // serialization
 
    virtual std::size_t serialize_buffer_size() const;
 
    virtual void serialize(char * * buffers, std::size_t * buffer_sizes,
        std::size_t num_of_buffers) const;
 
    void deserialize(const char * * buffers, std::size_t * buffer_sizes,
        std::size_t num_of_buffers);
 
    virtual const core::parameters & get_core_object() const;
 
    // used from unit tests
    void dump(std::ostream & os) const;
 
private:
 
    // values that are owned and controlled by this object
    std::unique_ptr<core::parameters> own_params_;
 
    // delegated object (not necessarily own_params_, can be external)
    // note: it is not owned
    core::parameters * params_;
};
 
} // namespace yami
 
#endif // YAMICPP_PARAMETERS_H_INCLUDED