values.h

Go to the documentation of this file.

#ifndef DBALLE_VALUES_H
#define DBALLE_VALUES_H

 
#include <dballe/fwd.h>
#include <dballe/value.h>
#include <dballe/var.h>
#include <functional>
#include <iosfwd>
#include <vector>
 
namespace dballe {
namespace impl {
 
template <typename Value> class ValuesBase
{
public:
    typedef typename std::vector<Value>::const_iterator const_iterator;
    typedef typename std::vector<Value>::iterator iterator;
 
protected:
    std::vector<Value> m_values;
 
    iterator insert_new(Value&& val);
 
public:
    ValuesBase() {}
    ValuesBase(const ValuesBase&)            = default;
    ValuesBase(ValuesBase&&)                 = default;
    ValuesBase& operator=(const ValuesBase&) = default;
    ValuesBase& operator=(ValuesBase&&)      = default;
 
    const_iterator begin() const { return m_values.begin(); }
    const_iterator end() const { return m_values.end(); }
    const_iterator cbegin() const { return m_values.cbegin(); }
    const_iterator cend() const { return m_values.cend(); }
    iterator begin() { return m_values.begin(); }
    iterator end() { return m_values.end(); }
    iterator find(wreport::Varcode code) noexcept;
    const_iterator find(wreport::Varcode code) const noexcept;
    size_t size() const { return m_values.size(); }
    bool empty() const { return m_values.empty(); }
    void clear() { return m_values.clear(); }
    void reserve(typename std::vector<Value>::size_type size)
    {
        m_values.reserve(size);
    }
    bool operator==(const ValuesBase<Value>& o) const;
    bool operator!=(const ValuesBase<Value>& o) const;

    void set(const wreport::Var&);

    void set(std::unique_ptr<wreport::Var>&&);

    void set(Value&& val);

    void unset(wreport::Varcode code);

    void merge(const ValuesBase<Value>& vals);

    void merge(ValuesBase<Value>&& vals);

    template <typename C, typename T> void set(const C& code, const T& val)
    {
        this->set(newvar(code, val));
    }
 
    template <typename C, typename T> void setf(const C& code, const T& val)
    {
        auto var = newvar(code);
        var->setf(val);
        this->set(std::move(var));
    }

    const Value& value(wreport::Varcode code) const;
    const Value& value(const char* code) const
    {
        return value(resolve_varcode(code));
    }
    const Value& value(const std::string& code) const
    {
        return value(resolve_varcode(code));
    }

    const wreport::Var& var(wreport::Varcode code) const;
    const wreport::Var& var(const char* code) const
    {
        return var(resolve_varcode(code));
    }
    const wreport::Var& var(const std::string& code) const
    {
        return var(resolve_varcode(code));
    }

    wreport::Var& var(wreport::Varcode code);
    wreport::Var& var(const char* code) { return var(resolve_varcode(code)); }
    wreport::Var& var(const std::string& code)
    {
        return var(resolve_varcode(code));
    }

    const Value* maybe_value(wreport::Varcode code) const;
    const Value* maybe_value(const char* code) const
    {
        return maybe_value(resolve_varcode(code));
    }
    const Value* maybe_value(const std::string& code) const
    {
        return maybe_value(resolve_varcode(code));
    }

    const wreport::Var* maybe_var(wreport::Varcode code) const;
    const wreport::Var* maybe_var(const char* code) const
    {
        return maybe_var(resolve_varcode(code));
    }
    const wreport::Var* maybe_var(const std::string& code) const
    {
        return maybe_var(resolve_varcode(code));
    }

    wreport::Var* maybe_var(wreport::Varcode code);
    wreport::Var* maybe_var(const char* code)
    {
        return maybe_var(resolve_varcode(code));
    }
    wreport::Var* maybe_var(const std::string& code)
    {
        return maybe_var(resolve_varcode(code));
    }

    template <typename C, typename T> T enq(C code, const T& def)
    {
        if (const wreport::Var* var = maybe_var(code))
            return var->enq(def);
        return def;
    }

    void move_to_attributes(wreport::Var& dest);

    void move_to(std::function<void(std::unique_ptr<wreport::Var>)> dest);

    void print(FILE* out) const;

    std::vector<uint8_t> encode() const;

    static std::vector<uint8_t> encode_attrs(const wreport::Var& var);

    static void decode(const std::vector<uint8_t>& buf,
                       std::function<void(std::unique_ptr<wreport::Var>)> dest);
};
 
extern template struct ValuesBase<Value>;
extern template struct ValuesBase<DBValue>;
 
} // namespace impl
 
struct DBValues;

struct Values : public impl::ValuesBase<Value>
{
    using ValuesBase<Value>::ValuesBase;
    Values() = default;
    explicit Values(const DBValues&);
    explicit Values(DBValues&&);
 
    Values& operator=(const DBValues&);
    Values& operator=(DBValues&&);
};

struct DBValues : public impl::ValuesBase<DBValue>
{
public:
    using ValuesBase<DBValue>::ValuesBase;
    DBValues() = default;
    explicit DBValues(const Values&);
    explicit DBValues(Values&&);
 
    DBValues& operator=(const Values&);
    DBValues& operator=(Values&&);

    bool vars_equal(const DBValues& o) const;

    void set_data_id(wreport::Varcode code, int data_id);

    void clear_ids()
    {
        for (auto& val : m_values)
            val.data_id = MISSING_INT;
    }
};
 
std::ostream& operator<<(std::ostream&, const Values&);
std::ostream& operator<<(std::ostream&, const DBValues&);
 
} // namespace dballe
 
#endif