Kea  2.5.2
data.h
Go to the documentation of this file.
1 // Copyright (C) 2010-2023 Internet Systems Consortium, Inc. ("ISC")
2 //
3 // This Source Code Form is subject to the terms of the Mozilla Public
4 // License, v. 2.0. If a copy of the MPL was not distributed with this
5 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
6 
7 #ifndef ISC_DATA_H
8 #define ISC_DATA_H 1
9 
10 #include <util/bigints.h>
11 
12 #include <iostream>
13 #include <map>
14 #include <stdexcept>
15 #include <string>
16 #include <vector>
17 
18 #include <boost/shared_ptr.hpp>
19 
20 #include <stdint.h>
21 
22 #include <exceptions/exceptions.h>
23 
24 namespace isc { namespace data {
25 
26 class Element;
27 // todo: describe the rationale behind ElementPtr?
28 typedef boost::shared_ptr<Element> ElementPtr;
29 typedef boost::shared_ptr<const Element> ConstElementPtr;
30 
36 class TypeError : public isc::Exception {
37 public:
38  TypeError(const char* file, size_t line, const char* what) :
39  isc::Exception(file, line, what) {}
40 };
41 
46 // i'd like to use Exception here but we need one that is derived from
47 // runtime_error (as this one is directly based on external data, and
48 // i want to add some values to any static data string that is provided)
49 class JSONError : public isc::Exception {
50 public:
51  JSONError(const char* file, size_t line, const char* what) :
52  isc::Exception(file, line, what) {}
53 };
54 
72 class Element {
73 
74 public:
94  struct Position {
95  std::string file_;
96  uint32_t line_;
97  uint32_t pos_;
98 
100  Position() : file_(""), line_(0), pos_(0) {
101  }
102 
108  Position(const std::string& file, const uint32_t line,
109  const uint32_t pos)
110  : file_(file), line_(line), pos_(pos) {
111  }
112 
116  std::string str() const;
117  };
118 
126  static const Position& ZERO_POSITION() {
127  static Position position("", 0, 0);
128  return (position);
129  }
130 
139  enum types {
140  integer = 0,
141  real = 1,
142  boolean = 2,
143  null = 3,
144  string = 4,
145  bigint = 5,
146  list = 6,
147  map = 7,
148  any = 8,
149  };
150 
151 private:
152  // technically the type could be omitted; is it useful?
153  // should we remove it or replace it with a pure virtual
154  // function getType?
155  types type_;
156 
158  Position position_;
159 
160 protected:
161 
168  Element(types t, const Position& pos = ZERO_POSITION())
169  : type_(t), position_(pos) {
170  }
171 
172 
173 public:
174  // base class; make dtor virtual
175  virtual ~Element() {};
176 
178  types getType() const { return (type_); }
179 
185  const Position& getPosition() const { return (position_); }
186 
194  std::string str() const;
195 
200  std::string toWire() const;
201  void toWire(std::ostream& out) const;
202 
205 #define throwTypeError(error) \
206  { \
207  std::string msg_ = error; \
208  if ((position_.file_ != "") || \
209  (position_.line_ != 0) || \
210  (position_.pos_ != 0)) { \
211  msg_ += " in (" + position_.str() + ")"; \
212  } \
213  isc_throw(TypeError, msg_); \
214  }
215 
217 
220  virtual bool equals(const Element& other) const = 0;
221 
224  virtual void toJSON(std::ostream& ss) const = 0;
225 
233 
234  virtual int64_t intValue() const
235  { throwTypeError("intValue() called on non-integer Element"); };
237  throwTypeError("bigIntValue() called on non-big-integer Element");
238  }
239  virtual double doubleValue() const
240  { throwTypeError("doubleValue() called on non-double Element"); };
241  virtual bool boolValue() const
242  { throwTypeError("boolValue() called on non-Bool Element"); };
243  virtual std::string stringValue() const
244  { throwTypeError("stringValue() called on non-string Element"); };
245  virtual const std::vector<ElementPtr>& listValue() const {
246  // replace with real exception or empty vector?
247  throwTypeError("listValue() called on non-list Element");
248  };
249  virtual const std::map<std::string, ConstElementPtr>& mapValue() const {
250  // replace with real exception or empty map?
251  throwTypeError("mapValue() called on non-map Element");
252  };
254 
263 
264  virtual bool getValue(int64_t& t) const;
265  virtual bool getValue(double& t) const;
266  virtual bool getValue(bool& t) const;
267  virtual bool getValue(std::string& t) const;
268  virtual bool getValue(std::vector<ElementPtr>& t) const;
269  virtual bool getValue(std::map<std::string, ConstElementPtr>& t) const;
271 
281 
282  virtual bool setValue(const long long int v);
283  virtual bool setValue(const isc::util::int128_t& v);
284  bool setValue(const long int i) { return (setValue(static_cast<long long int>(i))); };
285  bool setValue(const int i) { return (setValue(static_cast<long long int>(i))); };
286  virtual bool setValue(const double v);
287  virtual bool setValue(const bool t);
288  virtual bool setValue(const std::string& v);
289  virtual bool setValue(const std::vector<ElementPtr>& v);
290  virtual bool setValue(const std::map<std::string, ConstElementPtr>& v);
292 
293  // Other functions for specific subtypes
294 
299 
300  virtual ConstElementPtr get(const int i) const;
304 
309  virtual ElementPtr getNonConst(const int i) const;
310 
315  virtual void set(const size_t i, ElementPtr element);
316 
319  virtual void add(ElementPtr element);
320 
324  virtual void remove(const int i);
325 
327  virtual size_t size() const;
328 
330  virtual bool empty() const;
332 
333 
338 
339  virtual ConstElementPtr get(const std::string& name) const;
343 
347  virtual void set(const std::string& name, ConstElementPtr element);
348 
351  virtual void remove(const std::string& name);
352 
356  virtual bool contains(const std::string& name) const;
357 
371  virtual ConstElementPtr find(const std::string& identifier) const;
372 
377  virtual bool find(const std::string& identifier, ConstElementPtr& t) const;
379 
381 
382  // TODO: should we move all factory functions to a different class
383  // so as not to burden the Element base with too many functions?
384  // and/or perhaps even to a separate header?
385 
398 
399  static ElementPtr create(const Position& pos = ZERO_POSITION());
400  static ElementPtr create(const long long int i,
401  const Position& pos = ZERO_POSITION());
402  static ElementPtr create(const isc::util::int128_t& i,
403  const Position& pos = ZERO_POSITION());
404  static ElementPtr create(const int i,
405  const Position& pos = ZERO_POSITION());
406  static ElementPtr create(const long int i,
407  const Position& pos = ZERO_POSITION());
408  static ElementPtr create(const uint32_t i,
409  const Position& pos = ZERO_POSITION());
410  static ElementPtr create(const double d,
411  const Position& pos = ZERO_POSITION());
412  static ElementPtr create(const bool b,
413  const Position& pos = ZERO_POSITION());
414  static ElementPtr create(const std::string& s,
415  const Position& pos = ZERO_POSITION());
416  // need both std:string and char *, since c++ will match
417  // bool before std::string when you pass it a char *
418  static ElementPtr create(const char *s,
419  const Position& pos = ZERO_POSITION());
420 
425  static ElementPtr createList(const Position& pos = ZERO_POSITION());
426 
431  static ElementPtr createMap(const Position& pos = ZERO_POSITION());
433 
435 
439 
441  static ElementPtr fromJSON(const std::string& in, bool preproc = false);
448 
458  static ElementPtr fromJSON(std::istream& in, bool preproc = false);
459 
471  static ElementPtr fromJSON(std::istream& in, const std::string& file_name,
472  bool preproc = false);
473 
486  // make this one private?
488  static ElementPtr fromJSON(std::istream& in, const std::string& file,
489  int& line, int &pos);
490 
498  static ElementPtr fromJSONFile(const std::string& file_name,
499  bool preproc = false);
501 
503 
509  static std::string typeToName(Element::types type);
510 
516  static Element::types nameToType(const std::string& type_name);
517 
532  static void preprocess(std::istream& in, std::stringstream& out);
533 
535 
539 
541  static ElementPtr fromWire(std::stringstream& in, int length);
550 
557  static ElementPtr fromWire(const std::string& s);
559 
563  if (type_ == list || type_ == map) {
564  size_t s(size());
565  for (size_t i = 0; i < s; ++i) {
566  // Get child.
567  ElementPtr child;
568  if (type_ == list) {
569  child = getNonConst(i);
570  } else if (type_ == map) {
571  std::string const key(get(i)->stringValue());
572  // The ElementPtr - ConstElementPtr disparity between
573  // ListElement and MapElement is forcing a const cast here.
574  // It's undefined behavior to modify it after const casting.
575  // The options are limited. I've tried templating, moving
576  // this function from a member function to free-standing and
577  // taking the Element template as argument. I've tried
578  // making it a virtual function with overridden
579  // implementations in ListElement and MapElement. Nothing
580  // works.
581  child = boost::const_pointer_cast<Element>(get(key));
582  }
583 
584  // Makes no sense to continue for non-container children.
585  if (child->getType() != list && child->getType() != map) {
586  continue;
587  }
588 
589  // Recurse if not empty.
590  if (!child->empty()){
591  child->removeEmptyContainersRecursively();
592  }
593 
594  // When returning from recursion, remove if empty.
595  if (child->empty()) {
596  remove(i);
597  --i;
598  --s;
599  }
600  }
601  }
602  }
603 };
604 
615 class IntElement : public Element {
616  int64_t i;
617 public:
618  IntElement(int64_t v, const Position& pos = ZERO_POSITION())
619  : Element(integer, pos), i(v) { }
620  int64_t intValue() const { return (i); }
621  using Element::getValue;
622  bool getValue(int64_t& t) const { t = i; return (true); }
623  using Element::setValue;
624  bool setValue(long long int v) { i = v; return (true); }
625  void toJSON(std::ostream& ss) const;
626  bool equals(const Element& other) const;
627 };
628 
630 class BigIntElement : public Element {
631  using int128_t = isc::util::int128_t;
632  using Element::getValue;
633  using Element::setValue;
634 
635 public:
637  BigIntElement(const int128_t& v, const Position& pos = ZERO_POSITION())
638  : Element(bigint, pos), i_(v) {
639  }
640 
644  int128_t bigIntValue() const override {
645  return (i_);
646  }
647 
651  bool setValue(const int128_t& v) override {
652  i_ = v;
653  return (true);
654  }
655 
658  void toJSON(std::ostream& ss) const override;
659 
664  bool equals(const Element& other) const override;
665 
666 private:
668  int128_t i_;
669 };
670 
671 class DoubleElement : public Element {
672  double d;
673 
674 public:
675  DoubleElement(double v, const Position& pos = ZERO_POSITION())
676  : Element(real, pos), d(v) {};
677  double doubleValue() const { return (d); }
678  using Element::getValue;
679  bool getValue(double& t) const { t = d; return (true); }
680  using Element::setValue;
681  bool setValue(const double v) { d = v; return (true); }
682  void toJSON(std::ostream& ss) const;
683  bool equals(const Element& other) const;
684 };
685 
686 class BoolElement : public Element {
687  bool b;
688 
689 public:
690  BoolElement(const bool v, const Position& pos = ZERO_POSITION())
691  : Element(boolean, pos), b(v) {};
692  bool boolValue() const { return (b); }
693  using Element::getValue;
694  bool getValue(bool& t) const { t = b; return (true); }
695  using Element::setValue;
696  bool setValue(const bool v) { b = v; return (true); }
697  void toJSON(std::ostream& ss) const;
698  bool equals(const Element& other) const;
699 };
700 
701 class NullElement : public Element {
702 public:
704  : Element(null, pos) {};
705  void toJSON(std::ostream& ss) const;
706  bool equals(const Element& other) const;
707 };
708 
709 class StringElement : public Element {
710  std::string s;
711 
712 public:
713  StringElement(std::string v, const Position& pos = ZERO_POSITION())
714  : Element(string, pos), s(v) {};
715  std::string stringValue() const { return (s); }
716  using Element::getValue;
717  bool getValue(std::string& t) const { t = s; return (true); }
718  using Element::setValue;
719  bool setValue(const std::string& v) { s = v; return (true); }
720  void toJSON(std::ostream& ss) const;
721  bool equals(const Element& other) const;
722 };
723 
724 class ListElement : public Element {
725  std::vector<ElementPtr> l;
726 
727 public:
729  : Element(list, pos) {}
730  const std::vector<ElementPtr>& listValue() const { return (l); }
731  using Element::getValue;
732  bool getValue(std::vector<ElementPtr>& t) const {
733  t = l;
734  return (true);
735  }
736  using Element::setValue;
737  bool setValue(const std::vector<ElementPtr>& v) {
738  l = v;
739  return (true);
740  }
741  using Element::get;
742  ConstElementPtr get(int i) const { return (l.at(i)); }
743  ElementPtr getNonConst(int i) const { return (l.at(i)); }
744  using Element::set;
745  void set(size_t i, ElementPtr e) {
746  l.at(i) = e;
747  }
748  void add(ElementPtr e) { l.push_back(e); };
749  using Element::remove;
750  void remove(int i) { l.erase(l.begin() + i); };
751  void toJSON(std::ostream& ss) const;
752  size_t size() const { return (l.size()); }
753  bool empty() const { return (l.empty()); }
754  bool equals(const Element& other) const;
755 
765  void sort(std::string const& index = std::string());
766 };
767 
768 class MapElement : public Element {
769  std::map<std::string, ConstElementPtr> m;
770 
771 public:
772  MapElement(const Position& pos = ZERO_POSITION()) : Element(map, pos) {}
773  // @todo should we have direct iterators instead of exposing the std::map
774  // here?
775  const std::map<std::string, ConstElementPtr>& mapValue() const override {
776  return (m);
777  }
778  using Element::getValue;
779  bool getValue(std::map<std::string, ConstElementPtr>& t) const override {
780  t = m;
781  return (true);
782  }
783  using Element::setValue;
784  bool setValue(const std::map<std::string, ConstElementPtr>& v) override {
785  m = v;
786  return (true);
787  }
788  using Element::get;
789  ConstElementPtr get(const std::string& s) const override {
790  auto found = m.find(s);
791  return (found != m.end() ? found->second : ConstElementPtr());
792  }
793 
800  ConstElementPtr get(int const i) const override {
801  auto it(m.begin());
802  std::advance(it, i);
803  return create(it->first);
804  }
805 
806  using Element::set;
807  void set(const std::string& key, ConstElementPtr value) override;
808  using Element::remove;
809  void remove(const std::string& s) override { m.erase(s); }
810 
814  void remove(int const i) override {
815  auto it(m.begin());
816  std::advance(it, i);
817  m.erase(it);
818  }
819 
820  bool contains(const std::string& s) const override {
821  return (m.find(s) != m.end());
822  }
823  void toJSON(std::ostream& ss) const override;
824 
825  // we should name the two finds better...
826  // find the element at id; raises TypeError if one of the
827  // elements at path except the one we're looking for is not a
828  // mapelement.
829  // returns an empty element if the item could not be found
830  ConstElementPtr find(const std::string& id) const override;
831 
832  // find the Element at 'id', and store the element pointer in t
833  // returns true if found, or false if not found (either because
834  // it doesn't exist or one of the elements in the path is not
835  // a MapElement)
836  bool find(const std::string& id, ConstElementPtr& t) const override;
837 
841  size_t size() const override {
842  return (m.size());
843  }
844 
845  bool equals(const Element& other) const override;
846 
847  bool empty() const override { return (m.empty()); }
848 };
849 
853 bool isNull(ConstElementPtr p);
854 
863 
870 
879 void merge(ElementPtr element, ConstElementPtr other);
880 
890 typedef std::function<bool (ElementPtr&, ElementPtr&)> MatchTestFunc;
891 
894 typedef std::function<bool (ElementPtr&)> NoDataTestFunc;
895 
897 typedef std::function<bool (const std::string&)> IsKeyTestFunc;
898 
905 };
906 
909 typedef std::map<std::string, HierarchyTraversalTest> FunctionMap;
910 
924 typedef std::vector<FunctionMap> HierarchyDescriptor;
925 
944 void mergeDiffAdd(ElementPtr& element, ElementPtr& other,
945  HierarchyDescriptor& hierarchy, std::string key,
946  size_t idx = 0);
947 
965 void mergeDiffDel(ElementPtr& element, ElementPtr& other,
966  HierarchyDescriptor& hierarchy, std::string key,
967  size_t idx = 0);
968 
985 void extend(const std::string& container, const std::string& extension,
986  ElementPtr& element, ElementPtr& other,
987  HierarchyDescriptor& hierarchy, std::string key, size_t idx = 0,
988  bool alter = false);
989 
1000 ElementPtr copy(ConstElementPtr from, int level = 100);
1001 
1008 
1020 void prettyPrint(ConstElementPtr element, std::ostream& out,
1021  unsigned indent = 0, unsigned step = 2);
1022 
1033 std::string prettyPrint(ConstElementPtr element,
1034  unsigned indent = 0, unsigned step = 2);
1035 
1046 std::ostream& operator<<(std::ostream& out, const Element::Position& pos);
1047 
1062 std::ostream& operator<<(std::ostream& out, const Element& e);
1063 
1064 bool operator==(const Element& a, const Element& b);
1065 bool operator!=(const Element& a, const Element& b);
1066 bool operator<(const Element& a, const Element& b);
1067 
1068 } // namespace data
1069 } // namespace isc
1070 
1071 #endif // ISC_DATA_H
1072 
1073 // Local Variables:
1074 // mode: c++
1075 // End:
This is a base class for exceptions thrown from the DNS library module.
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
Wrapper over int128_t.
Definition: data.h:630
bool setValue(const int128_t &v) override
Sets the underlying big integer value.
Definition: data.h:651
BigIntElement(const int128_t &v, const Position &pos=ZERO_POSITION())
Constructor.
Definition: data.h:637
int128_t bigIntValue() const override
Retrieve the underlying big integer value.
Definition: data.h:644
bool equals(const Element &other) const override
Checks whether the other Element is equal.
Definition: data.cc:1013
void toJSON(std::ostream &ss) const override
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:819
bool getValue(bool &t) const
Definition: data.h:694
bool setValue(const bool v)
Definition: data.h:696
void toJSON(std::ostream &ss) const
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:840
BoolElement(const bool v, const Position &pos=ZERO_POSITION())
Definition: data.h:690
bool boolValue() const
Definition: data.h:692
bool equals(const Element &other) const
Definition: data.cc:1030
bool setValue(const double v)
Definition: data.h:681
DoubleElement(double v, const Position &pos=ZERO_POSITION())
Definition: data.h:675
bool equals(const Element &other) const
Definition: data.cc:1024
double doubleValue() const
Definition: data.h:677
bool getValue(double &t) const
Definition: data.h:679
void toJSON(std::ostream &ss) const
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:824
The Element class represents a piece of data, used by the command channel and configuration parts.
Definition: data.h:72
static ElementPtr create(const Position &pos=ZERO_POSITION())
Definition: data.cc:246
virtual bool equals(const Element &other) const =0
types
The types that an Element can hold.
Definition: data.h:139
virtual bool getValue(int64_t &t) const
Definition: data.cc:70
static std::string typeToName(Element::types type)
Returns the name of the given type as a string.
Definition: data.cc:631
virtual int64_t intValue() const
Definition: data.h:234
std::string str() const
Returns a string representing the Element and all its child elements; note that this is different fro...
Definition: data.cc:51
virtual std::string stringValue() const
Definition: data.h:243
std::string toWire() const
Returns the wireformat for the Element and all its child elements.
Definition: data.cc:58
virtual const std::map< std::string, ConstElementPtr > & mapValue() const
Definition: data.h:249
static ElementPtr fromWire(std::stringstream &in, int length)
These function pparse the wireformat at the given stringstream (of the given length).
Definition: data.cc:967
virtual bool setValue(const long long int v)
Definition: data.cc:100
static ElementPtr fromJSONFile(const std::string &file_name, bool preproc=false)
Reads contents of specified file and interprets it as JSON.
Definition: data.cc:797
virtual const std::vector< ElementPtr > & listValue() const
Definition: data.h:245
static const Position & ZERO_POSITION()
Returns Position object with line_ and pos_ set to 0, and with an empty file name.
Definition: data.h:126
virtual bool empty() const
Return true if there are no elements in the list.
Definition: data.cc:165
virtual void remove(const int i)
Removes the element at the given position.
Definition: data.cc:155
void removeEmptyContainersRecursively()
Remove all empty maps and lists from this Element and its descendants.
Definition: data.h:562
virtual bool contains(const std::string &name) const
Checks if there is data at the given key.
Definition: data.cc:185
virtual ConstElementPtr find(const std::string &identifier) const
Recursively finds any data at the given identifier.
Definition: data.cc:190
const Position & getPosition() const
Returns position where the data element's value starts in a configuration string.
Definition: data.h:185
virtual size_t size() const
Returns the number of elements in the list.
Definition: data.cc:160
Element(types t, const Position &pos=ZERO_POSITION())
Constructor.
Definition: data.h:168
virtual void add(ElementPtr element)
Adds an ElementPtr to the list.
Definition: data.cc:150
virtual ~Element()
Definition: data.h:175
bool setValue(const long int i)
Definition: data.h:284
static ElementPtr fromJSON(const std::string &in, bool preproc=false)
These functions will parse the given string (JSON) representation of a compound element.
Definition: data.cc:778
virtual ConstElementPtr get(const int i) const
Returns the ElementPtr at the given index.
Definition: data.cc:135
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
Definition: data.cc:301
static Element::types nameToType(const std::string &type_name)
Converts the string to the corresponding type Throws a TypeError if the name is unknown.
Definition: data.cc:657
static ElementPtr createList(const Position &pos=ZERO_POSITION())
Creates an empty ListElement type ElementPtr.
Definition: data.cc:296
virtual void toJSON(std::ostream &ss) const =0
Converts the Element to JSON format and appends it to the given stringstream.
virtual void set(const size_t i, ElementPtr element)
Sets the ElementPtr at the given index.
Definition: data.cc:145
virtual double doubleValue() const
Definition: data.h:239
bool setValue(const int i)
Definition: data.h:285
virtual isc::util::int128_t bigIntValue() const
Definition: data.h:236
types getType() const
Definition: data.h:178
virtual bool boolValue() const
Definition: data.h:241
static void preprocess(std::istream &in, std::stringstream &out)
input text preprocessor
Definition: data.cc:1613
virtual ElementPtr getNonConst(const int i) const
returns element as non-const pointer
Definition: data.cc:140
Notes: IntElement type is changed to int64_t.
Definition: data.h:615
bool setValue(long long int v)
Definition: data.h:624
IntElement(int64_t v, const Position &pos=ZERO_POSITION())
Definition: data.h:618
bool equals(const Element &other) const
Definition: data.cc:1002
int64_t intValue() const
Definition: data.h:620
void toJSON(std::ostream &ss) const
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:814
bool getValue(int64_t &t) const
Definition: data.h:622
A standard Data module exception that is thrown if a parse error is encountered when constructing an ...
Definition: data.h:49
JSONError(const char *file, size_t line, const char *what)
Definition: data.h:51
void sort(std::string const &index=std::string())
Sorts the elements inside the list.
Definition: data.cc:1065
bool empty() const
Return true if there are no elements in the list.
Definition: data.h:753
void remove(int i)
Removes the element at the given position.
Definition: data.h:750
bool getValue(std::vector< ElementPtr > &t) const
Definition: data.h:732
void toJSON(std::ostream &ss) const
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:902
void add(ElementPtr e)
Adds an ElementPtr to the list.
Definition: data.h:748
const std::vector< ElementPtr > & listValue() const
Definition: data.h:730
ElementPtr getNonConst(int i) const
returns element as non-const pointer
Definition: data.h:743
void set(size_t i, ElementPtr e)
Sets the ElementPtr at the given index.
Definition: data.h:745
size_t size() const
Returns the number of elements in the list.
Definition: data.h:752
bool setValue(const std::vector< ElementPtr > &v)
Definition: data.h:737
bool equals(const Element &other) const
Definition: data.cc:1047
ListElement(const Position &pos=ZERO_POSITION())
Definition: data.h:728
ConstElementPtr get(int i) const
Returns the ElementPtr at the given index.
Definition: data.h:742
bool contains(const std::string &s) const override
Checks if there is data at the given key.
Definition: data.h:820
ConstElementPtr find(const std::string &id) const override
Recursively finds any data at the given identifier.
Definition: data.cc:939
ConstElementPtr get(const std::string &s) const override
Returns the ElementPtr at the given key.
Definition: data.h:789
bool equals(const Element &other) const override
Definition: data.cc:1101
bool setValue(const std::map< std::string, ConstElementPtr > &v) override
Definition: data.h:784
void toJSON(std::ostream &ss) const override
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:916
ConstElementPtr get(int const i) const override
Get the i-th element in the map.
Definition: data.h:800
virtual void set(const size_t i, ElementPtr element)
Sets the ElementPtr at the given index.
Definition: data.cc:145
bool empty() const override
Return true if there are no elements in the list.
Definition: data.h:847
void remove(int const i) override
Remove the i-th element from the map.
Definition: data.h:814
void remove(const std::string &s) override
Remove the ElementPtr at the given key.
Definition: data.h:809
bool getValue(std::map< std::string, ConstElementPtr > &t) const override
Definition: data.h:779
MapElement(const Position &pos=ZERO_POSITION())
Definition: data.h:772
size_t size() const override
Returns number of stored elements.
Definition: data.h:841
const std::map< std::string, ConstElementPtr > & mapValue() const override
Definition: data.h:775
bool equals(const Element &other) const
Definition: data.cc:1036
void toJSON(std::ostream &ss) const
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:849
NullElement(const Position &pos=ZERO_POSITION())
Definition: data.h:703
std::string stringValue() const
Definition: data.h:715
bool setValue(const std::string &v)
Definition: data.h:719
bool getValue(std::string &t) const
Definition: data.h:717
void toJSON(std::ostream &ss) const
Converts the Element to JSON format and appends it to the given stringstream.
Definition: data.cc:854
StringElement(std::string v, const Position &pos=ZERO_POSITION())
Definition: data.h:713
bool equals(const Element &other) const
Definition: data.cc:1041
A standard Data module exception that is thrown if a function is called for an Element that has a wro...
Definition: data.h:36
TypeError(const char *file, size_t line, const char *what)
Definition: data.h:38
#define throwTypeError(error)
Add the position to a TypeError message should be used in place of isc_throw(TypeError,...
Definition: data.h:205
ElementPtr copy(ConstElementPtr from, int level)
Copy the data up to a nesting level.
Definition: data.cc:1395
bool operator==(const Element &a, const Element &b)
Definition: data.cc:215
void mergeDiffAdd(ElementPtr &element, ElementPtr &other, HierarchyDescriptor &hierarchy, std::string key, size_t idx)
Merges the diff data by adding the missing elements from 'other' to 'element' (recursively).
Definition: data.cc:1192
void removeIdentical(ElementPtr a, ConstElementPtr b)
Remove all values from the first ElementPtr that are equal in the second.
Definition: data.cc:1128
void merge(ElementPtr element, ConstElementPtr other)
Merges the data from other into element.
Definition: data.cc:1174
void mergeDiffDel(ElementPtr &element, ElementPtr &other, HierarchyDescriptor &hierarchy, std::string key, size_t idx)
Merges the diff data by removing the data present in 'other' from 'element' (recursively).
Definition: data.cc:1253
std::map< std::string, HierarchyTraversalTest > FunctionMap
Mapping between a container name and functions used to match elements inside the container.
Definition: data.h:909
bool operator<(Element const &a, Element const &b)
Definition: data.cc:224
bool isEquivalent(ConstElementPtr a, ConstElementPtr b)
Compares the data with other using unordered lists.
Definition: data.cc:1517
void prettyPrint(ConstElementPtr element, std::ostream &out, unsigned indent, unsigned step)
Pretty prints the data into stream.
Definition: data.cc:1522
std::function< bool(ElementPtr &)> NoDataTestFunc
Function used to check if the data provided for the element contains only information used for identi...
Definition: data.h:894
boost::shared_ptr< const Element > ConstElementPtr
Definition: data.h:29
void extend(const std::string &container, const std::string &extension, ElementPtr &element, ElementPtr &other, HierarchyDescriptor &hierarchy, std::string key, size_t idx, bool alter)
Extends data by adding the specified 'extension' elements from 'other' inside the 'container' element...
Definition: data.cc:1343
bool isNull(ConstElementPtr p)
Checks whether the given ElementPtr is a NULL pointer.
Definition: data.cc:1123
std::function< bool(ElementPtr &, ElementPtr &)> MatchTestFunc
Function used to check if two MapElements refer to the same configuration data.
Definition: data.h:890
std::ostream & operator<<(std::ostream &out, const Element::Position &pos)
Insert Element::Position as a string into stream.
Definition: data.cc:45
std::function< bool(const std::string &)> IsKeyTestFunc
Function used to check if the key is used for identification.
Definition: data.h:897
bool operator!=(const Element &a, const Element &b)
Definition: data.cc:219
boost::shared_ptr< Element > ElementPtr
Definition: data.h:26
std::vector< FunctionMap > HierarchyDescriptor
Hierarchy descriptor of the containers in a specific Element hierarchy tree.
Definition: data.h:924
boost::multiprecision::int128_t int128_t
Definition: bigints.h:19
Defines the logger used by the top-level component of kea-lfc.
Represents the position of the data element within a configuration string.
Definition: data.h:94
Position(const std::string &file, const uint32_t line, const uint32_t pos)
Constructor.
Definition: data.h:108
uint32_t pos_
Position within the line.
Definition: data.h:97
std::string str() const
Returns the position in the textual format.
Definition: data.cc:38
Position()
Default constructor.
Definition: data.h:100
uint32_t line_
Line number.
Definition: data.h:96
std::string file_
File name.
Definition: data.h:95
Structure holding the test functions used to traverse the element hierarchy.
Definition: data.h:901