node.h

Go to the documentation of this file.

#ifndef NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once
#endif


#include "yaml-cpp-pm/dll.h"
#include "yaml-cpp-pm/exceptions.h"
#include "yaml-cpp-pm/mark.h"
#include "yaml-cpp-pm/noncopyable.h"
#include "yaml-cpp-pm/conversion.h"
#include "yaml-cpp-pm/iterator.h"
#include "yaml-cpp-pm/ltnode.h"
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>

namespace YAML_PM
{
        class AliasManager;
        class Content;
        class NodeOwnership;
        class Scanner;
        class Emitter;
        class EventHandler;

        struct NodeType { enum value { Null, Scalar, Sequence, Map }; };

        class YAML_CPP_API Node: private noncopyable
        {
        public:
                friend class NodeOwnership;
                friend class NodeBuilder;
                
                Node();
                ~Node();

                void Clear();
                std::auto_ptr<Node> Clone() const;
                void EmitEvents(EventHandler& eventHandler) const;
                void EmitEvents(AliasManager& am, EventHandler& eventHandler) const;
                
                NodeType::value Type() const { return m_type; }
                bool IsAliased() const;

                // file location of start of this node
                const Mark GetMark() const { return m_mark; }

                // accessors
                Iterator begin() const;
                Iterator end() const;
                std::size_t size() const;

                // extraction of scalars
                bool GetScalar(std::string& s) const;

                // we can specialize this for other values
                template <typename T>
                bool Read(T& value) const;

                template <typename T>
                const T to() const;

                template <typename T>
                friend YAML_CPP_API typename enable_if<is_scalar_convertible<T> >::type operator >> (const Node& node, T& value);

                // retrieval for maps and sequences
                template <typename T>
                const Node *FindValue(const T& key) const;

                template <typename T>
                const Node& operator [] (const T& key) const;
                
                // specific to maps
                const Node *FindValue(const char *key) const;
                const Node *FindValue(char *key) const;
                const Node& operator [] (const char *key) const;
                const Node& operator [] (char *key) const;

                // for tags
                const std::string& Tag() const { return m_tag; }

                // emitting
                friend YAML_CPP_API Emitter& operator << (Emitter& out, const Node& node);

                // ordering
                int Compare(const Node& rhs) const;
                friend bool operator < (const Node& n1, const Node& n2);

        private:
                explicit Node(NodeOwnership& owner);
                Node& CreateNode();
                
                void Init(NodeType::value type, const Mark& mark, const std::string& tag);
                
                void MarkAsAliased();
                void SetScalarData(const std::string& data);
                void Append(Node& node);
                void Insert(Node& key, Node& value);

                // helper for sequences
                template <typename, bool> friend struct _FindFromNodeAtIndex;
                const Node *FindAtIndex(std::size_t i) const;
                
                // helper for maps
                template <typename T>
                const Node& GetValue(const T& key) const;

                template <typename T>
                const Node *FindValueForKey(const T& key) const;

        private:
                std::auto_ptr<NodeOwnership> m_pOwnership;

                Mark m_mark;
                std::string m_tag;

                typedef std::vector<Node *> node_seq;
                typedef std::map<Node *, Node *, ltnode> node_map;

                NodeType::value m_type;
                std::string m_scalarData;
                node_seq m_seqData;
                node_map m_mapData;
        };
}

#include "yaml-cpp-pm/nodeimpl.h"
#include "yaml-cpp-pm/nodereadimpl.h"

#endif // NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66