yaml-cpp/node/node.h

0001 #ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
0002 #define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
0003
0004 #if defined(_MSC_VER) ||                                            \
0005     (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
0006      (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
0007 #pragma once
0008 #endif
0009
0010 #include <stdexcept>
0011 #include <string>
0012
0013 #include "ATOOLS/YAML/yaml-cpp/dll.h"
0014 #include "ATOOLS/YAML/yaml-cpp/emitterstyle.h"
0015 #include "ATOOLS/YAML/yaml-cpp/mark.h"
0016 #include "ATOOLS/YAML/yaml-cpp/node/detail/iterator_fwd.h"
0017 #include "ATOOLS/YAML/yaml-cpp/node/ptr.h"
0018 #include "ATOOLS/YAML/yaml-cpp/node/type.h"
0019
0020 namespace SHERPA_YAML {
0021 namespace detail {
0022 class node;
0023 class node_data;
0024 struct iterator_value;
0025 }  // namespace detail
0026 }  // namespace SHERPA_YAML
0027
0028 namespace SHERPA_YAML {
0029 class YAML_CPP_API Node {
0030  public:
0031   friend class NodeBuilder;
0032   friend class NodeEvents;
0033   friend struct detail::iterator_value;
0034   friend class detail::node;
0035   friend class detail::node_data;
0036   template <typename>
0037   friend class detail::iterator_base;
0038   template <typename T, typename S>
0039   friend struct as_if;
0040
0041   using iterator = SHERPA_YAML::iterator;
0042   using const_iterator = SHERPA_YAML::const_iterator;
0043
0044   Node();
0045   explicit Node(NodeType::value type);
0046   template <typename T>
0047   explicit Node(const T& rhs);
0048   explicit Node(const detail::iterator_value& rhs);
0049   Node(const Node& rhs);
0050   ~Node();
0051
0052   SHERPA_YAML::Mark Mark() const;
0053   NodeType::value Type() const;
0054   bool IsDefined() const;
0055   bool IsNull() const { return Type() == NodeType::Null; }
0056   bool IsScalar() const { return Type() == NodeType::Scalar; }
0057   bool IsSequence() const { return Type() == NodeType::Sequence; }
0058   bool IsMap() const { return Type() == NodeType::Map; }
0059
0060   // bool conversions
0061   explicit operator bool() const { return IsDefined(); }
0062   bool operator!() const { return !IsDefined(); }
0063
0064   // access
0065   template <typename T>
0066   T as() const;
0067   template <typename T, typename S>
0068   T as(const S& fallback) const;
0069   const std::string& Scalar() const;
0070
0071   const std::string& Tag() const;
0072   void SetTag(const std::string& tag);
0073
0074   // style
0075   // WARNING: This API might change in future releases.
0076   EmitterStyle::value Style() const;
0077   void SetStyle(EmitterStyle::value style);
0078
0079   // assignment
0080   bool is(const Node& rhs) const;
0081   template <typename T>
0082   Node& operator=(const T& rhs);
0083   Node& operator=(const Node& rhs);
0084   void reset(const Node& rhs = Node());
0085
0086   // size/iterator
0087   std::size_t size() const;
0088
0089   const_iterator begin() const;
0090   iterator begin();
0091
0092   const_iterator end() const;
0093   iterator end();
0094
0095   // sequence
0096   template <typename T>
0097   void push_back(const T& rhs);
0098   void push_back(const Node& rhs);
0099
0100   // indexing
0101   template <typename Key>
0102   const Node operator[](const Key& key) const;
0103   template <typename Key>
0104   Node operator[](const Key& key);
0105   template <typename Key>
0106   bool remove(const Key& key);
0107
0108   const Node operator[](const Node& key) const;
0109   Node operator[](const Node& key);
0110   bool remove(const Node& key);
0111
0112   // map
0113   template <typename Key, typename Value>
0114   void force_insert(const Key& key, const Value& value);
0115
0116  private:
0117   enum Zombie { ZombieNode };
0118   explicit Node(Zombie);
0119   explicit Node(Zombie, const std::string&);
0120   explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
0121
0122   void EnsureNodeExists() const;
0123
0124   template <typename T>
0125   void Assign(const T& rhs);
0126   void Assign(const char* rhs);
0127   void Assign(char* rhs);
0128
0129   void AssignData(const Node& rhs);
0130   void AssignNode(const Node& rhs);
0131
0132  private:
0133   bool m_isValid;
0134   // String representation of invalid key, if the node is invalid.
0135   std::string m_invalidKey;
0136   mutable detail::shared_memory_holder m_pMemory;
0137   mutable detail::node* m_pNode;
0138 };
0139
0140 YAML_CPP_API bool operator==(const Node& lhs, const Node& rhs);
0141
0142 YAML_CPP_API Node Clone(const Node& node);
0143
0144 template <typename T>
0145 struct convert;
0146 }
0147
0148 #endif  // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66