data.h

Go to the documentation of this file.

// Copyright (C) 2010-2023 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef ISC_DATA_H
#define ISC_DATA_H 1
 
#include <util/bigints.h>
 
#include <iostream>
#include <map>
#include <stdexcept>
#include <string>
#include <vector>
 
#include <boost/shared_ptr.hpp>
 
#include <stdint.h>
 
#include <exceptions/exceptions.h>
 
namespace isc { namespace data {
 
class Element;
// todo: describe the rationale behind ElementPtr?
typedef boost::shared_ptr<Element> ElementPtr;
typedef boost::shared_ptr<const Element> ConstElementPtr;
 
class TypeError : public isc::Exception {
public:
    TypeError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
// i'd like to use Exception here but we need one that is derived from
// runtime_error (as this one is directly based on external data, and
// i want to add some values to any static data string that is provided)
class JSONError : public isc::Exception {
public:
    JSONError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class Element {
 
public:
    struct Position {
        std::string file_; 
        uint32_t line_;    
        uint32_t pos_;     
 
        Position() : file_(""), line_(0), pos_(0) {
        }
 
        Position(const std::string& file, const uint32_t line,
                 const uint32_t pos)
            : file_(file), line_(line), pos_(pos) {
        }
 
        std::string str() const;
    };
 
    static const Position& ZERO_POSITION() {
        static Position position("", 0, 0);
        return (position);
    }
 
    enum types {
        integer = 0,
        real = 1,
        boolean = 2,
        null = 3,
        string = 4,
        bigint = 5,
        list = 6,
        map = 7,
        any = 8,
    };
 
private:
    // technically the type could be omitted; is it useful?
    // should we remove it or replace it with a pure virtual
    // function getType?
    types type_;
 
    Position position_;
 
protected:
 
    Element(types t, const Position& pos = ZERO_POSITION())
        : type_(t), position_(pos) {
    }
 
 
public:
    // base class; make dtor virtual
    virtual ~Element() {};
 
    types getType() const { return (type_); }
 
    const Position& getPosition() const { return (position_); }
 
    std::string str() const;
 
    std::string toWire() const;
    void toWire(std::ostream& out) const;
 
#define throwTypeError(error)                   \
    {                                           \
        std::string msg_ = error;               \
        if ((position_.file_ != "") ||          \
            (position_.line_ != 0) ||           \
            (position_.pos_ != 0)) {            \
            msg_ += " in (" + position_.str() + ")";   \
        }                                       \
        isc_throw(TypeError, msg_);             \
    }
 
 
    virtual bool equals(const Element& other) const = 0;
 
    virtual void toJSON(std::ostream& ss) const = 0;
 
 
    virtual int64_t intValue() const
    { throwTypeError("intValue() called on non-integer Element"); };
    virtual isc::util::int128_t bigIntValue() const {
        throwTypeError("bigIntValue() called on non-big-integer Element");
    }
    virtual double doubleValue() const
    { throwTypeError("doubleValue() called on non-double Element"); };
    virtual bool boolValue() const
    { throwTypeError("boolValue() called on non-Bool Element"); };
    virtual std::string stringValue() const
    { throwTypeError("stringValue() called on non-string Element"); };
    virtual const std::vector<ElementPtr>& listValue() const {
        // replace with real exception or empty vector?
        throwTypeError("listValue() called on non-list Element");
    };
    virtual const std::map<std::string, ConstElementPtr>& mapValue() const {
        // replace with real exception or empty map?
        throwTypeError("mapValue() called on non-map Element");
    };
 
 
    virtual bool getValue(int64_t& t) const;
    virtual bool getValue(double& t) const;
    virtual bool getValue(bool& t) const;
    virtual bool getValue(std::string& t) const;
    virtual bool getValue(std::vector<ElementPtr>& t) const;
    virtual bool getValue(std::map<std::string, ConstElementPtr>& t) const;
 
 
    virtual bool setValue(const long long int v);
    virtual bool setValue(const isc::util::int128_t& v);
    bool setValue(const long int i) { return (setValue(static_cast<long long int>(i))); };
    bool setValue(const int i) { return (setValue(static_cast<long long int>(i))); };
    virtual bool setValue(const double v);
    virtual bool setValue(const bool t);
    virtual bool setValue(const std::string& v);
    virtual bool setValue(const std::vector<ElementPtr>& v);
    virtual bool setValue(const std::map<std::string, ConstElementPtr>& v);
 
    // Other functions for specific subtypes
 
 
 
    virtual ConstElementPtr get(const int i) const;
 
    virtual ElementPtr getNonConst(const int i) const;
 
    virtual void set(const size_t i, ElementPtr element);
 
    virtual void add(ElementPtr element);
 
    virtual void remove(const int i);
 
    virtual size_t size() const;
 
    virtual bool empty() const;
 
 
 
 
    virtual ConstElementPtr get(const std::string& name) const;
 
    virtual void set(const std::string& name, ConstElementPtr element);
 
    virtual void remove(const std::string& name);
 
    virtual bool contains(const std::string& name) const;
 
    virtual ConstElementPtr find(const std::string& identifier) const;
 
    virtual bool find(const std::string& identifier, ConstElementPtr& t) const;
 
 
    // TODO: should we move all factory functions to a different class
    // so as not to burden the Element base with too many functions?
    // and/or perhaps even to a separate header?
 
 
    static ElementPtr create(const Position& pos = ZERO_POSITION());
    static ElementPtr create(const long long int i,
                             const Position& pos = ZERO_POSITION());
    static ElementPtr create(const isc::util::int128_t& i,
                             const Position& pos = ZERO_POSITION());
    static ElementPtr create(const int i,
                             const Position& pos = ZERO_POSITION());
    static ElementPtr create(const long int i,
                             const Position& pos = ZERO_POSITION());
    static ElementPtr create(const uint32_t i,
                             const Position& pos = ZERO_POSITION());
    static ElementPtr create(const double d,
                             const Position& pos = ZERO_POSITION());
    static ElementPtr create(const bool b,
                             const Position& pos = ZERO_POSITION());
    static ElementPtr create(const std::string& s,
                             const Position& pos = ZERO_POSITION());
    // need both std:string and char *, since c++ will match
    // bool before std::string when you pass it a char *
    static ElementPtr create(const char *s,
                             const Position& pos = ZERO_POSITION());
 
    static ElementPtr createList(const Position& pos = ZERO_POSITION());
 
    static ElementPtr createMap(const Position& pos = ZERO_POSITION());
 
 
 
 
    static ElementPtr fromJSON(const std::string& in, bool preproc = false);
 
    static ElementPtr fromJSON(std::istream& in, bool preproc = false);
 
    static ElementPtr fromJSON(std::istream& in, const std::string& file_name,
                               bool preproc = false);
 
    // make this one private?
    static ElementPtr fromJSON(std::istream& in, const std::string& file,
                               int& line, int &pos);
 
    static ElementPtr fromJSONFile(const std::string& file_name,
                                   bool preproc = false);
 
 
    static std::string typeToName(Element::types type);
 
    static Element::types nameToType(const std::string& type_name);
 
    static void preprocess(std::istream& in, std::stringstream& out);
 
 
 
 
    static ElementPtr fromWire(std::stringstream& in, int length);
 
    static ElementPtr fromWire(const std::string& s);
 
    void removeEmptyContainersRecursively() {
        if (type_ == list || type_ == map) {
            size_t s(size());
            for (size_t i = 0; i < s; ++i) {
                // Get child.
                ElementPtr child;
                if (type_ == list) {
                    child = getNonConst(i);
                } else if (type_ == map) {
                    std::string const key(get(i)->stringValue());
                    // The ElementPtr - ConstElementPtr disparity between
                    // ListElement and MapElement is forcing a const cast here.
                    // It's undefined behavior to modify it after const casting.
                    // The options are limited. I've tried templating, moving
                    // this function from a member function to free-standing and
                    // taking the Element template as argument. I've tried
                    // making it a virtual function with overridden
                    // implementations in ListElement and MapElement. Nothing
                    // works.
                    child = boost::const_pointer_cast<Element>(get(key));
                }
 
                // Makes no sense to continue for non-container children.
                if (child->getType() != list && child->getType() != map) {
                    continue;
                }
 
                // Recurse if not empty.
                if (!child->empty()){
                    child->removeEmptyContainersRecursively();
                }
 
                // When returning from recursion, remove if empty.
                if (child->empty()) {
                    remove(i);
                    --i;
                    --s;
                }
            }
        }
    }
};
 
class IntElement : public Element {
    int64_t i;
public:
    IntElement(int64_t v, const Position& pos = ZERO_POSITION())
        : Element(integer, pos), i(v) { }
    int64_t intValue() const { return (i); }
    using Element::getValue;
    bool getValue(int64_t& t) const { t = i; return (true); }
    using Element::setValue;
    bool setValue(long long int v) { i = v; return (true); }
    void toJSON(std::ostream& ss) const;
    bool equals(const Element& other) const;
};
 
class BigIntElement : public Element {
    using int128_t = isc::util::int128_t;
    using Element::getValue;
    using Element::setValue;
 
public:
    BigIntElement(const int128_t& v, const Position& pos = ZERO_POSITION())
        : Element(bigint, pos), i_(v) {
    }
 
    int128_t bigIntValue() const override {
        return (i_);
    }
 
    bool setValue(const int128_t& v) override {
        i_ = v;
        return (true);
    }
 
    void toJSON(std::ostream& ss) const override;
 
    bool equals(const Element& other) const override;
 
private:
    int128_t i_;
};
 
class DoubleElement : public Element {
    double d;
 
public:
    DoubleElement(double v, const Position& pos = ZERO_POSITION())
        : Element(real, pos), d(v) {};
    double doubleValue() const { return (d); }
    using Element::getValue;
    bool getValue(double& t) const { t = d; return (true); }
    using Element::setValue;
    bool setValue(const double v) { d = v; return (true); }
    void toJSON(std::ostream& ss) const;
    bool equals(const Element& other) const;
};
 
class BoolElement : public Element {
    bool b;
 
public:
    BoolElement(const bool v, const Position& pos = ZERO_POSITION())
        : Element(boolean, pos), b(v) {};
    bool boolValue() const { return (b); }
    using Element::getValue;
    bool getValue(bool& t) const { t = b; return (true); }
    using Element::setValue;
    bool setValue(const bool v) { b = v; return (true); }
    void toJSON(std::ostream& ss) const;
    bool equals(const Element& other) const;
};
 
class NullElement : public Element {
public:
    NullElement(const Position& pos = ZERO_POSITION())
        : Element(null, pos) {};
    void toJSON(std::ostream& ss) const;
    bool equals(const Element& other) const;
};
 
class StringElement : public Element {
    std::string s;
 
public:
    StringElement(std::string v, const Position& pos = ZERO_POSITION())
        : Element(string, pos), s(v) {};
    std::string stringValue() const { return (s); }
    using Element::getValue;
    bool getValue(std::string& t) const { t = s; return (true); }
    using Element::setValue;
    bool setValue(const std::string& v) { s = v; return (true); }
    void toJSON(std::ostream& ss) const;
    bool equals(const Element& other) const;
};
 
class ListElement : public Element {
    std::vector<ElementPtr> l;
 
public:
    ListElement(const Position& pos = ZERO_POSITION())
        : Element(list, pos) {}
    const std::vector<ElementPtr>& listValue() const { return (l); }
    using Element::getValue;
    bool getValue(std::vector<ElementPtr>& t) const {
        t = l;
        return (true);
    }
    using Element::setValue;
    bool setValue(const std::vector<ElementPtr>& v) {
        l = v;
        return (true);
    }
    using Element::get;
    ConstElementPtr get(int i) const { return (l.at(i)); }
    ElementPtr getNonConst(int i) const  { return (l.at(i)); }
    using Element::set;
    void set(size_t i, ElementPtr e) {
        l.at(i) = e;
    }
    void add(ElementPtr e) { l.push_back(e); };
    using Element::remove;
    void remove(int i) { l.erase(l.begin() + i); };
    void toJSON(std::ostream& ss) const;
    size_t size() const { return (l.size()); }
    bool empty() const { return (l.empty()); }
    bool equals(const Element& other) const;
 
    void sort(std::string const& index = std::string());
};
 
class MapElement : public Element {
    std::map<std::string, ConstElementPtr> m;
 
public:
    MapElement(const Position& pos = ZERO_POSITION()) : Element(map, pos) {}
    // @todo should we have direct iterators instead of exposing the std::map
    // here?
    const std::map<std::string, ConstElementPtr>& mapValue() const override {
        return (m);
    }
    using Element::getValue;
    bool getValue(std::map<std::string, ConstElementPtr>& t) const override {
        t = m;
        return (true);
    }
    using Element::setValue;
    bool setValue(const std::map<std::string, ConstElementPtr>& v) override {
        m = v;
        return (true);
    }
    using Element::get;
    ConstElementPtr get(const std::string& s) const override {
        auto found = m.find(s);
        return (found != m.end() ? found->second : ConstElementPtr());
    }
 
    ConstElementPtr get(int const i) const override {
        auto it(m.begin());
        std::advance(it, i);
        return create(it->first);
    }
 
    using Element::set;
    void set(const std::string& key, ConstElementPtr value) override;
    using Element::remove;
    void remove(const std::string& s) override { m.erase(s); }
 
    void remove(int const i) override {
        auto it(m.begin());
        std::advance(it, i);
        m.erase(it);
    }
 
    bool contains(const std::string& s) const override {
        return (m.find(s) != m.end());
    }
    void toJSON(std::ostream& ss) const override;
 
    // we should name the two finds better...
    // find the element at id; raises TypeError if one of the
    // elements at path except the one we're looking for is not a
    // mapelement.
    // returns an empty element if the item could not be found
    ConstElementPtr find(const std::string& id) const override;
 
    // find the Element at 'id', and store the element pointer in t
    // returns true if found, or false if not found (either because
    // it doesn't exist or one of the elements in the path is not
    // a MapElement)
    bool find(const std::string& id, ConstElementPtr& t) const override;
 
    size_t size() const override {
        return (m.size());
    }
 
    bool equals(const Element& other) const override;
 
    bool empty() const override { return (m.empty()); }
};
 
bool isNull(ConstElementPtr p);
 
void removeIdentical(ElementPtr a, ConstElementPtr b);
 
ConstElementPtr removeIdentical(ConstElementPtr a, ConstElementPtr b);
 
void merge(ElementPtr element, ConstElementPtr other);
 
typedef std::function<bool (ElementPtr&, ElementPtr&)> MatchTestFunc;
 
typedef std::function<bool (ElementPtr&)> NoDataTestFunc;
 
typedef std::function<bool (const std::string&)> IsKeyTestFunc;
 
struct HierarchyTraversalTest {
    MatchTestFunc match_;
    NoDataTestFunc no_data_;
    IsKeyTestFunc is_key_;
};
 
typedef std::map<std::string, HierarchyTraversalTest> FunctionMap;
 
typedef std::vector<FunctionMap> HierarchyDescriptor;
 
void mergeDiffAdd(ElementPtr& element, ElementPtr& other,
                  HierarchyDescriptor& hierarchy, std::string key,
                  size_t idx = 0);
 
void mergeDiffDel(ElementPtr& element, ElementPtr& other,
                  HierarchyDescriptor& hierarchy, std::string key,
                  size_t idx = 0);
 
void extend(const std::string& container, const std::string& extension,
            ElementPtr& element, ElementPtr& other,
            HierarchyDescriptor& hierarchy, std::string key, size_t idx = 0,
            bool alter = false);
 
ElementPtr copy(ConstElementPtr from, int level = 100);
 
bool isEquivalent(ConstElementPtr a, ConstElementPtr b);
 
void prettyPrint(ConstElementPtr element, std::ostream& out,
                 unsigned indent = 0, unsigned step = 2);
 
std::string prettyPrint(ConstElementPtr element,
                        unsigned indent = 0, unsigned step = 2);
 
std::ostream& operator<<(std::ostream& out, const Element::Position& pos);
 
std::ostream& operator<<(std::ostream& out, const Element& e);
 
bool operator==(const Element& a, const Element& b);
bool operator!=(const Element& a, const Element& b);
bool operator<(const Element& a, const Element& b);
 
}  // namespace data
}  // namespace isc
 
#endif // ISC_DATA_H