YAMLTraits.h File Reference

#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Regex.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/raw_ostream.h"
#include <system_error>

Include dependency graph for YAMLTraits.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	llvm::yaml::MappingTraits< T >
struct	llvm::yaml::ScalarEnumerationTraits< T >
struct	llvm::yaml::ScalarBitSetTraits< T >
struct	llvm::yaml::ScalarTraits< T >
struct	llvm::yaml::SequenceTraits< T >
struct	llvm::yaml::DocumentListTraits< T >
struct	llvm::yaml::has_ScalarEnumerationTraits< T >
struct	llvm::yaml::has_ScalarBitSetTraits< T >
struct	llvm::yaml::has_ScalarTraits< T >
struct	llvm::yaml::has_MappingTraits< T >
struct	llvm::yaml::has_MappingValidateTraits< T >
struct	llvm::yaml::has_SequenceMethodTraits< T >
class	llvm::yaml::has_FlowTraits< T, Enabled >
struct	llvm::yaml::has_FlowTraits< T, true >
struct	llvm::yaml::has_FlowTraits< T, true >::Fallback
struct	llvm::yaml::has_FlowTraits< T, true >::Derived
struct	llvm::yaml::has_SequenceTraits< T >
struct	llvm::yaml::has_DocumentListTraits< T >
struct	llvm::yaml::missingTraits< T >
struct	llvm::yaml::validatedMappingTraits< T >
struct	llvm::yaml::unvalidatedMappingTraits< T >
class	llvm::yaml::IO
struct	llvm::yaml::ScalarTraits< bool >
struct	llvm::yaml::ScalarTraits< StringRef >
struct	llvm::yaml::ScalarTraits< std::string >
struct	llvm::yaml::ScalarTraits< uint8_t >
struct	llvm::yaml::ScalarTraits< uint16_t >
struct	llvm::yaml::ScalarTraits< uint32_t >
struct	llvm::yaml::ScalarTraits< uint64_t >
struct	llvm::yaml::ScalarTraits< int8_t >
struct	llvm::yaml::ScalarTraits< int16_t >
struct	llvm::yaml::ScalarTraits< int32_t >
struct	llvm::yaml::ScalarTraits< int64_t >
struct	llvm::yaml::ScalarTraits< float >
struct	llvm::yaml::ScalarTraits< double >
struct	llvm::yaml::MappingNormalization< TNorm, TFinal >
struct	llvm::yaml::MappingNormalizationHeap< TNorm, TFinal >
class	llvm::yaml::Input
class	llvm::yaml::Input::HNode
class	llvm::yaml::Input::EmptyHNode
class	llvm::yaml::Input::ScalarHNode
class	llvm::yaml::Input::MapHNode
class	llvm::yaml::Input::SequenceHNode
class	llvm::yaml::Output
struct	llvm::yaml::ScalarTraits< Hex8 >
struct	llvm::yaml::ScalarTraits< Hex16 >
struct	llvm::yaml::ScalarTraits< Hex32 >
struct	llvm::yaml::ScalarTraits< Hex64 >
Namespaces
namespace	llvm
	List of target independent CodeGen pass IDs.
namespace	llvm::yaml
Defines
#define	LLVM_YAML_STRONG_TYPEDEF(_base, _type)
#define	LLVM_YAML_IS_SEQUENCE_VECTOR(_type)
#define	LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(_type)
#define	LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type)
Functions
bool	llvm::yaml::isNumber (StringRef S)
bool	llvm::yaml::isNumeric (StringRef S)
bool	llvm::yaml::isNull (StringRef S)
bool	llvm::yaml::isBool (StringRef S)
bool	llvm::yaml::needsQuotes (StringRef S)
template<typename T >
std::enable_if < has_ScalarEnumerationTraits < T >::value, void >::type	llvm::yaml::yamlize (IO &io, T &Val, bool)
template<typename T >
std::enable_if < has_DocumentListTraits< T > ::value, Input & >::type	llvm::yaml::operator>> (Input &yin, T &docList)
template<typename T >
std::enable_if < has_DocumentListTraits< T > ::value, Output & >::type	llvm::yaml::operator<< (Output &yout, T &docList)

---

Define Documentation

#define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR

(

_type

)

Value:

namespace llvm {                                                          \
  namespace yaml {                                                          \
    template<>                                                              \
    struct DocumentListTraits< std::vector<_type> > {                       \
      static size_t size(IO &io, std::vector<_type> &seq) {                 \
        return seq.size();                                                  \
      }                                                                     \
      static _type& element(IO &io, std::vector<_type> &seq, size_t index) {\
        if ( index >= seq.size() )                                          \
          seq.resize(index+1);                                              \
        return seq[index];                                                  \
      }                                                                     \
    };                                                                      \
  }                                                                         \
  }

Utility for declaring that a std::vector of a particular type should be considered a YAML document list.

Definition at line 1277 of file YAMLTraits.h.

#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR

(

_type

)

Value:

namespace llvm {                                                          \
  namespace yaml {                                                          \
    template<>                                                              \
    struct SequenceTraits< std::vector<_type> > {                           \
      static size_t size(IO &io, std::vector<_type> &seq) {                 \
        return seq.size();                                                  \
      }                                                                     \
      static _type& element(IO &io, std::vector<_type> &seq, size_t index) {\
        (void)flow; /* Remove this workaround after PR17897 is fixed */     \
        if ( index >= seq.size() )                                          \
          seq.resize(index+1);                                              \
        return seq[index];                                                  \
      }                                                                     \
      static const bool flow = true;                                        \
    };                                                                      \
  }                                                                         \
  }

Utility for declaring that a std::vector of a particular type should be considered a YAML flow sequence.

Definition at line 1256 of file YAMLTraits.h.

#define LLVM_YAML_IS_SEQUENCE_VECTOR

(

_type

)

Value:

namespace llvm {                                                          \
  namespace yaml {                                                          \
    template<>                                                              \
    struct SequenceTraits< std::vector<_type> > {                           \
      static size_t size(IO &io, std::vector<_type> &seq) {                 \
        return seq.size();                                                  \
      }                                                                     \
      static _type& element(IO &io, std::vector<_type> &seq, size_t index) {\
        if ( index >= seq.size() )                                          \
          seq.resize(index+1);                                              \
        return seq[index];                                                  \
      }                                                                     \
    };                                                                      \
  }                                                                         \
  }

Utility for declaring that a std::vector of a particular type should be considered a YAML sequence.

Definition at line 1237 of file YAMLTraits.h.

#define LLVM_YAML_STRONG_TYPEDEF	(		_base,
			_type
	)

Value:

struct _type {                                                             \
        _type() { }                                                            \
        _type(const _base v) : value(v) { }                                    \
        _type(const _type &v) : value(v.value) {}                              \
        _type &operator=(const _type &rhs) { value = rhs.value; return *this; }\
        _type &operator=(const _base &rhs) { value = rhs; return *this; }      \
        operator const _base & () const { return value; }                      \
        bool operator==(const _type &rhs) const { return value == rhs.value; } \
        bool operator==(const _base &rhs) const { return value == rhs; }       \
        bool operator<(const _type &rhs) const { return value < rhs.value; }   \
        _base value;                                                           \
    };

YAML I/O does conversion based on types. But often native data types are just a typedef of built in intergral types (e.g. int). But the C++ type matching system sees through the typedef and all the typedefed types look like a built in type. This will cause the generic YAML I/O conversion to be used. To provide better control over the YAML conversion, you can use this macro instead of typedef. It will create a class with one field and automatic conversion operators to and from the base type. Based on BOOST_STRONG_TYPEDEF

Definition at line 1074 of file YAMLTraits.h.