public this(const Flag!"useDefaultConstructors" defaultConstructors = Yes.useDefaultConstructors) @safe nothrow

Construct a Constructor.

/// If you don't want to support default YAML tags/data types, you can use defaultConstructors to disable constructor functions for these.

/// Params: defaultConstructors = Use constructors for default YAML tags?

public void addConstructorScalar(T)(
    const string tag, 
    T function(ref Node) ctor) @safe nothrow

Add a constructor function from scalar.

The function must take a reference to Node to construct from. The node contains a string for scalars, Node[] for sequences and Node.Pair[] for mappings.

Any exception thrown by this function will be caught by D:YAML and its message will be added to a YAMLException that will also tell the user which type failed to construct, and position in the file.

The value returned by this function will be stored in the resulting node.

Only one constructor function can be set for one tag.

Structs and classes must implement the opCmp() operator for D:YAML support. The signature of the operator that must be implemented is const int opCmp(ref const MyStruct s) for structs where MyStruct is the struct type, and int opCmp(Object o) for classes. Note that the class opCmp() should not alter the compared values - it is not const for compatibility reasons.

Parameters

tag	Tag for the function to handle.
ctor	Constructor function.

Example

 import std.string;

 import dyaml.all;

 struct MyStruct
 {
     int x, y, z;

     //Any D:YAML type must have a custom opCmp operator.
     //This is used for ordering in mappings.
     const int opCmp(ref const MyStruct s)
     {
         if(x != s.x){return x - s.x;}
         if(y != s.y){return y - s.y;}
         if(z != s.z){return z - s.z;}
         return 0;
     }
 }

 MyStruct constructMyStructScalar(ref Node node)
 {
     //Guaranteed to be string as we construct from scalar.
     //!mystruct x:y:z
     auto parts = node.as!string().split(":");
     // If this throws, the D:YAML will handle it and throw a YAMLException.
     return MyStruct(to!int(parts[0]), to!int(parts[1]), to!int(parts[2]));
 }

 void main()
 {
     auto loader = Loader("file.yaml");
     auto constructor = new Constructor;
     constructor.addConstructorScalar("!mystruct", &constructMyStructScalar);
     loader.constructor = constructor;
     Node node = loader.load();
 }

public void addConstructorSequence(T)(
    const string tag, 
    T function(ref Node) ctor) @safe nothrow

Add a constructor function from sequence.

Example

 import std.string;

 import dyaml.all;

 struct MyStruct
 {
     int x, y, z;

     //Any D:YAML type must have a custom opCmp operator.
     //This is used for ordering in mappings.
     const int opCmp(ref const MyStruct s)
     {
         if(x != s.x){return x - s.x;}
         if(y != s.y){return y - s.y;}
         if(z != s.z){return z - s.z;}
         return 0;
     }
 }

 MyStruct constructMyStructSequence(ref Node node)
 {
     //node is guaranteed to be sequence.
     //!mystruct [x, y, z]
     return MyStruct(node[0].as!int, node[1].as!int, node[2].as!int);
 }

 void main()
 {
     auto loader = Loader("file.yaml");
     auto constructor = new Constructor;
     constructor.addConstructorSequence("!mystruct", &constructMyStructSequence);
     loader.constructor = constructor;
     Node node = loader.load();
 }

addConstructorScalar

public void addConstructorMapping(T)(
    const string tag, 
    T function(ref Node) ctor) @safe nothrow

Add a constructor function from a mapping.

Example

 import std.string;

 import dyaml.all;

 struct MyStruct
 {
     int x, y, z;

     //Any D:YAML type must have a custom opCmp operator.
     //This is used for ordering in mappings.
     const int opCmp(ref const MyStruct s)
     {
         if(x != s.x){return x - s.x;}
         if(y != s.y){return y - s.y;}
         if(z != s.z){return z - s.z;}
         return 0;
     }
 }

 MyStruct constructMyStructMapping(ref Node node)
 {
     //node is guaranteed to be mapping.
     //!mystruct {"x": x, "y": y, "z": z}
     return MyStruct(node["x"].as!int, node["y"].as!int, node["z"].as!int);
 }

 void main()
 {
     auto loader = Loader("file.yaml");
     auto constructor = new Constructor;
     constructor.addConstructorMapping("!mystruct", &constructMyStructMapping);
     loader.constructor = constructor;
     Node node = loader.load();
 }

addConstructorScalar