parameters.h

// Copyright Maciej Sobczak 2008-2022.
// This file is part of YAMI4.
// See the package-level LICENSE.txt file.
 
#ifndef YAMICORE_PARAMETERS_H_INCLUDED
#define YAMICORE_PARAMETERS_H_INCLUDED
 
#include "allocator.h"
#include "core.h"
#include "dll.h"
#include "parameter_type.h"
#include "serializable.h"
 
namespace yami
{
 
namespace details
{
struct entry;
 
// for unit tests, to avoid dependency on IOStreams from core
class dump_sink
{
public:
    virtual ~dump_sink() {}
 
    virtual void indent(std::size_t spaces) = 0;
    virtual void dump(bool v) = 0;
    virtual void dump(int v) = 0;
    virtual void dump(long long v) = 0;
    virtual void dump(unsigned int v) = 0;
    virtual void dump(unsigned long long v) = 0;
    virtual void dump(double v) = 0;
    virtual void dump(const char * str) = 0;
    virtual void dump(const char * str, std::size_t str_len) = 0;
};
 
} // namespace details
 
namespace core
{
 
class parameter_entry;
class parameter_iterator;
 
class DLL parameters : public serializable
{
public:
    explicit parameters();
 
    explicit parameters(allocator & alloc);
 
    ~parameters();
 
    // single-value operations
 
    result set_boolean(const char * name, std::size_t name_length,
        bool value);
 
    result set_boolean(const char * name, bool value);
 
    result get_boolean(const char * name, std::size_t name_length,
        bool & value) const;
 
    result get_boolean(const char * name, bool & value) const;
 
    result set_integer(const char * name, std::size_t name_length, int value);
 
    result set_integer(const char * name, int value);
 
    result get_integer(const char * name, std::size_t name_length,
        int & value) const;
 
    result get_integer(const char * name, int & value) const;
 
    result set_long_long(const char * name, std::size_t name_length,
        long long value);
 
    result set_long_long(const char * name, long long value);
 
    result get_long_long(const char * name, std::size_t name_length,
        long long & value) const;
 
    result get_long_long(const char * name, long long & value) const;
 
    result set_word(const char * name, std::size_t name_length, unsigned int value);
 
    result set_word(const char * name, unsigned int value);
 
    result get_word(const char * name, std::size_t name_length,
        unsigned int & value) const;
 
    result get_word(const char * name, unsigned int & value) const;
 
    result set_long_long_word(const char * name, std::size_t name_length,
        unsigned long long value);
 
    result set_long_long_word(const char * name, unsigned long long value);
 
    result get_long_long_word(const char * name, std::size_t name_length,
        unsigned long long & value) const;
 
    result get_long_long_word(const char * name, unsigned long long & value) const;
 
    result set_double_float(const char * name, std::size_t name_length,
        double value);
 
    result set_double_float(const char * name, double value);
 
    result get_double_float(const char * name, std::size_t name_length,
        double & value) const;
 
    result get_double_float(const char * name, double & value) const;
 
    result set_string(const char * name, std::size_t name_length,
        const char * value, std::size_t value_length);
 
    result set_string(const char * name, const char * value);
 
    result set_string_shallow(const char * name, std::size_t name_length,
        const char * value, std::size_t value_length);
 
    result set_string_shallow(const char * name, const char * value);
 
    result get_string(const char * name, std::size_t name_length,
        const char * & value, std::size_t & value_length) const;
 
    result get_string(const char * name,
        const char * & value, std::size_t & value_length) const;
 
    result set_binary(const char * name, std::size_t name_length,
        const void * value, std::size_t value_length);
 
    result set_binary(const char * name,
        const void * value, std::size_t value_length);
 
    result set_binary_shallow(const char * name, std::size_t name_length,
        const void * value, std::size_t value_length);
 
    result set_binary_shallow(const char * name,
        const void * value, std::size_t value_length);
 
    result get_binary(const char * name, std::size_t name_length,
        const void * & value, std::size_t & value_length) const;
 
    result get_binary(const char * name,
        const void * & value, std::size_t & value_length) const;
 
    // array operations
 
    result set_boolean_array(const char * name, std::size_t name_length,
        const bool * values, std::size_t array_length);
 
    result set_boolean_array(const char * name,
        const bool * values, std::size_t array_length);
 
    result set_boolean_array_shallow(
        const char * name, std::size_t name_length,
        const bool * values, std::size_t array_length);
 
    result set_boolean_array_shallow(const char * name,
        const bool * values, std::size_t array_length);
 
    result create_boolean_array(const char * name, std::size_t name_length,
        std::size_t array_length, bool * & array);
 
    result create_boolean_array(const char * name,
        std::size_t array_length, bool * & array);
 
    result get_boolean_array(const char * name, std::size_t name_length,
        bool * & values, std::size_t & array_length) const;
 
    result get_boolean_array(const char * name,
        bool * & values, std::size_t & array_length) const;
 
    result set_integer_array(const char * name, std::size_t name_length,
        const int * values, std::size_t array_length);
 
    result set_integer_array(const char * name,
        const int * values, std::size_t array_length);
 
    result set_integer_array_shallow(
        const char * name, std::size_t name_length,
        const int * values, std::size_t array_length);
 
    result set_integer_array_shallow(const char * name,
        const int * values, std::size_t array_length);
 
    result create_integer_array(const char * name, std::size_t name_length,
        std::size_t array_length, int * & array);
 
    result create_integer_array(const char * name,
        std::size_t array_length, int * & array);
 
    result get_integer_array(const char * name, std::size_t name_length,
        int * & values, std::size_t & array_length) const;
 
    result get_integer_array(const char * name,
        int * & values, std::size_t & array_length) const;
 
    result set_long_long_array(const char * name, std::size_t name_length,
        const long long * values, std::size_t array_length);
 
    result set_long_long_array(const char * name,
        const long long * values, std::size_t array_length);
 
    result set_long_long_array_shallow(
        const char * name, std::size_t name_length,
        const long long * values, std::size_t array_length);
 
    result set_long_long_array_shallow(const char * name,
        const long long * values, std::size_t array_length);
 
    result create_long_long_array(const char * name, std::size_t name_length,
        std::size_t array_length, long long * & array);
 
    result create_long_long_array(const char * name,
        std::size_t array_length, long long * & array);
 
    result get_long_long_array(const char * name, std::size_t name_length,
        long long * & values, std::size_t & array_length) const;
 
    result get_long_long_array(const char * name,
        long long * & values, std::size_t & array_length) const;
 
    result set_word_array(const char * name, std::size_t name_length,
        const unsigned int * values, std::size_t array_length);
 
    result set_word_array(const char * name,
        const unsigned int * values, std::size_t array_length);
 
    result set_word_array_shallow(
        const char * name, std::size_t name_length,
        const unsigned int * values, std::size_t array_length);
 
    result set_word_array_shallow(const char * name,
        const unsigned int * values, std::size_t array_length);
 
    result create_word_array(const char * name, std::size_t name_length,
        std::size_t array_length, unsigned int * & array);
 
    result create_word_array(const char * name,
        std::size_t array_length, unsigned int * & array);
 
    result get_word_array(const char * name, std::size_t name_length,
        unsigned int * & values, std::size_t & array_length) const;
 
    result get_word_array(const char * name,
        unsigned int * & values, std::size_t & array_length) const;
 
    result set_long_long_word_array(const char * name, std::size_t name_length,
        const unsigned long long * values, std::size_t array_length);
 
    result set_long_long_word_array(const char * name,
        const unsigned long long * values, std::size_t array_length);
 
    result set_long_long_word_array_shallow(
        const char * name, std::size_t name_length,
        const unsigned long long * values, std::size_t array_length);
 
    result set_long_long_word_array_shallow(const char * name,
        const unsigned long long * values, std::size_t array_length);
 
    result create_long_long_word_array(const char * name, std::size_t name_length,
        std::size_t array_length, unsigned long long * & array);
 
    result create_long_long_word_array(const char * name,
        std::size_t array_length, unsigned long long * & array);
 
    result get_long_long_word_array(const char * name, std::size_t name_length,
        unsigned long long * & values, std::size_t & array_length) const;
 
    result get_long_long_word_array(const char * name,
        unsigned long long * & values, std::size_t & array_length) const;
 
    result set_double_float_array(const char * name, std::size_t name_length,
        const double * values, std::size_t array_length);
 
    result set_double_float_array(const char * name,
        const double * values, std::size_t array_length);
 
    result set_double_float_array_shallow(
        const char * name, std::size_t name_length,
        const double * values, std::size_t array_length);
 
    result set_double_float_array_shallow(const char * name,
        const double * values, std::size_t array_length);
 
    result create_double_float_array(
        const char * name, std::size_t name_length,
        std::size_t array_length, double * & array);
 
    result create_double_float_array(
        const char * name,
        std::size_t array_length, double * & array);
 
    result get_double_float_array(const char * name, std::size_t name_length,
        double * & values, std::size_t & array_length) const;
 
    result get_double_float_array(const char * name,
        double * & values, std::size_t & array_length) const;
 
    result create_string_array(const char * name, std::size_t name_length,
        std::size_t array_length);
 
    result create_string_array(const char * name, std::size_t array_length);
 
    result set_string_in_array(const char * name, std::size_t name_length,
        std::size_t index, const char * value, std::size_t value_length);
 
    result set_string_in_array(const char * name, std::size_t index,
        const char * value);
 
    result get_string_array_length(const char * name, std::size_t name_length,
        std::size_t & array_length) const;
 
    result get_string_array_length(const char * name,
        std::size_t & array_length) const;
 
    result get_string_in_array(const char * name, std::size_t name_length,
        std::size_t index,
        const char * & value, std::size_t & value_length) const;
 
    result get_string_in_array(const char * name, std::size_t index,
        const char * & value, std::size_t & value_length) const;
 
    result create_binary_array(const char * name, std::size_t name_length,
        std::size_t array_length);
 
    result create_binary_array(const char * name, std::size_t array_length);
 
    result set_binary_in_array(const char * name, std::size_t name_length,
        std::size_t index, const void * value, std::size_t value_length);
 
    result set_binary_in_array(const char * name, std::size_t index,
        const void * value, std::size_t value_length);
 
    result get_binary_array_length(const char * name, std::size_t name_length,
        std::size_t & array_length) const;
 
    result get_binary_array_length(const char * name,
        std::size_t & array_length) const;
 
    result get_binary_in_array(const char * name, std::size_t name_length,
        std::size_t index,
        const void * & value, std::size_t & value_length) const;
 
    result get_binary_in_array(const char * name, std::size_t index,
        const void * & value, std::size_t & value_length) const;
 
    // support for data nesting
 
    result create_nested_parameters(
        const char * name, std::size_t name_length,
        parameters * & params);
 
    result create_nested_parameters(const char * name, parameters * & params);
 
    result get_nested_parameters(
        const char * name, std::size_t name_length,
        parameters * & params) const;
 
    result get_nested_parameters(
        const char * name, parameters * & params) const;
 
    result create_nested_array(const char * name, std::size_t name_length,
        std::size_t array_length);
 
    result create_nested_array(const char * name, std::size_t array_length);
 
    result get_nested_array_length(const char * name, std::size_t name_length,
        std::size_t & array_length) const;
 
    result get_nested_array_length(const char * name,
        std::size_t & array_length) const;
 
    result get_nested_in_array(const char * name, std::size_t name_length,
        std::size_t index,
        parameters * & nested) const;
 
    result get_nested_in_array(const char * name, std::size_t index,
        parameters * & nested) const;
 
    // other operations
 
    result remove(const char * name, std::size_t name_length);
 
    result remove(const char * name);
 
    // inspection
 
    std::size_t size() const;
 
    result get_type(const char * name, std::size_t name_length,
        parameter_type & t) const;
 
    result get_type(const char * name, parameter_type & t) const;
 
    // iterator support
 
    result get_iterator(parameter_iterator & it) const;
 
    result find(const char * name, std::size_t name_length,
        parameter_entry & entry) const;
 
    result find(const char * name, parameter_entry & entry) const;
 
    result merge_from(const parameters & other);
 
    void clear();
 
    // serialization
 
    virtual result get_serialize_buffer_size(std::size_t & size) const;
 
    virtual result serialize(char * * buffers,
        const std::size_t * buffer_sizes,
        std::size_t num_of_buffers) const;
 
    result deserialize(const char * * buffers,
        const std::size_t * buffer_sizes,
        std::size_t num_of_buffers);
 
    // for unit tests
    void dump(details::dump_sink & sink, std::size_t indent_length = 0) const;
    
    // used internally
    allocator & allocator_;
    details::entry * data_;
    std::size_t num_of_entries_;
 
private:
 
    standard_allocator default_allocator_;
    
    parameters(const parameters &);
    void operator=(const parameters &);
};
 
} // namespace core
 
} // namespace yami
 
#endif // YAMICORE_PARAMETERS_H_INCLUDED