LLVM  6.0.0svn
Classes | Namespaces | Macros | Functions
YAMLTraits.h File Reference
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/AlignOf.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/Regex.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <cctype>
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <new>
#include <string>
#include <system_error>
#include <type_traits>
#include <vector>
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::EmptyContext
 
struct  llvm::yaml::MappingTraits< T >
 This class should be specialized by any type that needs to be converted to/from a YAML mapping. More...
 
struct  llvm::yaml::MappingContextTraits< T, Context >
 This class is similar to MappingTraits<T> but allows you to pass in additional context for each map operation. More...
 
struct  llvm::yaml::ScalarEnumerationTraits< T >
 This class should be specialized by any integral type that converts to/from a YAML scalar where there is a one-to-one mapping between in-memory values and a string in YAML. More...
 
struct  llvm::yaml::ScalarBitSetTraits< T >
 This class should be specialized by any integer type that is a union of bit values and the YAML representation is a flow sequence of strings. More...
 
struct  llvm::yaml::ScalarTraits< T >
 This class should be specialized by type that requires custom conversion to/from a yaml scalar. More...
 
struct  llvm::yaml::BlockScalarTraits< T >
 This class should be specialized by type that requires custom conversion to/from a YAML literal block scalar. More...
 
struct  llvm::yaml::SequenceTraits< T, EnableIf >
 This class should be specialized by any type that needs to be converted to/from a YAML sequence. More...
 
struct  llvm::yaml::SequenceElementTraits< T, EnableIf >
 This class should be specialized by any type for which vectors of that type need to be converted to/from a YAML sequence. More...
 
struct  llvm::yaml::DocumentListTraits< T >
 This class should be specialized by any type that needs to be converted to/from a list of YAML documents. More...
 
struct  llvm::yaml::CustomMappingTraits< T >
 This class should be specialized by any type that needs to be converted to/from a YAML mapping in the case where the names of the keys are not known in advance, e.g. More...
 
struct  llvm::yaml::MissingTrait< T >
 
struct  llvm::yaml::has_ScalarEnumerationTraits< T >
 
struct  llvm::yaml::has_ScalarBitSetTraits< T >
 
struct  llvm::yaml::has_ScalarTraits< T >
 
struct  llvm::yaml::has_BlockScalarTraits< T >
 
struct  llvm::yaml::has_MappingTraits< T, Context >
 
struct  llvm::yaml::has_MappingTraits< T, EmptyContext >
 
struct  llvm::yaml::has_MappingValidateTraits< T, Context >
 
struct  llvm::yaml::has_MappingValidateTraits< T, EmptyContext >
 
struct  llvm::yaml::has_SequenceMethodTraits< T >
 
struct  llvm::yaml::has_CustomMappingTraits< 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, Context >
 
struct  llvm::yaml::validatedMappingTraits< T, Context >
 
struct  llvm::yaml::unvalidatedMappingTraits< T, Context >
 
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::ScalarTraits< support::detail::packed_endian_specific_integral< value_type, endian, alignment > >
 
struct  llvm::yaml::MappingNormalization< TNorm, TFinal >
 
struct  llvm::yaml::MappingNormalizationHeap< TNorm, TFinal >
 
class  llvm::yaml::Input
 The Input class is used to parse a yaml document into in-memory structs and vectors. More...
 
class  llvm::yaml::Output
 The Output class is used to generate a yaml document from in-memory structs and vectors. More...
 
struct  llvm::yaml::ScalarTraits< Hex8 >
 Use these types instead of uintXX_t in any mapping to have its yaml output formatted as hexadecimal. More...
 
struct  llvm::yaml::ScalarTraits< Hex16 >
 
struct  llvm::yaml::ScalarTraits< Hex32 >
 
struct  llvm::yaml::ScalarTraits< Hex64 >
 
struct  llvm::yaml::IsFlowSequenceBase< B >
 
struct  llvm::yaml::IsFlowSequenceBase< true >
 
struct  llvm::yaml::SequenceTraitsImpl< T, Flow >
 
struct  llvm::yaml::CheckIsBool< bool >
 
struct  llvm::yaml::SequenceTraits< std::vector< T >, typename std::enable_if< CheckIsBool< SequenceElementTraits< T >::flow >::value >::type >
 
struct  llvm::yaml::SequenceTraits< SmallVector< T, N >, typename std::enable_if< CheckIsBool< SequenceElementTraits< T >::flow >::value >::type >
 
struct  llvm::yaml::SequenceElementTraits< T, typename std::enable_if< std::is_fundamental< T >::value >::type >
 
struct  llvm::yaml::SequenceElementTraits< std::string >
 
struct  llvm::yaml::SequenceElementTraits< StringRef >
 
struct  llvm::yaml::SequenceElementTraits< std::pair< std::string, std::string > >
 
struct  llvm::yaml::StdMapStringCustomMappingTraitsImpl< T >
 Implementation of CustomMappingTraits for std::map<std::string, T>. More...
 

Namespaces

 llvm
 Compute iterated dominance frontiers using a linear time algorithm.
 
 llvm::yaml
 
 llvm::yaml::detail
 

Macros

#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)
 YAML I/O does conversion based on types. More...
 
#define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW)
 
#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)   LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false)
 Utility for declaring that a std::vector of a particular type should be considered a YAML sequence. More...
 
#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type)   LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true)
 Utility for declaring that a std::vector of a particular type should be considered a YAML flow sequence. More...
 
#define LLVM_YAML_DECLARE_MAPPING_TRAITS(Type)
 
#define LLVM_YAML_DECLARE_ENUM_TRAITS(Type)
 
#define LLVM_YAML_DECLARE_BITSET_TRAITS(Type)
 
#define LLVM_YAML_DECLARE_SCALAR_TRAITS(Type, MustQuote)
 
#define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type)
 Utility for declaring that a std::vector of a particular type should be considered a YAML document list. More...
 
#define LLVM_YAML_IS_STRING_MAP(_type)
 Utility for declaring that std::map<std::string, _type> should be considered a YAML map. More...
 

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 , typename Context >
void llvm::yaml::detail::doMapping (IO &io, T &Val, Context &Ctx)
 
template<typename T >
void llvm::yaml::detail::doMapping (IO &io, T &Val, EmptyContext &Ctx)
 
template<typename T >
std::enable_if< has_ScalarEnumerationTraits< T >::value, void >::type llvm::yaml::yamlize (IO &io, T &Val, bool, EmptyContext &Ctx)
 
template<typename T >
std::enable_if< has_ScalarBitSetTraits< T >::value, void >::type llvm::yaml::yamlize (IO &io, T &Val, bool, EmptyContext &Ctx)
 
template<typename T >
std::enable_if< has_ScalarTraits< T >::value, void >::type llvm::yaml::yamlize (IO &io, T &Val, bool, EmptyContext &Ctx)
 
template<typename T >
std::enable_if< has_BlockScalarTraits< T >::value, void >::type llvm::yaml::yamlize (IO &YamlIO, T &Val, bool, EmptyContext &Ctx)
 
template<typename T , typename Context >
std::enable_if< validatedMappingTraits< T, Context >::value, void >::type llvm::yaml::yamlize (IO &io, T &Val, bool, Context &Ctx)
 
template<typename T , typename Context >
std::enable_if< unvalidatedMappingTraits< T, Context >::value, void >::type llvm::yaml::yamlize (IO &io, T &Val, bool, Context &Ctx)
 
template<typename T >
std::enable_if< has_CustomMappingTraits< T >::value, void >::type llvm::yaml::yamlize (IO &io, T &Val, bool, EmptyContext &Ctx)
 
template<typename T >
std::enable_if< missingTraits< T, EmptyContext >::value, void >::type llvm::yaml::yamlize (IO &io, T &Val, bool, EmptyContext &Ctx)
 
template<typename T , typename Context >
std::enable_if< has_SequenceTraits< T >::value, void >::type llvm::yaml::yamlize (IO &io, T &Seq, bool, Context &Ctx)
 
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_MappingTraits< T, EmptyContext >::value, Input & >::type llvm::yaml::operator>> (Input &yin, T &docMap)
 
template<typename T >
std::enable_if< has_SequenceTraits< T >::value, Input & >::type llvm::yaml::operator>> (Input &yin, T &docSeq)
 
template<typename T >
std::enable_if< has_BlockScalarTraits< T >::value, Input & >::type llvm::yaml::operator>> (Input &In, T &Val)
 
template<typename T >
std::enable_if< has_CustomMappingTraits< T >::value, Input & >::type llvm::yaml::operator>> (Input &In, T &Val)
 
template<typename T >
std::enable_if< missingTraits< T, EmptyContext >::value, Input & >::type llvm::yaml::operator>> (Input &yin, T &docSeq)
 
template<typename T >
std::enable_if< has_DocumentListTraits< T >::value, Output & >::type llvm::yaml::operator<< (Output &yout, T &docList)
 
template<typename T >
std::enable_if< has_MappingTraits< T, EmptyContext >::value, Output & >::type llvm::yaml::operator<< (Output &yout, T &map)
 
template<typename T >
std::enable_if< has_SequenceTraits< T >::value, Output & >::type llvm::yaml::operator<< (Output &yout, T &seq)
 
template<typename T >
std::enable_if< has_BlockScalarTraits< T >::value, Output & >::type llvm::yaml::operator<< (Output &Out, T &Val)
 
template<typename T >
std::enable_if< has_CustomMappingTraits< T >::value, Output & >::type llvm::yaml::operator<< (Output &Out, T &Val)
 
template<typename T >
std::enable_if< missingTraits< T, EmptyContext >::value, Output & >::type llvm::yaml::operator<< (Output &yout, T &seq)
 

Macro Definition Documentation

◆ LLVM_YAML_DECLARE_BITSET_TRAITS

#define LLVM_YAML_DECLARE_BITSET_TRAITS (   Type)
Value:
namespace llvm { \
namespace yaml { \
template <> struct ScalarBitSetTraits<Type> { \
static void bitset(IO &IO, Type &Options); \
}; \
} \
}
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24

Definition at line 1669 of file YAMLTraits.h.

◆ LLVM_YAML_DECLARE_ENUM_TRAITS

#define LLVM_YAML_DECLARE_ENUM_TRAITS (   Type)
Value:
namespace llvm { \
namespace yaml { \
template <> struct ScalarEnumerationTraits<Type> { \
static void enumeration(IO &io, Type &Value); \
}; \
} \
}
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24

Definition at line 1660 of file YAMLTraits.h.

◆ LLVM_YAML_DECLARE_MAPPING_TRAITS

#define LLVM_YAML_DECLARE_MAPPING_TRAITS (   Type)
Value:
namespace llvm { \
namespace yaml { \
template <> struct MappingTraits<Type> { \
static void mapping(IO &IO, Type &Obj); \
}; \
} \
}
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24

Definition at line 1651 of file YAMLTraits.h.

◆ LLVM_YAML_DECLARE_SCALAR_TRAITS

#define LLVM_YAML_DECLARE_SCALAR_TRAITS (   Type,
  MustQuote 
)
Value:
namespace llvm { \
namespace yaml { \
template <> struct ScalarTraits<Type> { \
static void output(const Type &Value, void *ctx, raw_ostream &Out); \
static StringRef input(StringRef Scalar, void *ctxt, Type &Value); \
static bool mustQuote(StringRef) { return MustQuote; } \
}; \
} \
}
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24

Definition at line 1678 of file YAMLTraits.h.

◆ LLVM_YAML_IS_DOCUMENT_LIST_VECTOR

#define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR (   _type)
Value:
namespace llvm { \
namespace yaml { \
template <unsigned N> \
struct DocumentListTraits<SmallVector<_type, N>> \
: public SequenceTraitsImpl<SmallVector<_type, N>, false> {}; \
template <> \
struct DocumentListTraits<std::vector<_type>> \
: public SequenceTraitsImpl<std::vector<_type>, false> {}; \
} \
}
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24

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

Definition at line 1691 of file YAMLTraits.h.

◆ LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR

#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR (   type)    LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true)

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

Definition at line 1648 of file YAMLTraits.h.

Referenced by llvm::yaml::ScalarEnumerationTraits< MachineJumpTableInfo::JTEntryKind >::enumeration().

◆ LLVM_YAML_IS_SEQUENCE_VECTOR

#define LLVM_YAML_IS_SEQUENCE_VECTOR (   type)    LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false)

◆ LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL

#define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL (   TYPE,
  FLOW 
)
Value:
namespace llvm { \
namespace yaml { \
static_assert( \
!std::is_fundamental<TYPE>::value && \
!std::is_same<TYPE, std::string>::value && \
!std::is_same<TYPE, llvm::StringRef>::value, \
"only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"); \
template <> struct SequenceElementTraits<TYPE> { \
static const bool flow = FLOW; \
}; \
} \
}
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24

Definition at line 1627 of file YAMLTraits.h.

◆ LLVM_YAML_IS_STRING_MAP

#define LLVM_YAML_IS_STRING_MAP (   _type)
Value:
namespace llvm { \
namespace yaml { \
template <> \
struct CustomMappingTraits<std::map<std::string, _type>> \
: public StdMapStringCustomMappingTraitsImpl<_type> {}; \
} \
}
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24

Utility for declaring that std::map<std::string, _type> should be considered a YAML map.

Definition at line 1705 of file YAMLTraits.h.

Referenced by llvm::yaml::MappingTraits< FunctionSummaryYaml >::mapping().

◆ LLVM_YAML_STRONG_TYPEDEF

#define LLVM_YAML_STRONG_TYPEDEF (   _base,
  _type 
)
Value:
struct _type { \
_type() = default; \
_type(const _base v) : value(v) {} \
_type(const _type &v) = default; \
_type &operator=(const _type &rhs) = default; \
_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; \
using BaseType = _base; \
};
BaseType
A given derived pointer can have multiple base pointers through phi/selects.
bool operator<(int64_t V1, const APSInt &V2)
Definition: APSInt.h:326
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1946

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 1346 of file YAMLTraits.h.

Referenced by llvm::yaml::MappingTraits< ELFYAML::Object >::mapping().