node.h

Go to the documentation of this file.

#pragma once

#ifndef NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66


#include "conversion.h"
#include "exceptions.h"
#include "iterator.h"
#include "mark.h"
#include "noncopyable.h"
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <memory>

namespace YAML
{
        class Content;
        class Scanner;
        class Emitter;
        struct ParserState;

        enum CONTENT_TYPE { CT_NONE, CT_SCALAR, CT_SEQUENCE, CT_MAP };

        class Node: private noncopyable
        {
        public:
                Node();
                ~Node();

                void Clear();
                std::auto_ptr<Node> Clone() const;
                void Parse(Scanner *pScanner, ParserState& state);

                CONTENT_TYPE GetType() 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 Read() const;
                
                template <typename T>
                operator T() const;

                template <typename T>
                friend void 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& operator [] (const char *key) const;

                // for anchors/aliases
                const Node *Identity() const { return m_pIdentity; }
                bool IsAlias() const { return m_alias; }
                bool IsReferenced() const { return m_referenced; }
                
                // for tags
                const std::string GetTag() const { return IsAlias() ? m_pIdentity->GetTag() : m_tag; }

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

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

        private:
                // 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;
                
                // helper for cloning
                Node(const Mark& mark, const std::string& anchor, const std::string& tag, const Content *pContent);

                // helpers for parsing
                void ParseHeader(Scanner *pScanner, ParserState& state);
                void ParseTag(Scanner *pScanner, ParserState& state);
                void ParseAnchor(Scanner *pScanner, ParserState& state);
                void ParseAlias(Scanner *pScanner, ParserState& state);

        private:
                Mark m_mark;
                std::string m_anchor, m_tag;
                Content *m_pContent;
                bool m_alias;
                const Node *m_pIdentity;
                mutable bool m_referenced;
        };
        
        // comparisons with auto-conversion
        template <typename T>
        bool operator == (const T& value, const Node& node);
        
        template <typename T>
        bool operator == (const Node& node, const T& value);
        
        template <typename T>
        bool operator != (const T& value, const Node& node);
        
        template <typename T>
        bool operator != (const Node& node, const T& value);
        
        bool operator == (const char *value, const Node& node);
        bool operator == (const Node& node, const char *value);
        bool operator != (const char *value, const Node& node);
        bool operator != (const Node& node, const char *value);
}

#include "nodeimpl.h"
#include "nodereadimpl.h"

#endif // NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

---

yaml_cpp
Author(s): Jesse Beder
autogenerated on Fri Jan 11 09:42:43 2013