Initial commit.

doc/html/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: bc848a1b422611af46aa082001644165
+tags: fbb0d17656682115ca4d033fb2f83ba1

doc/html/_sources/articles/spec_differences.txt

@@ -0,0 +1,65 @@
+.. highlight:: yaml
+
+=====================================================
+Differences between D:YAML and the YAML specification
+=====================================================
+
+There are some differences between D:YAML and the YAML 1.1 specification. Some 
+are caused by difficulty of implementation of some features, such as multiple 
+Unicode encodings within single stream, and some by unnecessary restrictions or
+ambiguities in the specification. 
+
+Still, D:YAML tries to be as close to the specification as possible. D:YAML should
+never load documents with different meaning than according to the specification, 
+and documents that fail to load should be very rare (for instance, very few 
+files use multiple Unicode encodings).
+
+
+--------------------------
+List of known differences:
+--------------------------
+
+Differences that can cause valid YAML documents not to load:
+
+* At the moment, all mappings in the internal representation are ordered,
+  and a comparison for equality between equal mappings with differing order
+  will return false. This will be fixed once Phobos has a usable map type or
+  D associative arrays work with variants.
+* No support for byte order marks and multiple Unicode encodings in a stream.
+* Plain scalars in flow context cannot contain ``,``, ``:`` and ``?``.
+  This might change with ``:`` in the future. 
+  See http://pyyaml.org/wiki/YAMLColonInFlowContext for details.
+* The specification does not restrict characters for anchors and
+  aliases. This may lead to problems, for instance, the document::
+
+     [ *alias, value ]
+
+  can be interpteted in two ways, as::
+
+     [ "value" ]
+
+  and::
+
+     [ *alias , "value" ]
+
+  Therefore we restrict aliases and anchors to ASCII alphanumeric characters.
+* The specification is confusing about tabs in plain scalars. We don't use tabs 
+  in plain scalars at all.
+* There is no support for recursive data structures in DYAML.
+
+Other differences:
+
+* Indentation is ignored in the flow context, which is less restrictive than the
+  specification. This allows code such as::
+
+     key: {
+     }
+
+* Indentation rules for quoted scalars are loosed: They don't need to adhere
+  indentation as ``"`` and ``'`` clearly mark the beginning and the end of them.
+* We allow ``_`` in tag handles.
+* Right now, two mappings with the same contents but different orderings are 
+  considered unequal, even if they are unordered mappings. This is because all
+  mappings are ordered in the D:YAML implementation. This should change in 
+  future, once D associative arrays work with variant types or a map class or 
+  struct appears in Phobos.

doc/html/_sources/index.txt

@@ -0,0 +1,21 @@
+================================
+Welcome to D:YAML documentation!
+================================
+
+`API Documentation <api/index.html>`_
+
+Tutorials:
+
+.. toctree::
+   :maxdepth: 2
+
+   tutorials/getting_started
+   tutorials/custom_types 
+   tutorials/yaml_syntax 
+
+Articles:
+
+.. toctree::
+   :maxdepth: 2
+
+   articles/spec_differences

doc/html/_sources/tutorials/custom_types.txt

@@ -0,0 +1,227 @@
+======================
+Custom YAML data types
+======================
+
+Often you will want to serialize complex data types such as classes. You can use
+functions to process nodes; e.g. a mapping containing class data members indexed 
+by name. Alternatively, YAML supports custom data types using identifiers called
+*tags*. That is the topic of this tutorial.
+
+Each YAML node has a tag specifying its type. For instance: strings use the tag 
+``tag:yaml.org,2002:str``. Tags of most default types are *implicitly resolved* 
+during parsing, so you don't need to specify tag for each float, integer, etc.
+It is also possible to implicitly resolve custom tags, as we will show later.
+
+
+-----------
+Constructor
+-----------
+
+D:YAML uses the *Constructor* class to process each node to hold data type
+corresponding to its tag. *Constructor* stores a function for each supported 
+tag to process it. These functions can be supplied by the user using the 
+*addConstructor()* method. *Constructor* is then passed to *Loader*, which will
+parse YAML input.
+
+We will implement support for an RGB color type. It is implemented as the 
+following struct:
+
+.. code-block:: d
+    
+   struct Color
+   {
+       ubyte red;
+       ubyte green;
+       ubyte blue;
+   }
+
+First, we need a function to construct our data type. It must take two *Mark* 
+structs, which store position of the node in the file, and either a *string*, an
+array of *Node* or of *Node.Pair*, depending on whether we're constructing our 
+value from a scalar, sequence, or mapping, respectively. In this tutorial, we 
+have functions to construct a color from a scalar, using HTML-like format, 
+RRGGBB, or from a mapping, where we use the following format: 
+{r:RRR, g:GGG, b:BBB} . Code of these functions:
+
+.. code-block:: d
+
+   Color constructColorScalar(Mark start, Mark end, string value)
+   {
+       if(value.length != 6)
+       {
+           throw new ConstructorException("Invalid color: " ~ value, start, end);
+       }
+       //We don't need to check for uppercase chars this way.
+       value = value.toLower();
+
+       //Get value of a hex digit.
+       uint hex(char c)
+       {
+           if(!std.ascii.isHexDigit(c))
+           {
+               throw new ConstructorException("Invalid color: " ~ value, start, end);
+           }
+
+           if(std.ascii.isDigit(c))
+           {
+               return c - '0';
+           }
+           return c - 'a' + 10;
+       }
+
+       Color result;
+       result.red   = cast(ubyte)(16 * hex(value[0]) + hex(value[1]));
+       result.green = cast(ubyte)(16 * hex(value[2]) + hex(value[3]));
+       result.blue  = cast(ubyte)(16 * hex(value[4]) + hex(value[5]));
+
+       return result;
+   }
+
+   Color constructColorMapping(Mark start, Mark end, Node.Pair[] pairs)
+   {
+       int r, g, b;
+       r = g = b = -1;
+       bool error = pairs.length != 3;
+
+       foreach(ref pair; pairs)
+       {
+           //Key might not be a string, and value might not be an int,
+           //so we need to check for that
+           try
+           {
+               switch(pair.key.get!string)
+               {
+                   case "r": r = pair.value.get!int; break;
+                   case "g": g = pair.value.get!int; break;
+                   case "b": b = pair.value.get!int; break;
+                   default:  error = true;
+               }
+           }
+           catch(NodeException e)
+           {
+               error = true;
+           }
+       }
+
+       if(error || r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255)
+       {
+           throw new ConstructorException("Invalid color", start, end);
+       }
+
+       return Color(cast(ubyte)r, cast(ubyte)g, cast(ubyte)b);
+   }
+
+Next, we need some YAML code using our new tag. Create a file called input.yaml 
+with the following contents:
+
+.. code-block:: yaml
+
+   scalar-red: !color FF0000
+   scalar-orange: !color FFFF00
+   mapping-red: !color-mapping {r: 255, g: 0, b: 0}
+   mapping-orange:
+       !color-mapping
+       r: 255
+       g: 255
+       b: 0
+
+You can see that we're using tag ``!color`` for scalar colors, and 
+``!color-mapping`` for colors expressed as mappings. 
+
+Finally, the code to put it all together:
+
+.. code-block:: d
+   
+   void main()
+   {
+       auto red    = Color(255, 0, 0);
+       auto orange = Color(255, 255, 0);
+
+       try
+       {
+           auto constructor = new Constructor;
+           //both functions handle the same tag, but one handles scalar, one mapping.
+           constructor.addConstructor("!color", &constructColorScalar);
+           constructor.addConstructor("!color-mapping", &constructColorMapping);
+
+           auto loader = new Loader("input.yaml", constructor, new Resolver);
+
+           auto root = loader.loadSingleDocument();
+
+           if(root["scalar-red"].get!Color == red && 
+              root["mapping-red"].get!Color == red && 
+              root["scalar-orange"].get!Color == orange && 
+              root["mapping-orange"].get!Color == orange)
+           {
+               writeln("SUCCESS");
+               return;
+           }
+       }
+       catch(YAMLException e)
+       {
+           writeln(e.msg);
+       }
+
+       writeln("FAILURE");
+   }
+
+First, we create a *Constructor* and pass functions to handle the ``!color`` 
+and ``!color-mapping`` tag. We construct a *Loader* using the *Constructor*. 
+We also need a *Resolver*, but for now we just default-construct it. We then 
+load the YAML document, and finally, read the colors using *get()* method to
+test if they were loaded as expected.
+
+You can find the source code for what we've done so far in the 
+``examples/constructor`` directory in the D:YAML package.
+
+
+--------
+Resolver
+--------
+
+Specifying tag for every color value can be tedious. D:YAML can implicitly 
+resolve tag of a scalar using a regular expression. This is how default types, 
+e.g. int, are resolved. We will use the *Resolver* class to add implicit tag 
+resolution for the Color data type (in its scalar form).
+
+We use the *addImplicitResolver* method of *Resolver*, passing the tag, regular
+expression the value must match to resolve to this tag, and a string of possible
+starting characters of the value. Then we pass the *Resolver* to the constructor 
+of *Loader*.
+
+Note that resolvers added first override ones added later. If no resolver 
+matches a scalar, YAML string tag is used. Therefore our custom values must not 
+be resolvable as any non-string YAML data type.
+
+Add this to your code to add implicit resolution of ``!color``.
+
+.. code-block:: d
+
+   //code from the previous example...
+
+   auto resolver = new Resolver;
+   resolver.addImplicitResolver("!color", std.regex.regex("[0-9a-fA-F]{6}",
+                                "0123456789abcdefABCDEF"));
+   
+   auto loader = new Loader("input.yaml", constructor, resolver);
+
+   //code from the previous example...
+
+Now, change contents of input.dyaml to this:
+
+.. code-block:: yaml
+
+   scalar-red: FF0000
+   scalar-orange: FFFF00
+   mapping-red: !color-mapping {r: 255, g: 0, b: 0}
+   mapping-orange:
+       !color-mapping
+       r: 255
+       g: 255
+       b: 0
+
+We no longer need to specify the tag for scalar color values. Compile and test 
+the example. If everything went as expected, it should report success. 
+
+You can find the complete code in the ``examples/resolver`` directory in the 
+D:YAML package.

doc/html/_sources/tutorials/getting_started.txt

@@ -0,0 +1,168 @@
+===============
+Getting started 
+===============
+
+Welcome to D:YAML! D:YAML is a `YAML <http://en.wikipedia.org/wiki/YAML>`_ parser 
+library for the `D programming language <http://d-p-l.org>`_. This tutorial will 
+explain how to set D:YAML up and use it in your projects. 
+
+This is meant to be the **simplest possible** introduction to D:YAML. Some of the
+information present might already be known to you. Only basic usage is covered. 
+More advanced usage is described in other tutorials.
+
+
+----------
+Setting up
+----------
+
+^^^^^^^^^^^^^^^^^^^^^^^^
+Install the DMD compiler
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Digital Mars D compiler, or DMD, is the most commonly used D compiler. You can
+find its newest version `here <http://www.digitalmars.com/d/download.html>`_. 
+Download the version of DMD for your operating system and install it.
+
+.. note:: 
+   Other D compilers exist, such as 
+   `GDC <http://bitbucket.org/goshawk/gdc/wiki/Home>`_ and 
+   `LDC <http://www.dsource.org/projects/ldc/>`_. 
+   Setting up with either one of them should be similar to DMD,
+   however, at the moment they are not as up to date as DMD.
+
+
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Download and compile D:YAML
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The newest version of D:YAML can be found `here <TODO>`_. Download a source 
+archive, extract it, and move to the extracted directory.
+
+D:YAML uses a modified version of the `CDC <http://dsource.org/projects/cdc/>`_ 
+script for compilation. To compile D:YAML, you first need to build CDC.
+Do this by typing the following command into the console::
+
+   dmd cdc.d
+
+Now you can use CDC to compile D:YAML.
+To do this on Unix/Linux, use the following command::
+
+   ./cdc
+
+On Windows::
+
+   cdc.exe
+
+This will compile the library to a file called ``libdyaml.a`` on Unix/Linux or
+``libdyaml.lib`` on Windows.
+
+
+-------------------------
+Your first D:YAML project 
+-------------------------
+
+Create a directory for your project and in that directory, create a file called
+``input.yaml`` with the following contents:
+
+.. code-block:: yaml
+
+   Hello World :
+       - Hello
+       - World
+   Answer: 42
+
+This will serve as input for our example.
+
+Now we need to parse it. Create a file called "main.d". Paste following code 
+into the file:
+
+.. code-block:: d
+
+   import std.stdio;
+   import yaml;
+
+   void main()
+   {
+       yaml.Node root = yaml.load("input.yaml");
+       foreach(string word; root["Hello World"])
+       {
+           writeln(word);
+       }
+       writeln("The answer is ", root["Answer"].get!int);
+   }
+
+
+^^^^^^^^^^^^^^^^^^^^^^^
+Explanation of the code
+^^^^^^^^^^^^^^^^^^^^^^^
+
+First, we import the *yaml* module. This is the only module you need to import 
+to use D:YAML - it automatically imports all needed modules.
+
+Next we load the file using the *yaml.load()* function - this loads the file as
+**one** YAML document and throws *YAMLException*, D:YAML exception type, if the 
+file could not be parsed or does not contain exactly one document. Note that we 
+don't do any error checking here in order to keep the example as simple as 
+possible.
+
+*yaml.Node* represents a node in a YAML document. It can be a sequence (array), 
+mapping (associative array) or a scalar (value). Here the root node is a 
+mapping, and we use the index operator to get subnodes with keys "Hello World"
+and "Answer". We iterate over the first, as it is a sequence, and use the 
+*yaml.Node.get()* method on the second to get its value as an integer.
+
+You can iterate over a mapping or sequence as if it was an associative or normal 
+array. If you try to iterate over a scalar, it will throw a *YAMLException*. 
+
+You can iterate over subnodes using yaml.Node as the iterated type, or specify 
+the type subnodes are expected to have. D:YAML will automatically convert 
+iterated subnodes to that type if possible. Here we specify the *string* type, 
+so we iterate over the "Hello World" sequence as an array of strings. If it is
+not possible to convert to iterated type, a *YAMLException* is thrown. For 
+instance, if we specified *int* here, we would get an error, as "Hello" 
+cannot be converted to an integer.
+
+The *yaml.Node.get()* method is used to get value of a scalar node as specified 
+type. D:YAML will try to return the scalar as specified type, converting if 
+needed, throwing *YAMLException* if not possible.
+
+
+^^^^^^^^^
+Compiling
+^^^^^^^^^
+
+To compile your project, you must give DMD the directories containing import 
+modules and the library. You also need to tell it to link with D:YAML. The import
+directory should be the D:YAML package directory. You can specify it using the 
+``-I`` option of DMD.  The library directory should point to where you put the
+compiled D:YAML library. On Unix/Linux you can specify it using the ``-L-L`` 
+option, and link with D:YAML using the ``-L-l`` option. On Windows, the import
+directory is used as the library directory. To link with the library on Windows,
+just add the path to it relative to the current directory.
+
+For example, if you extracted D:YAML to ``/home/xxx/dyaml`` and compiled it in 
+that directory, your project is in ``/home/xxx/dyaml-project``, and you are 
+currently in that directory, you can compile the project with the following 
+command on Unix/Linux::
+
+   dmd -I../dyaml -L-L../dyaml -L-ldyaml main.d
+
+And the following on Windows::
+
+   dmd -I../dyaml ../dyaml/libdyaml.lib main.d
+
+This will produce an executable called ``main`` or ``main.exe`` in your 
+directory. When you run it, it should produce the following output::
+
+   Hello
+   World                                                                                                                                                                                                                                                                          
+   The answer is 42 
+
+
+^^^^^^^^^^
+Conclusion
+^^^^^^^^^^
+
+You should now have a basic idea about how to use D:YAML. To learn more, look at
+the `API documentation <../api/index.html>`_ and other tutorials. You can find code for this
+example in the ``example/getting_started`` directory in the package.

doc/html/_sources/tutorials/yaml_syntax.txt

@@ -0,0 +1,273 @@
+===========
+YAML syntax
+===========
+
+This is an introduction to the most common YAML constructs. For more detailed 
+information, see `PyYAML documentation <http://pyyaml.org/wiki/PyYAMLDocumentation>`_,
+which this article is based on,
+`Chapter 2 of the YAML specification <http://yaml.org/spec/1.1/#id857168>`_
+or the `Wikipedia page <http://en.wikipedia.org/wiki/YAML>`_.
+
+YAML is a data serialization format designed to be as human readable as 
+possible. YAML is a recursive acronym for "YAML Ain't Markup Language".
+
+YAML is similar to JSON, and in fact, JSON is a subset of YAML 1.2; but YAML has
+some more advanced features and is easier to read. However, YAML is also more
+difficult to parse (and probably somewhat slower). Data is stored in mappings
+(associative arrays), sequences (lists) and scalars (single values). Data 
+structure hierarchy either depends on indentation (block context, similar to
+Python code), or nesting of brackets and braces (flow context, similar to JSON).
+YAML comments begin with ``#`` and continue until the end of line.
+
+
+---------
+Documents
+---------
+
+A YAML stream consists of one or more documents starting with ``---`` and
+optionally ending with ``...`` . If there is only one document, ``---`` can be
+left out.
+
+Single document with no explicit start or end:
+
+.. code-block:: yaml
+
+   - Red
+   - Green
+   - Blue
+
+Same document with explicit start and end:
+
+.. code-block:: yaml
+
+   ---
+   - Red
+   - Green
+   - Blue
+   ...
+
+A stream containing multiple documents:
+
+.. code-block:: yaml
+
+   ---
+   - Red
+   - Green
+   - Blue
+   ---
+   - Linux
+   - BSD
+   ---
+   answer : 42
+    
+
+---------
+Sequences
+---------
+
+Sequences are arrays of nodes of any type, similar e.g. to Python lists.
+In block context, each item begins with hyphen+space "- ". In flow context,
+sequences have syntax similar to D arrays.
+
+.. code-block:: yaml
+
+   #Block context
+   - Red
+   - Green
+   - Blue
+
+.. code-block:: yaml
+
+   #Flow context
+   [Red, Green, Blue]
+
+.. code-block:: yaml
+
+   #Nested
+   -
+     - Red
+     - Green
+     - Blue
+   -
+     - Linux
+     - BSD
+
+.. code-block:: yaml
+
+   #Nested flow
+   [[Red, Green, Blue], [Linux, BSD]]
+
+.. code-block:: yaml
+
+   #Nested in a mapping
+   Colors:
+     - Red
+     - Green
+     - Blue
+   Operating systems:
+     - Linux
+     - BSD
+
+
+--------
+Mappings
+--------
+
+Mappings are associative arrays where each key and value can be of any type, 
+similar e.g. to Python dictionaries. In block context, keys and values are
+separated by colon+space ": ". In flow context, mappings have syntax similar
+to D associative arrays, but with braces instead of brackets:
+
+.. code-block:: yaml
+
+   #Block context
+   CPU: Athlon
+   GPU: Radeon
+   OS: Linux
+
+.. code-block:: yaml
+
+   #Flow context
+   {CPU: Athlon, GPU: Radeon, OS: Linux}
+
+.. code-block:: yaml
+
+   #Nested
+   PC:
+     CPU: Athlon
+     GPU: Radeon
+     OS: Debian
+   Phone:
+     CPU: Cortex
+     GPU: PowerVR
+     OS: Android
+
+.. code-block:: yaml
+
+   #Nested flow
+   {PC: {CPU: Athlon, GPU: Radeon, OS: Debian}, 
+    Phone: {CPU: Cortex, GPU: PowerVR, OS: Android}}
+
+.. code-block:: yaml
+
+   #Nested in a sequence
+   - CPU: Athlon
+     GPU: Radeon
+     OS: Debian
+   - CPU: Cortex
+     GPU: PowerVR
+     OS: Android
+
+Complex keys start with question mark+space "? ".
+
+.. code-block:: yaml
+
+   #Nested in a sequence
+   ? [CPU, GPU]: [Athlon, Radeon]
+   OS: Debian
+
+
+-------
+Scalars
+-------
+
+Scalars are simple values such as integers, strings, timestamps and so on.
+There are multiple scalar styles.
+
+Plain scalars use no quotes, start with the first non-space and end with the 
+last non-space character:
+
+.. code-block:: yaml
+
+   scalar: Plain scalar 
+
+Single quoted scalars start and end with single quotes. A single quote is 
+represented by a pair of single quotes ''.
+
+.. code-block:: yaml
+
+   scalar: 'Single quoted scalar ending with some spaces    '
+
+Double quoted scalars support C-style escape sequences.
+
+.. code-block:: yaml
+
+   scalar: "Double quoted scalar \n with some \\ escape sequences"
+
+Block scalars are convenient for multi-line values. They start either with
+``|`` or with ``>``. With ``|``, the newlines in the scalar are preserved.
+With ``>``, the newlines between two non-empty lines are removed.
+
+.. code-block:: yaml
+
+   scalar: |
+     Newlines are preserved
+     First line
+     Second line 
+
+.. code-block:: yaml
+
+   scalar: >
+     Newlines are folded
+     This is still the first paragraph
+
+     This is the second
+     paragraph
+
+
+-------------------
+Anchors and aliases
+-------------------
+
+Anchors and aliases can reduce size of YAML code by allowing you to define a
+value once, assign an anchor to it and use alias referring to that anchor 
+anywhere else you need that value. It is possible to use this to create 
+recursive data structures and some parsers support this; however, D:YAML does
+not (this might change in the future, but it is unlikely).
+
+.. code-block:: yaml
+
+   Person: &AD
+     gender: male
+     name: Arthur Dent
+   Clone: *AD
+
+
+----
+Tags
+----
+
+Tags are identifiers that specify data types of YAML nodes. Most default YAML
+tags are resolved implicitly, so there is no need to specify them. D:YAML also
+supports implicit resolution for custom, user specified tags.
+
+Explicitly specified tags:
+
+.. code-block:: yaml
+
+   answer: !!int "42"
+   name:   !!str "Arthur Dent"
+
+Implicit tags:
+
+.. code-block:: yaml
+
+   answer: 42        #int
+   name: Arthur Dent #string
+
+This table shows D types stored in *yaml.Node* default YAML tags are converted to.
+Some of these might change in the future (especially !!map and !!set).
+
+======================  ================
+YAML tag                D type
+======================  ================
+!!null                  yaml.YAMLNull
+!!bool                  bool
+!!int                   long
+!!float                 real
+!!binary                ubyte[]
+!!timestamp             datetime.SysTime
+!!map, !!omap, !!pairs  Node.Pair[]
+!!seq, !!set            Node[]
+!!str                   string 
+======================  ================

doc/html/_static/basic.css

@@ -0,0 +1,509 @@
+/*
+ * basic.css
+ * ~~~~~~~~~
+ *
+ * Sphinx stylesheet -- basic theme.
+ *
+ * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/* -- main layout ----------------------------------------------------------- */
+
+div.clearer {
+    clear: both;
+}
+
+/* -- relbar ---------------------------------------------------------------- */
+
+div.related {
+    width: 100%;
+    font-size: 90%;
+}
+
+div.related h3 {
+    display: none;
+}
+
+div.related ul {
+    margin: 0;
+    padding: 0 0 0 10px;
+    list-style: none;
+}
+
+div.related li {
+    display: inline;
+}
+
+div.related li.right {
+    float: right;
+    margin-right: 5px;
+}
+
+/* -- sidebar --------------------------------------------------------------- */
+
+div.sphinxsidebarwrapper {
+    padding: 10px 5px 0 10px;
+}
+
+div.sphinxsidebar {
+    float: left;
+    width: 230px;
+    margin-left: -100%;
+    font-size: 90%;
+}
+
+div.sphinxsidebar ul {
+    list-style: none;
+}
+
+div.sphinxsidebar ul ul,
+div.sphinxsidebar ul.want-points {
+    margin-left: 20px;
+    list-style: square;
+}
+
+div.sphinxsidebar ul ul {
+    margin-top: 0;
+    margin-bottom: 0;
+}
+
+div.sphinxsidebar form {
+    margin-top: 10px;
+}
+
+div.sphinxsidebar input {
+    border: 1px solid #98dbcc;
+    font-family: sans-serif;
+    font-size: 1em;
+}
+
+img {
+    border: 0;
+}
+
+/* -- search page ----------------------------------------------------------- */
+
+ul.search {
+    margin: 10px 0 0 20px;
+    padding: 0;
+}
+
+ul.search li {
+    padding: 5px 0 5px 20px;
+    background-image: url(file.png);
+    background-repeat: no-repeat;
+    background-position: 0 7px;
+}
+
+ul.search li a {
+    font-weight: bold;
+}
+
+ul.search li div.context {
+    color: #888;
+    margin: 2px 0 0 30px;
+    text-align: left;
+}
+
+ul.keywordmatches li.goodmatch a {
+    font-weight: bold;
+}
+
+/* -- index page ------------------------------------------------------------ */
+
+table.contentstable {
+    width: 90%;
+}
+
+table.contentstable p.biglink {
+    line-height: 150%;
+}
+
+a.biglink {
+    font-size: 1.3em;
+}
+
+span.linkdescr {
+    font-style: italic;
+    padding-top: 5px;
+    font-size: 90%;
+}
+
+/* -- general index --------------------------------------------------------- */
+
+table.indextable {
+    width: 100%;
+}
+
+table.indextable td {
+    text-align: left;
+    vertical-align: top;
+}
+
+table.indextable dl, table.indextable dd {
+    margin-top: 0;
+    margin-bottom: 0;
+}
+
+table.indextable tr.pcap {
+    height: 10px;
+}
+
+table.indextable tr.cap {
+    margin-top: 10px;
+    background-color: #f2f2f2;
+}
+
+img.toggler {
+    margin-right: 3px;
+    margin-top: 3px;
+    cursor: pointer;
+}
+
+div.modindex-jumpbox {
+    border-top: 1px solid #ddd;
+    border-bottom: 1px solid #ddd;
+    margin: 1em 0 1em 0;
+    padding: 0.4em;
+}
+
+div.genindex-jumpbox {
+    border-top: 1px solid #ddd;
+    border-bottom: 1px solid #ddd;
+    margin: 1em 0 1em 0;
+    padding: 0.4em;
+}
+
+/* -- general body styles --------------------------------------------------- */
+
+a.headerlink {
+    visibility: hidden;
+}
+
+h1:hover > a.headerlink,
+h2:hover > a.headerlink,
+h3:hover > a.headerlink,
+h4:hover > a.headerlink,
+h5:hover > a.headerlink,
+h6:hover > a.headerlink,
+dt:hover > a.headerlink {
+    visibility: visible;
+}
+
+div.body p.caption {
+    text-align: inherit;
+}
+
+div.body td {
+    text-align: left;
+}
+
+.field-list ul {
+    padding-left: 1em;
+}
+
+.first {
+    margin-top: 0 !important;
+}
+
+p.rubric {
+    margin-top: 30px;
+    font-weight: bold;
+}
+
+.align-left {
+    text-align: left;
+}
+
+.align-center {
+    clear: both;
+    text-align: center;
+}
+
+.align-right {
+    text-align: right;
+}
+
+/* -- sidebars -------------------------------------------------------------- */
+
+div.sidebar {
+    margin: 0 0 0.5em 1em;
+    border: 1px solid #ddb;
+    padding: 7px 7px 0 7px;
+    background-color: #ffe;
+    width: 40%;
+    float: right;
+}
+
+p.sidebar-title {
+    font-weight: bold;
+}
+
+/* -- topics ---------------------------------------------------------------- */
+
+div.topic {
+    border: 1px solid #ccc;
+    padding: 7px 7px 0 7px;
+    margin: 10px 0 10px 0;
+}
+
+p.topic-title {
+    font-size: 1.1em;
+    font-weight: bold;
+    margin-top: 10px;
+}
+
+/* -- admonitions ----------------------------------------------------------- */
+
+div.admonition {
+    margin-top: 10px;
+    margin-bottom: 10px;
+    padding: 7px;
+}
+
+div.admonition dt {
+    font-weight: bold;
+}
+
+div.admonition dl {
+    margin-bottom: 0;
+}
+
+p.admonition-title {
+    margin: 0px 10px 5px 0px;
+    font-weight: bold;
+}
+
+div.body p.centered {
+    text-align: center;
+    margin-top: 25px;
+}
+
+/* -- tables ---------------------------------------------------------------- */
+
+table.docutils {
+    border: 0;
+    border-collapse: collapse;
+}
+
+table.docutils td, table.docutils th {
+    padding: 1px 8px 1px 5px;
+    border-top: 0;
+    border-left: 0;
+    border-right: 0;
+    border-bottom: 1px solid #aaa;
+}
+
+table.field-list td, table.field-list th {
+    border: 0 !important;
+}
+
+table.footnote td, table.footnote th {
+    border: 0 !important;
+}
+
+th {
+    text-align: left;
+    padding-right: 5px;
+}
+
+table.citation {
+    border-left: solid 1px gray;
+    margin-left: 1px;
+}
+
+table.citation td {
+    border-bottom: none;
+}
+
+/* -- other body styles ----------------------------------------------------- */
+
+ol.arabic {
+    list-style: decimal;
+}
+
+ol.loweralpha {
+    list-style: lower-alpha;
+}
+
+ol.upperalpha {
+    list-style: upper-alpha;
+}
+
+ol.lowerroman {
+    list-style: lower-roman;
+}
+
+ol.upperroman {
+    list-style: upper-roman;
+}
+
+dl {
+    margin-bottom: 15px;
+}
+
+dd p {
+    margin-top: 0px;
+}
+
+dd ul, dd table {
+    margin-bottom: 10px;
+}
+
+dd {
+    margin-top: 3px;
+    margin-bottom: 10px;
+    margin-left: 30px;
+}
+
+dt:target, .highlighted {
+    background-color: #fbe54e;
+}
+
+dl.glossary dt {
+    font-weight: bold;
+    font-size: 1.1em;
+}
+
+.field-list ul {
+    margin: 0;
+    padding-left: 1em;
+}
+
+.field-list p {
+    margin: 0;
+}
+
+.refcount {
+    color: #060;
+}
+
+.optional {
+    font-size: 1.3em;
+}
+
+.versionmodified {
+    font-style: italic;
+}
+
+.system-message {
+    background-color: #fda;
+    padding: 5px;
+    border: 3px solid red;
+}
+
+.footnote:target  {
+    background-color: #ffa
+}
+
+.line-block {
+    display: block;
+    margin-top: 1em;
+    margin-bottom: 1em;
+}
+
+.line-block .line-block {
+    margin-top: 0;
+    margin-bottom: 0;
+    margin-left: 1.5em;
+}
+
+.guilabel, .menuselection {
+    font-family: sans-serif;
+}
+
+.accelerator {
+    text-decoration: underline;
+}
+
+.classifier {
+    font-style: oblique;
+}
+
+/* -- code displays --------------------------------------------------------- */
+
+pre {
+    overflow: auto;
+}
+
+td.linenos pre {
+    padding: 5px 0px;
+    border: 0;
+    background-color: transparent;
+    color: #aaa;
+}
+
+table.highlighttable {
+    margin-left: 0.5em;
+}
+
+table.highlighttable td {
+    padding: 0 0.5em 0 0.5em;
+}
+
+tt.descname {
+    background-color: transparent;
+    font-weight: bold;
+    font-size: 1.2em;
+}
+
+tt.descclassname {
+    background-color: transparent;
+}
+
+tt.xref, a tt {
+    background-color: transparent;
+    font-weight: bold;
+}
+
+h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
+    background-color: transparent;
+}
+
+.viewcode-link {
+    float: right;
+}
+
+.viewcode-back {
+    float: right;
+    font-family: sans-serif;
+}
+
+div.viewcode-block:target {
+    margin: -1px -10px;
+    padding: 0 10px;
+}
+
+/* -- math display ---------------------------------------------------------- */
+
+img.math {
+    vertical-align: middle;
+}
+
+div.body div.math p {
+    text-align: center;
+}
+
+span.eqno {
+    float: right;
+}
+
+/* -- printout stylesheet --------------------------------------------------- */
+
+@media print {
+    div.document,
+    div.documentwrapper,
+    div.bodywrapper {
+        margin: 0 !important;
+        width: 100%;
+    }
+
+    div.sphinxsidebar,
+    div.related,
+    div.footer,
+    #top-link {
+        display: none;
+    }
+}

doc/html/_static/default.css

@@ -0,0 +1,255 @@
+/*
+ * default.css_t
+ * ~~~~~~~~~~~~~
+ *
+ * Sphinx stylesheet -- default theme.
+ *
+ * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+@import url("basic.css");
+
+/* -- page layout ----------------------------------------------------------- */
+
+body {
+    font-family: Verdana, "Deja Vu", "Bitstream Vera Sans", sans-serif;
+    font-size: 100%;
+    background-color: #1f252b;
+    color: #000;
+    margin: 0;
+    padding: 0;
+}
+
+div.document {
+    background-color: #1f252b;
+}
+
+div.documentwrapper {
+    float: left;
+    width: 100%;
+}
+
+div.bodywrapper {
+    margin: 0 0 0 230px;
+}
+
+div.body {
+    background-color: #f6f6f6;
+    color: black;
+    padding: 0 20px 30px 20px;
+}
+
+div.footer {
+    color: #ccc;
+    width: 100%;
+    padding: 9px 0 9px 0;
+    text-align: center;
+    font-size: 75%;
+}
+
+div.footer a {
+    color: #ccc;
+    text-decoration: underline;
+}
+
+div.related {
+    background-color: #303333;
+    line-height: 30px;
+    color: #ccc;
+}
+
+div.related a {
+    color: #ffffff;
+}
+
+div.sphinxsidebar {
+}
+
+div.sphinxsidebar h3 {
+    font-family: Georgia, "Times New Roman", Times, serif;
+    color: #ffffff;
+    font-size: 1.4em;
+    font-weight: normal;
+    margin: 0;
+    padding: 0;
+}
+
+div.sphinxsidebar h3 a {
+    color: #ffffff;
+}
+
+div.sphinxsidebar h4 {
+    font-family: Georgia, "Times New Roman", Times, serif;
+    color: #ffffff;
+    font-size: 1.3em;
+    font-weight: normal;
+    margin: 5px 0 0 0;
+    padding: 0;
+}
+
+div.sphinxsidebar p {
+    color: #ffffff;
+}
+
+div.sphinxsidebar p.topless {
+    margin: 5px 10px 10px 10px;
+}
+
+div.sphinxsidebar ul {
+    margin: 10px;
+    padding: 0;
+    color: #ffffff;
+}
+
+div.sphinxsidebar a {
+    color: #ddd;
+}
+
+div.sphinxsidebar input {
+    border: 1px solid #ddd;
+    font-family: sans-serif;
+    font-size: 1em;
+}
+
+
+/* -- hyperlink styles ------------------------------------------------------ */
+
+a {
+    color: #006;
+    text-decoration: none;
+}
+
+a:visited {
+    color: #606;
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+
+
+/* -- body styles ----------------------------------------------------------- */
+
+div.body h1,
+div.body h2,
+div.body h3,
+div.body h4,
+div.body h5,
+div.body h6 {
+    font-family: Georgia, "Times New Roman", Times, serif;
+    background-color: #f6f6f6;
+    font-weight: normal;
+    color: #633;
+    border-bottom: 1px solid #ccc;
+    margin: 20px -20px 10px -20px;
+    padding: 3px 0 3px 10px;
+}
+
+div.body h1 { margin-top: 0; font-size: 200%; }
+div.body h2 { font-size: 160%; }
+div.body h3 { font-size: 140%; }
+div.body h4 { font-size: 120%; }
+div.body h5 { font-size: 110%; }
+div.body h6 { font-size: 100%; }
+
+a.headerlink {
+    color: #006;
+    font-size: 0.8em;
+    padding: 0 4px 0 4px;
+    text-decoration: none;
+}
+
+a.headerlink:hover {
+    background-color: #006;
+    color: white;
+}
+
+div.body p, div.body dd, div.body li {
+    text-align: justify;
+    line-height: 130%;
+}
+
+div.admonition p.admonition-title + p {
+    display: inline;
+}
+
+div.admonition p {
+    margin-bottom: 5px;
+}
+
+div.admonition pre {
+    margin-bottom: 5px;
+}
+
+div.admonition ul, div.admonition ol {
+    margin-bottom: 5px;
+}
+
+div.note {
+    background-color: #eee;
+    border: 1px solid #ccc;
+}
+
+div.seealso {
+    background-color: #ffc;
+    border: 1px solid #ff6;
+}
+
+div.topic {
+    background-color: #eee;
+}
+
+div.warning {
+    background-color: #ffe4e4;
+    border: 1px solid #f66;
+}
+
+p.admonition-title {
+    display: inline;
+}
+
+p.admonition-title:after {
+    content: ":";
+}
+
+pre {
+    padding: 5px;
+    background-color: fcfcfc;
+    color: 000066;
+    line-height: 120%;
+    border: 1px solid #ac9;
+    border-left: none;
+    border-right: none;
+}
+
+tt {
+    background-color: #ecf0f3;
+    padding: 0 1px 0 1px;
+    font-size: 0.95em;
+}
+
+th {
+    background-color: #ede;
+}
+
+.warning tt {
+    background: #efc2c2;
+}
+
+.note tt {
+    background: #d6d6d6;
+}
+
+.viewcode-back {
+    font-family: Verdana, "Deja Vu", "Bitstream Vera Sans", sans-serif;
+}
+
+div.viewcode-block:target {
+    background-color: #f4debf;
+    border-top: 1px solid #ac9;
+    border-bottom: 1px solid #ac9;
+}

doc/html/_static/doctools.js

@@ -0,0 +1,247 @@
+/*
+ * doctools.js
+ * ~~~~~~~~~~~
+ *
+ * Sphinx JavaScript utilties for all documentation.
+ *
+ * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/**
+ * select a different prefix for underscore
+ */
+$u = _.noConflict();
+
+/**
+ * make the code below compatible with browsers without
+ * an installed firebug like debugger
+if (!window.console || !console.firebug) {
+  var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
+    "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
+    "profile", "profileEnd"];
+  window.console = {};
+  for (var i = 0; i < names.length; ++i)
+    window.console[names[i]] = function() {};
+}
+ */
+
+/**
+ * small helper function to urldecode strings
+ */
+jQuery.urldecode = function(x) {
+  return decodeURIComponent(x).replace(/\+/g, ' ');
+}
+
+/**
+ * small helper function to urlencode strings
+ */
+jQuery.urlencode = encodeURIComponent;
+
+/**
+ * This function returns the parsed url parameters of the
+ * current request. Multiple values per key are supported,
+ * it will always return arrays of strings for the value parts.
+ */
+jQuery.getQueryParameters = function(s) {
+  if (typeof s == 'undefined')
+    s = document.location.search;
+  var parts = s.substr(s.indexOf('?') + 1).split('&');
+  var result = {};
+  for (var i = 0; i < parts.length; i++) {
+    var tmp = parts[i].split('=', 2);
+    var key = jQuery.urldecode(tmp[0]);
+    var value = jQuery.urldecode(tmp[1]);
+    if (key in result)
+      result[key].push(value);
+    else
+      result[key] = [value];
+  }
+  return result;
+};
+
+/**
+ * small function to check if an array contains
+ * a given item.
+ */
+jQuery.contains = function(arr, item) {
+  for (var i = 0; i < arr.length; i++) {
+    if (arr[i] == item)
+      return true;
+  }
+  return false;
+};
+
+/**
+ * highlight a given string on a jquery object by wrapping it in
+ * span elements with the given class name.
+ */
+jQuery.fn.highlightText = function(text, className) {
+  function highlight(node) {
+    if (node.nodeType == 3) {
+      var val = node.nodeValue;
+      var pos = val.toLowerCase().indexOf(text);
+      if (pos >= 0 && !jQuery(node.parentNode).hasClass(className)) {
+        var span = document.createElement("span");
+        span.className = className;
+        span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+        node.parentNode.insertBefore(span, node.parentNode.insertBefore(
+          document.createTextNode(val.substr(pos + text.length)),
+          node.nextSibling));
+        node.nodeValue = val.substr(0, pos);
+      }
+    }
+    else if (!jQuery(node).is("button, select, textarea")) {
+      jQuery.each(node.childNodes, function() {
+        highlight(this);
+      });
+    }
+  }
+  return this.each(function() {
+    highlight(this);
+  });
+};
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+var Documentation = {
+
+  init : function() {
+    this.fixFirefoxAnchorBug();
+    this.highlightSearchWords();
+    this.initIndexTable();
+  },
+
+  /**
+   * i18n support
+   */
+  TRANSLATIONS : {},
+  PLURAL_EXPR : function(n) { return n == 1 ? 0 : 1; },
+  LOCALE : 'unknown',
+
+  // gettext and ngettext don't access this so that the functions
+  // can safely bound to a different name (_ = Documentation.gettext)
+  gettext : function(string) {
+    var translated = Documentation.TRANSLATIONS[string];
+    if (typeof translated == 'undefined')
+      return string;
+    return (typeof translated == 'string') ? translated : translated[0];
+  },
+
+  ngettext : function(singular, plural, n) {
+    var translated = Documentation.TRANSLATIONS[singular];
+    if (typeof translated == 'undefined')
+      return (n == 1) ? singular : plural;
+    return translated[Documentation.PLURALEXPR(n)];
+  },
+
+  addTranslations : function(catalog) {
+    for (var key in catalog.messages)
+      this.TRANSLATIONS[key] = catalog.messages[key];
+    this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
+    this.LOCALE = catalog.locale;
+  },
+
+  /**
+   * add context elements like header anchor links
+   */
+  addContextElements : function() {
+    $('div[id] > :header:first').each(function() {
+      $('<a class="headerlink">\u00B6</a>').
+      attr('href', '#' + this.id).
+      attr('title', _('Permalink to this headline')).
+      appendTo(this);
+    });
+    $('dt[id]').each(function() {
+      $('<a class="headerlink">\u00B6</a>').
+      attr('href', '#' + this.id).
+      attr('title', _('Permalink to this definition')).
+      appendTo(this);
+    });
+  },
+
+  /**
+   * workaround a firefox stupidity
+   */
+  fixFirefoxAnchorBug : function() {
+    if (document.location.hash && $.browser.mozilla)
+      window.setTimeout(function() {
+        document.location.href += '';
+      }, 10);
+  },
+
+  /**
+   * highlight the search words provided in the url in the text
+   */
+  highlightSearchWords : function() {
+    var params = $.getQueryParameters();
+    var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
+    if (terms.length) {
+      var body = $('div.body');
+      window.setTimeout(function() {
+        $.each(terms, function() {
+          body.highlightText(this.toLowerCase(), 'highlighted');
+        });
+      }, 10);
+      $('<li class="highlight-link"><a href="javascript:Documentation.' +
+        'hideSearchWords()">' + _('Hide Search Matches') + '</a></li>')
+          .appendTo($('.sidebar .this-page-menu'));
+    }
+  },
+
+  /**
+   * init the domain index toggle buttons
+   */
+  initIndexTable : function() {
+    var togglers = $('img.toggler').click(function() {
+      var src = $(this).attr('src');
+      var idnum = $(this).attr('id').substr(7);
+      $('tr.cg-' + idnum).toggle();
+      if (src.substr(-9) == 'minus.png')
+        $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
+      else
+        $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
+    }).css('display', '');
+    if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
+        togglers.click();
+    }
+  },
+
+  /**
+   * helper function to hide the search marks again
+   */
+  hideSearchWords : function() {
+    $('.sidebar .this-page-menu li.highlight-link').fadeOut(300);
+    $('span.highlighted').removeClass('highlighted');
+  },
+
+  /**
+   * make the url absolute
+   */
+  makeURL : function(relativeURL) {
+    return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
+  },
+
+  /**
+   * get the current relative url
+   */
+  getCurrentURL : function() {
+    var path = document.location.pathname;
+    var parts = path.split(/\//);
+    $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
+      if (this == '..')
+        parts.pop();
+    });
+    var url = parts.join('/');
+    return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
+  }
+};
+
+// quick alias for translations
+_ = Documentation.gettext;
+
+$(document).ready(function() {
+  Documentation.init();
+});

doc/html/_static/pygments.css

@@ -0,0 +1,61 @@
+.hll { background-color: #ffffcc }
+.c { color: #408090; font-style: italic } /* Comment */
+.err { border: 1px solid #FF0000 } /* Error */
+.k { color: #007020; font-weight: bold } /* Keyword */
+.o { color: #666666 } /* Operator */
+.cm { color: #408090; font-style: italic } /* Comment.Multiline */
+.cp { color: #007020 } /* Comment.Preproc */
+.c1 { color: #408090; font-style: italic } /* Comment.Single */
+.cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
+.gd { color: #A00000 } /* Generic.Deleted */
+.ge { font-style: italic } /* Generic.Emph */
+.gr { color: #FF0000 } /* Generic.Error */
+.gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.gi { color: #00A000 } /* Generic.Inserted */
+.go { color: #303030 } /* Generic.Output */
+.gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
+.gs { font-weight: bold } /* Generic.Strong */
+.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.gt { color: #0040D0 } /* Generic.Traceback */
+.kc { color: #007020; font-weight: bold } /* Keyword.Constant */
+.kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
+.kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
+.kp { color: #007020 } /* Keyword.Pseudo */
+.kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
+.kt { color: #902000 } /* Keyword.Type */
+.m { color: #208050 } /* Literal.Number */
+.s { color: #4070a0 } /* Literal.String */
+.na { color: #4070a0 } /* Name.Attribute */
+.nb { color: #007020 } /* Name.Builtin */
+.nc { color: #0e84b5; font-weight: bold } /* Name.Class */
+.no { color: #60add5 } /* Name.Constant */
+.nd { color: #555555; font-weight: bold } /* Name.Decorator */
+.ni { color: #d55537; font-weight: bold } /* Name.Entity */
+.ne { color: #007020 } /* Name.Exception */
+.nf { color: #06287e } /* Name.Function */
+.nl { color: #002070; font-weight: bold } /* Name.Label */
+.nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
+.nt { color: #062873; font-weight: bold } /* Name.Tag */
+.nv { color: #bb60d5 } /* Name.Variable */
+.ow { color: #007020; font-weight: bold } /* Operator.Word */
+.w { color: #bbbbbb } /* Text.Whitespace */
+.mf { color: #208050 } /* Literal.Number.Float */
+.mh { color: #208050 } /* Literal.Number.Hex */
+.mi { color: #208050 } /* Literal.Number.Integer */
+.mo { color: #208050 } /* Literal.Number.Oct */
+.sb { color: #4070a0 } /* Literal.String.Backtick */
+.sc { color: #4070a0 } /* Literal.String.Char */
+.sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
+.s2 { color: #4070a0 } /* Literal.String.Double */
+.se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
+.sh { color: #4070a0 } /* Literal.String.Heredoc */
+.si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
+.sx { color: #c65d09 } /* Literal.String.Other */
+.sr { color: #235388 } /* Literal.String.Regex */
+.s1 { color: #4070a0 } /* Literal.String.Single */
+.ss { color: #517918 } /* Literal.String.Symbol */
+.bp { color: #007020 } /* Name.Builtin.Pseudo */
+.vc { color: #bb60d5 } /* Name.Variable.Class */
+.vg { color: #bb60d5 } /* Name.Variable.Global */
+.vi { color: #bb60d5 } /* Name.Variable.Instance */
+.il { color: #208050 } /* Literal.Number.Integer.Long */

doc/html/_static/searchtools.js

@@ -0,0 +1,518 @@
+/*
+ * searchtools.js
+ * ~~~~~~~~~~~~~~
+ *
+ * Sphinx JavaScript utilties for the full-text search.
+ *
+ * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/**
+ * helper function to return a node containing the
+ * search summary for a given text. keywords is a list
+ * of stemmed words, hlwords is the list of normal, unstemmed
+ * words. the first one is used to find the occurance, the
+ * latter for highlighting it.
+ */
+
+jQuery.makeSearchSummary = function(text, keywords, hlwords) {
+  var textLower = text.toLowerCase();
+  var start = 0;
+  $.each(keywords, function() {
+    var i = textLower.indexOf(this.toLowerCase());
+    if (i > -1)
+      start = i;
+  });
+  start = Math.max(start - 120, 0);
+  var excerpt = ((start > 0) ? '...' : '') +
+  $.trim(text.substr(start, 240)) +
+  ((start + 240 - text.length) ? '...' : '');
+  var rv = $('<div class="context"></div>').text(excerpt);
+  $.each(hlwords, function() {
+    rv = rv.highlightText(this, 'highlighted');
+  });
+  return rv;
+}
+
+/**
+ * Porter Stemmer
+ */
+var PorterStemmer = function() {
+
+  var step2list = {
+    ational: 'ate',
+    tional: 'tion',
+    enci: 'ence',
+    anci: 'ance',
+    izer: 'ize',
+    bli: 'ble',
+    alli: 'al',
+    entli: 'ent',
+    eli: 'e',
+    ousli: 'ous',
+    ization: 'ize',
+    ation: 'ate',
+    ator: 'ate',
+    alism: 'al',
+    iveness: 'ive',
+    fulness: 'ful',
+    ousness: 'ous',
+    aliti: 'al',
+    iviti: 'ive',
+    biliti: 'ble',
+    logi: 'log'
+  };
+
+  var step3list = {
+    icate: 'ic',
+    ative: '',
+    alize: 'al',
+    iciti: 'ic',
+    ical: 'ic',
+    ful: '',
+    ness: ''
+  };
+
+  var c = "[^aeiou]";          // consonant
+  var v = "[aeiouy]";          // vowel
+  var C = c + "[^aeiouy]*";    // consonant sequence
+  var V = v + "[aeiou]*";      // vowel sequence
+
+  var mgr0 = "^(" + C + ")?" + V + C;                      // [C]VC... is m>0
+  var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$";    // [C]VC[V] is m=1
+  var mgr1 = "^(" + C + ")?" + V + C + V + C;              // [C]VCVC... is m>1
+  var s_v   = "^(" + C + ")?" + v;                         // vowel in stem
+
+  this.stemWord = function (w) {
+    var stem;
+    var suffix;
+    var firstch;
+    var origword = w;
+
+    if (w.length < 3)
+      return w;
+
+    var re;
+    var re2;
+    var re3;
+    var re4;
+
+    firstch = w.substr(0,1);
+    if (firstch == "y")
+      w = firstch.toUpperCase() + w.substr(1);
+
+    // Step 1a
+    re = /^(.+?)(ss|i)es$/;
+    re2 = /^(.+?)([^s])s$/;
+
+    if (re.test(w))
+      w = w.replace(re,"$1$2");
+    else if (re2.test(w))
+      w = w.replace(re2,"$1$2");
+
+    // Step 1b
+    re = /^(.+?)eed$/;
+    re2 = /^(.+?)(ed|ing)$/;
+    if (re.test(w)) {
+      var fp = re.exec(w);
+      re = new RegExp(mgr0);
+      if (re.test(fp[1])) {
+        re = /.$/;
+        w = w.replace(re,"");
+      }
+    }
+    else if (re2.test(w)) {
+      var fp = re2.exec(w);
+      stem = fp[1];
+      re2 = new RegExp(s_v);
+      if (re2.test(stem)) {
+        w = stem;
+        re2 = /(at|bl|iz)$/;
+        re3 = new RegExp("([^aeiouylsz])\\1$");
+        re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+        if (re2.test(w))
+          w = w + "e";
+        else if (re3.test(w)) {
+          re = /.$/;
+          w = w.replace(re,"");
+        }
+        else if (re4.test(w))
+          w = w + "e";
+      }
+    }
+
+    // Step 1c
+    re = /^(.+?)y$/;
+    if (re.test(w)) {
+      var fp = re.exec(w);
+      stem = fp[1];
+      re = new RegExp(s_v);
+      if (re.test(stem))
+        w = stem + "i";
+    }
+
+    // Step 2
+    re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+    if (re.test(w)) {
+      var fp = re.exec(w);
+      stem = fp[1];
+      suffix = fp[2];
+      re = new RegExp(mgr0);
+      if (re.test(stem))
+        w = stem + step2list[suffix];
+    }
+
+    // Step 3
+    re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+    if (re.test(w)) {
+      var fp = re.exec(w);
+      stem = fp[1];
+      suffix = fp[2];
+      re = new RegExp(mgr0);
+      if (re.test(stem))
+        w = stem + step3list[suffix];
+    }
+
+    // Step 4
+    re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+    re2 = /^(.+?)(s|t)(ion)$/;
+    if (re.test(w)) {
+      var fp = re.exec(w);
+      stem = fp[1];
+      re = new RegExp(mgr1);
+      if (re.test(stem))
+        w = stem;
+    }
+    else if (re2.test(w)) {
+      var fp = re2.exec(w);
+      stem = fp[1] + fp[2];
+      re2 = new RegExp(mgr1);
+      if (re2.test(stem))
+        w = stem;
+    }
+
+    // Step 5
+    re = /^(.+?)e$/;
+    if (re.test(w)) {
+      var fp = re.exec(w);
+      stem = fp[1];
+      re = new RegExp(mgr1);
+      re2 = new RegExp(meq1);
+      re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+      if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
+        w = stem;
+    }
+    re = /ll$/;
+    re2 = new RegExp(mgr1);
+    if (re.test(w) && re2.test(w)) {
+      re = /.$/;
+      w = w.replace(re,"");
+    }
+
+    // and turn initial Y back to y
+    if (firstch == "y")
+      w = firstch.toLowerCase() + w.substr(1);
+    return w;
+  }
+}
+
+
+/**
+ * Search Module
+ */
+var Search = {
+
+  _index : null,
+  _queued_query : null,
+  _pulse_status : -1,
+
+  init : function() {
+      var params = $.getQueryParameters();
+      if (params.q) {
+          var query = params.q[0];
+          $('input[name="q"]')[0].value = query;
+          this.performSearch(query);
+      }
+  },
+
+  loadIndex : function(url) {
+    $.ajax({type: "GET", url: url, data: null, success: null,
+            dataType: "script", cache: true});
+  },
+
+  setIndex : function(index) {
+    var q;
+    this._index = index;
+    if ((q = this._queued_query) !== null) {
+      this._queued_query = null;
+      Search.query(q);
+    }
+  },
+
+  hasIndex : function() {
+      return this._index !== null;
+  },
+
+  deferQuery : function(query) {
+      this._queued_query = query;
+  },
+
+  stopPulse : function() {
+      this._pulse_status = 0;
+  },
+
+  startPulse : function() {
+    if (this._pulse_status >= 0)
+        return;
+    function pulse() {
+      Search._pulse_status = (Search._pulse_status + 1) % 4;
+      var dotString = '';
+      for (var i = 0; i < Search._pulse_status; i++)
+        dotString += '.';
+      Search.dots.text(dotString);
+      if (Search._pulse_status > -1)
+        window.setTimeout(pulse, 500);
+    };
+    pulse();
+  },
+
+  /**
+   * perform a search for something
+   */
+  performSearch : function(query) {
+    // create the required interface elements
+    this.out = $('#search-results');
+    this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
+    this.dots = $('<span></span>').appendTo(this.title);
+    this.status = $('<p style="display: none"></p>').appendTo(this.out);
+    this.output = $('<ul class="search"/>').appendTo(this.out);
+
+    $('#search-progress').text(_('Preparing search...'));
+    this.startPulse();
+
+    // index already loaded, the browser was quick!
+    if (this.hasIndex())
+      this.query(query);
+    else
+      this.deferQuery(query);
+  },
+
+  query : function(query) {
+    var stopwords = ['and', 'then', 'into', 'it', 'as', 'are', 'in',
+                     'if', 'for', 'no', 'there', 'their', 'was', 'is',
+                     'be', 'to', 'that', 'but', 'they', 'not', 'such',
+                     'with', 'by', 'a', 'on', 'these', 'of', 'will',
+                     'this', 'near', 'the', 'or', 'at'];
+
+    // stem the searchterms and add them to the correct list
+    var stemmer = new PorterStemmer();
+    var searchterms = [];
+    var excluded = [];
+    var hlterms = [];
+    var tmp = query.split(/\s+/);
+    var object = (tmp.length == 1) ? tmp[0].toLowerCase() : null;
+    for (var i = 0; i < tmp.length; i++) {
+      if ($u.indexOf(stopwords, tmp[i]) != -1 || tmp[i].match(/^\d+$/) ||
+          tmp[i] == "") {
+        // skip this "word"
+        continue;
+      }
+      // stem the word
+      var word = stemmer.stemWord(tmp[i]).toLowerCase();
+      // select the correct list
+      if (word[0] == '-') {
+        var toAppend = excluded;
+        word = word.substr(1);
+      }
+      else {
+        var toAppend = searchterms;
+        hlterms.push(tmp[i].toLowerCase());
+      }
+      // only add if not already in the list
+      if (!$.contains(toAppend, word))
+        toAppend.push(word);
+    };
+    var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" "));
+
+    // console.debug('SEARCH: searching for:');
+    // console.info('required: ', searchterms);
+    // console.info('excluded: ', excluded);
+
+    // prepare search
+    var filenames = this._index.filenames;
+    var titles = this._index.titles;
+    var terms = this._index.terms;
+    var objects = this._index.objects;
+    var objtypes = this._index.objtypes;
+    var objnames = this._index.objnames;
+    var fileMap = {};
+    var files = null;
+    // different result priorities
+    var importantResults = [];
+    var objectResults = [];
+    var regularResults = [];
+    var unimportantResults = [];
+    $('#search-progress').empty();
+
+    // lookup as object
+    if (object != null) {
+      for (var prefix in objects) {
+        for (var name in objects[prefix]) {
+          var fullname = (prefix ? prefix + '.' : '') + name;
+          if (fullname.toLowerCase().indexOf(object) > -1) {
+            match = objects[prefix][name];
+            descr = objnames[match[1]] + _(', in ') + titles[match[0]];
+            // XXX the generated anchors are not generally correct
+            // XXX there may be custom prefixes
+            result = [filenames[match[0]], fullname, '#'+fullname, descr];
+            switch (match[2]) {
+            case 1: objectResults.push(result); break;
+            case 0: importantResults.push(result); break;
+            case 2: unimportantResults.push(result); break;
+            }
+          }
+        }
+      }
+    }
+
+    // sort results descending
+    objectResults.sort(function(a, b) {
+      return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
+    });
+
+    importantResults.sort(function(a, b) {
+      return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
+    });
+
+    unimportantResults.sort(function(a, b) {
+      return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
+    });
+
+
+    // perform the search on the required terms
+    for (var i = 0; i < searchterms.length; i++) {
+      var word = searchterms[i];
+      // no match but word was a required one
+      if ((files = terms[word]) == null)
+        break;
+      if (files.length == undefined) {
+        files = [files];
+      }
+      // create the mapping
+      for (var j = 0; j < files.length; j++) {
+        var file = files[j];
+        if (file in fileMap)
+          fileMap[file].push(word);
+        else
+          fileMap[file] = [word];
+      }
+    }
+
+    // now check if the files don't contain excluded terms
+    for (var file in fileMap) {
+      var valid = true;
+
+      // check if all requirements are matched
+      if (fileMap[file].length != searchterms.length)
+        continue;
+
+      // ensure that none of the excluded terms is in the
+      // search result.
+      for (var i = 0; i < excluded.length; i++) {
+        if (terms[excluded[i]] == file ||
+            $.contains(terms[excluded[i]] || [], file)) {
+          valid = false;
+          break;
+        }
+      }
+
+      // if we have still a valid result we can add it
+      // to the result list
+      if (valid)
+        regularResults.push([filenames[file], titles[file], '', null]);
+    }
+
+    // delete unused variables in order to not waste
+    // memory until list is retrieved completely
+    delete filenames, titles, terms;
+
+    // now sort the regular results descending by title
+    regularResults.sort(function(a, b) {
+      var left = a[1].toLowerCase();
+      var right = b[1].toLowerCase();
+      return (left > right) ? -1 : ((left < right) ? 1 : 0);
+    });
+
+    // combine all results
+    var results = unimportantResults.concat(regularResults)
+      .concat(objectResults).concat(importantResults);
+
+    // print the results
+    var resultCount = results.length;
+    function displayNextItem() {
+      // results left, load the summary and display it
+      if (results.length) {
+        var item = results.pop();
+        var listItem = $('<li style="display:none"></li>');
+        if (DOCUMENTATION_OPTIONS.FILE_SUFFIX == '') {
+          // dirhtml builder
+          var dirname = item[0] + '/';
+          if (dirname.match(/\/index\/$/)) {
+            dirname = dirname.substring(0, dirname.length-6);
+          } else if (dirname == 'index/') {
+            dirname = '';
+          }
+          listItem.append($('<a/>').attr('href',
+            DOCUMENTATION_OPTIONS.URL_ROOT + dirname +
+            highlightstring + item[2]).html(item[1]));
+        } else {
+          // normal html builders
+          listItem.append($('<a/>').attr('href',
+            item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX +
+            highlightstring + item[2]).html(item[1]));
+        }
+        if (item[3]) {
+          listItem.append($('<span> (' + item[3] + ')</span>'));
+          Search.output.append(listItem);
+          listItem.slideDown(5, function() {
+            displayNextItem();
+          });
+        } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
+          $.get(DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' +
+                item[0] + '.txt', function(data) {
+            if (data != '') {
+              listItem.append($.makeSearchSummary(data, searchterms, hlterms));
+              Search.output.append(listItem);
+            }
+            listItem.slideDown(5, function() {
+              displayNextItem();
+            });
+          });
+        } else {
+          // no source available, just display title
+          Search.output.append(listItem);
+          listItem.slideDown(5, function() {
+            displayNextItem();
+          });
+        }
+      }
+      // search finished, update title and status message
+      else {
+        Search.stopPulse();
+        Search.title.text(_('Search Results'));
+        if (!resultCount)
+          Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.'));
+        else
+            Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount));
+        Search.status.fadeIn(500);
+      }
+    }
+    displayNextItem();
+  }
+}
+
+$(document).ready(function() {
+  Search.init();
+});

doc/html/_static/sidebar.js

@@ -0,0 +1,147 @@
+/*
+ * sidebar.js
+ * ~~~~~~~~~~
+ *
+ * This script makes the Sphinx sidebar collapsible.
+ *
+ * .sphinxsidebar contains .sphinxsidebarwrapper.  This script adds
+ * in .sphixsidebar, after .sphinxsidebarwrapper, the #sidebarbutton
+ * used to collapse and expand the sidebar.
+ *
+ * When the sidebar is collapsed the .sphinxsidebarwrapper is hidden
+ * and the width of the sidebar and the margin-left of the document
+ * are decreased. When the sidebar is expanded the opposite happens.
+ * This script saves a per-browser/per-session cookie used to
+ * remember the position of the sidebar among the pages.
+ * Once the browser is closed the cookie is deleted and the position
+ * reset to the default (expanded).
+ *
+ * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+$(function() {
+  // global elements used by the functions.
+  // the 'sidebarbutton' element is defined as global after its
+  // creation, in the add_sidebar_button function
+  var bodywrapper = $('.bodywrapper');
+  var sidebar = $('.sphinxsidebar');
+  var sidebarwrapper = $('.sphinxsidebarwrapper');
+
+  // original margin-left of the bodywrapper and width of the sidebar
+  // with the sidebar expanded
+  var bw_margin_expanded = bodywrapper.css('margin-left');
+  var ssb_width_expanded = sidebar.width();
+
+  // margin-left of the bodywrapper and width of the sidebar
+  // with the sidebar collapsed
+  var bw_margin_collapsed = '.8em';
+  var ssb_width_collapsed = '.8em';
+
+  // colors used by the current theme
+  var dark_color = $('.related').css('background-color');
+  var light_color = $('.document').css('background-color');
+
+  function sidebar_is_collapsed() {
+    return sidebarwrapper.is(':not(:visible)');
+  }
+
+  function toggle_sidebar() {
+    if (sidebar_is_collapsed())
+      expand_sidebar();
+    else
+      collapse_sidebar();
+  }
+
+  function collapse_sidebar() {
+    sidebarwrapper.hide();
+    sidebar.css('width', ssb_width_collapsed);
+    bodywrapper.css('margin-left', bw_margin_collapsed);
+    sidebarbutton.css({
+        'margin-left': '0',
+        'height': bodywrapper.height()
+    });
+    sidebarbutton.find('span').text('»');
+    sidebarbutton.attr('title', _('Expand sidebar'));
+    document.cookie = 'sidebar=collapsed';
+  }
+
+  function expand_sidebar() {
+    bodywrapper.css('margin-left', bw_margin_expanded);
+    sidebar.css('width', ssb_width_expanded);
+    sidebarwrapper.show();
+    sidebarbutton.css({
+        'margin-left': ssb_width_expanded-12,
+        'height': bodywrapper.height()
+    });
+    sidebarbutton.find('span').text('«');
+    sidebarbutton.attr('title', _('Collapse sidebar'));
+    document.cookie = 'sidebar=expanded';
+  }
+
+  function add_sidebar_button() {
+    sidebarwrapper.css({
+        'float': 'left',
+        'margin-right': '0',
+        'width': ssb_width_expanded - 28
+    });
+    // create the button
+    sidebar.append(
+        '<div id="sidebarbutton"><span>&laquo;</span></div>'
+    );
+    var sidebarbutton = $('#sidebarbutton');
+    // find the height of the viewport to center the '<<' in the page
+    var viewport_height;
+    if (window.innerHeight)
+ 	  viewport_height = window.innerHeight;
+    else
+	  viewport_height = $(window).height();
+    sidebarbutton.find('span').css({
+        'display': 'block',
+        'margin-top': (viewport_height - sidebar.position().top - 20) / 2
+    });
+
+    sidebarbutton.click(toggle_sidebar);
+    sidebarbutton.attr('title', _('Collapse sidebar'));
+    sidebarbutton.css({
+        'color': '#FFFFFF',
+        'border-left': '1px solid ' + dark_color,
+        'font-size': '1.2em',
+        'cursor': 'pointer',
+        'height': bodywrapper.height(),
+        'padding-top': '1px',
+        'margin-left': ssb_width_expanded - 12
+    });
+
+    sidebarbutton.hover(
+      function () {
+          $(this).css('background-color', dark_color);
+      },
+      function () {
+          $(this).css('background-color', light_color);
+      }
+    );
+  }
+
+  function set_position_from_cookie() {
+    if (!document.cookie)
+      return;
+    var items = document.cookie.split(';');
+    for(var k=0; k<items.length; k++) {
+      var key_val = items[k].split('=');
+      var key = key_val[0];
+      if (key == 'sidebar') {
+        var value = key_val[1];
+        if ((value == 'collapsed') && (!sidebar_is_collapsed()))
+          collapse_sidebar();
+        else if ((value == 'expanded') && (sidebar_is_collapsed()))
+          expand_sidebar();
+      }
+    }
+  }
+
+  add_sidebar_button();
+  var sidebarbutton = $('#sidebarbutton');
+  set_position_from_cookie();
+});

doc/html/_static/underscore.js

@@ -0,0 +1,16 @@
+(function(){var j=this,n=j._,i=function(a){this._wrapped=a},m=typeof StopIteration!=="undefined"?StopIteration:"__break__",b=j._=function(a){return new i(a)};if(typeof exports!=="undefined")exports._=b;var k=Array.prototype.slice,o=Array.prototype.unshift,p=Object.prototype.toString,q=Object.prototype.hasOwnProperty,r=Object.prototype.propertyIsEnumerable;b.VERSION="0.5.5";b.each=function(a,c,d){try{if(a.forEach)a.forEach(c,d);else if(b.isArray(a)||b.isArguments(a))for(var e=0,f=a.length;e<f;e++)c.call(d,
+a[e],e,a);else{var g=b.keys(a);f=g.length;for(e=0;e<f;e++)c.call(d,a[g[e]],g[e],a)}}catch(h){if(h!=m)throw h;}return a};b.map=function(a,c,d){if(a&&b.isFunction(a.map))return a.map(c,d);var e=[];b.each(a,function(f,g,h){e.push(c.call(d,f,g,h))});return e};b.reduce=function(a,c,d,e){if(a&&b.isFunction(a.reduce))return a.reduce(b.bind(d,e),c);b.each(a,function(f,g,h){c=d.call(e,c,f,g,h)});return c};b.reduceRight=function(a,c,d,e){if(a&&b.isFunction(a.reduceRight))return a.reduceRight(b.bind(d,e),c);
+var f=b.clone(b.toArray(a)).reverse();b.each(f,function(g,h){c=d.call(e,c,g,h,a)});return c};b.detect=function(a,c,d){var e;b.each(a,function(f,g,h){if(c.call(d,f,g,h)){e=f;b.breakLoop()}});return e};b.select=function(a,c,d){if(a&&b.isFunction(a.filter))return a.filter(c,d);var e=[];b.each(a,function(f,g,h){c.call(d,f,g,h)&&e.push(f)});return e};b.reject=function(a,c,d){var e=[];b.each(a,function(f,g,h){!c.call(d,f,g,h)&&e.push(f)});return e};b.all=function(a,c,d){c=c||b.identity;if(a&&b.isFunction(a.every))return a.every(c,
+d);var e=true;b.each(a,function(f,g,h){(e=e&&c.call(d,f,g,h))||b.breakLoop()});return e};b.any=function(a,c,d){c=c||b.identity;if(a&&b.isFunction(a.some))return a.some(c,d);var e=false;b.each(a,function(f,g,h){if(e=c.call(d,f,g,h))b.breakLoop()});return e};b.include=function(a,c){if(b.isArray(a))return b.indexOf(a,c)!=-1;var d=false;b.each(a,function(e){if(d=e===c)b.breakLoop()});return d};b.invoke=function(a,c){var d=b.rest(arguments,2);return b.map(a,function(e){return(c?e[c]:e).apply(e,d)})};b.pluck=
+function(a,c){return b.map(a,function(d){return d[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);var e={computed:-Infinity};b.each(a,function(f,g,h){g=c?c.call(d,f,g,h):f;g>=e.computed&&(e={value:f,computed:g})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);var e={computed:Infinity};b.each(a,function(f,g,h){g=c?c.call(d,f,g,h):f;g<e.computed&&(e={value:f,computed:g})});return e.value};b.sortBy=function(a,c,d){return b.pluck(b.map(a,
+function(e,f,g){return{value:e,criteria:c.call(d,e,f,g)}}).sort(function(e,f){e=e.criteria;f=f.criteria;return e<f?-1:e>f?1:0}),"value")};b.sortedIndex=function(a,c,d){d=d||b.identity;for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?(e=g+1):(f=g)}return e};b.toArray=function(a){if(!a)return[];if(a.toArray)return a.toArray();if(b.isArray(a))return a;if(b.isArguments(a))return k.call(a);return b.values(a)};b.size=function(a){return b.toArray(a).length};b.first=function(a,c,d){return c&&!d?k.call(a,
+0,c):a[0]};b.rest=function(a,c,d){return k.call(a,b.isUndefined(c)||d?1:c)};b.last=function(a){return a[a.length-1]};b.compact=function(a){return b.select(a,function(c){return!!c})};b.flatten=function(a){return b.reduce(a,[],function(c,d){if(b.isArray(d))return c.concat(b.flatten(d));c.push(d);return c})};b.without=function(a){var c=b.rest(arguments);return b.select(a,function(d){return!b.include(c,d)})};b.uniq=function(a,c){return b.reduce(a,[],function(d,e,f){if(0==f||(c===true?b.last(d)!=e:!b.include(d,
+e)))d.push(e);return d})};b.intersect=function(a){var c=b.rest(arguments);return b.select(b.uniq(a),function(d){return b.all(c,function(e){return b.indexOf(e,d)>=0})})};b.zip=function(){for(var a=b.toArray(arguments),c=b.max(b.pluck(a,"length")),d=new Array(c),e=0;e<c;e++)d[e]=b.pluck(a,String(e));return d};b.indexOf=function(a,c){if(a.indexOf)return a.indexOf(c);for(var d=0,e=a.length;d<e;d++)if(a[d]===c)return d;return-1};b.lastIndexOf=function(a,c){if(a.lastIndexOf)return a.lastIndexOf(c);for(var d=
+a.length;d--;)if(a[d]===c)return d;return-1};b.range=function(a,c,d){var e=b.toArray(arguments),f=e.length<=1;a=f?0:e[0];c=f?e[0]:e[1];d=e[2]||1;e=Math.ceil((c-a)/d);if(e<=0)return[];e=new Array(e);f=a;for(var g=0;1;f+=d){if((d>0?f-c:c-f)>=0)return e;e[g++]=f}};b.bind=function(a,c){var d=b.rest(arguments,2);return function(){return a.apply(c||j,d.concat(b.toArray(arguments)))}};b.bindAll=function(a){var c=b.rest(arguments);if(c.length==0)c=b.functions(a);b.each(c,function(d){a[d]=b.bind(a[d],a)});
+return a};b.delay=function(a,c){var d=b.rest(arguments,2);return setTimeout(function(){return a.apply(a,d)},c)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(b.rest(arguments)))};b.wrap=function(a,c){return function(){var d=[a].concat(b.toArray(arguments));return c.apply(c,d)}};b.compose=function(){var a=b.toArray(arguments);return function(){for(var c=b.toArray(arguments),d=a.length-1;d>=0;d--)c=[a[d].apply(this,c)];return c[0]}};b.keys=function(a){if(b.isArray(a))return b.range(0,a.length);
+var c=[];for(var d in a)q.call(a,d)&&c.push(d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=function(a){return b.select(b.keys(a),function(c){return b.isFunction(a[c])}).sort()};b.extend=function(a,c){for(var d in c)a[d]=c[d];return a};b.clone=function(a){if(b.isArray(a))return a.slice(0);return b.extend({},a)};b.tap=function(a,c){c(a);return a};b.isEqual=function(a,c){if(a===c)return true;var d=typeof a;if(d!=typeof c)return false;if(a==c)return true;if(!a&&c||a&&!c)return false;
+if(a.isEqual)return a.isEqual(c);if(b.isDate(a)&&b.isDate(c))return a.getTime()===c.getTime();if(b.isNaN(a)&&b.isNaN(c))return true;if(b.isRegExp(a)&&b.isRegExp(c))return a.source===c.source&&a.global===c.global&&a.ignoreCase===c.ignoreCase&&a.multiline===c.multiline;if(d!=="object")return false;if(a.length&&a.length!==c.length)return false;d=b.keys(a);var e=b.keys(c);if(d.length!=e.length)return false;for(var f in a)if(!b.isEqual(a[f],c[f]))return false;return true};b.isEmpty=function(a){return b.keys(a).length==
+0};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=function(a){return!!(a&&a.concat&&a.unshift)};b.isArguments=function(a){return a&&b.isNumber(a.length)&&!b.isArray(a)&&!r.call(a,"length")};b.isFunction=function(a){return!!(a&&a.constructor&&a.call&&a.apply)};b.isString=function(a){return!!(a===""||a&&a.charCodeAt&&a.substr)};b.isNumber=function(a){return p.call(a)==="[object Number]"};b.isDate=function(a){return!!(a&&a.getTimezoneOffset&&a.setUTCFullYear)};b.isRegExp=function(a){return!!(a&&
+a.test&&a.exec&&(a.ignoreCase||a.ignoreCase===false))};b.isNaN=function(a){return b.isNumber(a)&&isNaN(a)};b.isNull=function(a){return a===null};b.isUndefined=function(a){return typeof a=="undefined"};b.noConflict=function(){j._=n;return this};b.identity=function(a){return a};b.breakLoop=function(){throw m;};var s=0;b.uniqueId=function(a){var c=s++;return a?a+c:c};b.template=function(a,c){a=new Function("obj","var p=[],print=function(){p.push.apply(p,arguments);};with(obj){p.push('"+a.replace(/[\r\t\n]/g,
+" ").replace(/'(?=[^%]*%>)/g,"\t").split("'").join("\\'").split("\t").join("'").replace(/<%=(.+?)%>/g,"',$1,'").split("<%").join("');").split("%>").join("p.push('")+"');}return p.join('');");return c?a(c):a};b.forEach=b.each;b.foldl=b.inject=b.reduce;b.foldr=b.reduceRight;b.filter=b.select;b.every=b.all;b.some=b.any;b.head=b.first;b.tail=b.rest;b.methods=b.functions;var l=function(a,c){return c?b(a).chain():a};b.each(b.functions(b),function(a){var c=b[a];i.prototype[a]=function(){var d=b.toArray(arguments);
+o.call(d,this._wrapped);return l(c.apply(b,d),this._chain)}});b.each(["pop","push","reverse","shift","sort","splice","unshift"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){c.apply(this._wrapped,arguments);return l(this._wrapped,this._chain)}});b.each(["concat","join","slice"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){return l(c.apply(this._wrapped,arguments),this._chain)}});i.prototype.chain=function(){this._chain=true;return this};i.prototype.value=function(){return this._wrapped}})();

doc/html/api/css/style.css

@@ -0,0 +1,220 @@
+body
+{
+    margin: 0;
+    padding: 0;
+    border: 0;
+    color: black;
+    background-color: #1f252b;
+    font-size: 100%;
+    font-family: Verdana, "Deja Vu", "Bitstream Vera Sans", sans-serif;
+}
+
+h1, h2, h3, h4, h5, h6
+{
+    font-family: Georgia, "Times New Roman", Times, serif;
+    font-weight: normal;
+    color: #633;
+    line-height: normal;
+    text-align: left;
+}
+
+h1
+{
+    margin-top: 0;
+    font-size: 2.5em;
+}
+
+h2{font-size: 1.7em;}
+
+h3{font-size: 1.35em;}
+
+h4
+{
+    font-size: 1.15em;
+    font-style: italic;
+    margin-bottom: 0;
+}
+
+pre
+{
+    background: #eef;
+    padding: 1ex;
+    margin: 1em 0 1em 3em;
+    font-family: monospace;
+    font-size: 1.2em;
+    line-height: normal;
+    border: 1px solid #ccc;
+    width: auto;
+}
+
+dd
+{
+    padding: 1ex;
+    margin-left: 3em;
+    margin-bottom: 1em;
+}
+
+td{text-align: justify;}
+
+hr{margin: 2em 0;}
+
+a{color: #006;}
+
+a:visited{color: #606;}
+
+/* These are different kinds of <pre> sections */
+.console /* command line console */
+{
+    background-color: #f7f7f7;
+    color: #181818;
+}
+
+.moddeffile /* module definition file */
+{
+    background-color: #efeffe;
+    color: #010199;
+}
+
+.d_code /* D code */
+{
+    background-color: #fcfcfc;
+    color: #000066;
+}
+
+.d_code2 /* D code */
+{
+    background-color: #fcfcfc;
+    color: #000066;
+}
+
+td .d_code2
+{
+    min-width: 20em;
+    margin: 1em 0em;
+}
+
+.d_inlinecode
+{
+    font-family: monospace;
+    font-weight: bold;
+}
+
+/* Elements of D source code text */
+.d_comment{color: green;}
+.d_string {color: red;}
+.d_keyword{color: blue;}
+.d_psymbol{text-decoration: underline;}
+.d_param  {font-style: italic;}
+
+/* Focal symbol that is being documented */
+.ddoc_psymbol{color: #336600;}
+
+div#top{max-width: 85em;}
+
+div#header{padding: 0.2em 1em 0.2em 1em;}
+div.pbr
+{
+    margin: 4px 0px 8px 10px}
+
+img#logo{vertical-align: bottom;}
+
+#main-heading
+{
+    margin-left: 1em;
+    color: white;
+    font-size: 1.4em;
+    font-family: Arial, Verdana, sans-serif;
+    font-variant: small-caps;
+    text-decoration: none;
+}
+
+div#navigation
+{
+    font-size: 0.875em;
+    float: left;
+    width: 12.0em;
+    padding: 0 1.5em;
+}
+
+div.navblock
+{
+    margin-top: 0;
+    margin-bottom: 1em;
+}
+
+div#navigation .navblock h2
+{
+    font-family: Verdana, "Deja Vu", "Bitstream Vera Sans", sans-serif;
+    font-size: 1.35em;
+    color: #ccc;
+    margin: 0;
+}
+
+div#navigation .navblock ul
+{
+    list-style-type: none;
+    margin: 0;
+    padding: 0;
+}
+
+div#navigation .navblock li
+{
+    margin: 0 0 0 0.8em;
+    padding: 0;
+}
+
+#navigation .navblock a
+{
+    display: block;
+    color: #ddd;
+    text-decoration: none;
+    padding: 0.1em 0;
+    border-bottom: 1px dashed #444;
+}
+
+#navigation .navblock a:hover{color: white;}
+
+#navigation .navblock a.active
+{
+    color: white;
+    border-color: white;
+}
+
+div#content
+{
+    min-height: 440px;
+    margin-left: 15em;
+    margin-right: 1.6em;
+    padding: 1.6em;
+    padding-top: 1.3em;
+    border: 0.6em solid #cccccc;
+    background-color: #f6f6f6;
+    font-size: 0.875em;
+    line-height: 1.4em;
+}
+
+div#content li{padding-bottom: .7ex;}
+
+div#copyright
+{
+    padding: 1em 2em;
+    background-color: #303333;
+    color: #ccc;
+    font-size: 0.75em;
+    text-align: center;
+}
+
+div#copyright a{color: #ccc;}
+
+.d_inlinecode
+{
+    font-family: Consolas, "Bitstream Vera Sans Mono", "Andale Mono", "DejaVu Sans Mono", "Lucida Console", monospace;
+}
+
+.d_decl
+{
+    font-weight: bold;
+    background-color: #E4E9EF;
+    border-bottom: solid 2px #336600;
+    padding: 2px 0px 2px 2px;
+}

doc/html/api/dyaml.constructor.html

@@ -0,0 +1,192 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+        "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang='en'>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" >
+<title>dyaml.constructor - D:YAML 0.1 API documentation</title>
+<link rel="stylesheet" type="text/css" href="css/style.css">
+</head>
+
+<body><div id="top">
+<div id="header">
+<img id="logo" alt="D:YAML logo" src="images/logo.png"><a id="main-heading" href="index.html">D:YAML 0.1 API documentation</a>
+</div>
+</div>
+
+<div id="navigation">
+<div class="navblock">
+<div id="toctop">
+<ul><li><a href="../index.html">Documentation home</a></li>
+</ul>
+</div>
+</div>
+<div class="navblock">
+<ul><li><a href="index.html">Main page</a></li>
+<li><a href="dyaml.constructor.html">dyaml.constructor</a></li>
+<li><a href="dyaml.exception.html">dyaml.exception</a></li>
+<li><a href="dyaml.loader.html">dyaml.loader</a></li>
+<li><a href="dyaml.node.html">dyaml.node</a></li>
+<li><a href="dyaml.resolver.html">dyaml.resolver</a></li>
+</ul>
+</div>
+</div>
+
+<div id="content">
+<h1>dyaml.constructor</h1>
+<!-- Generated by Ddoc from dyaml/constructor.d -->
+<p>Implements a class that processes YAML mappings, sequences and scalars into
+ nodes. This can be used to implement custom data types. A tutorial can be
+ found <a href="../tutorials/custom_types.html">here</a>.</p>
+
+<dl><dt class="d_decl">class <a name="ConstructorException"></a><span class="ddoc_psymbol">ConstructorException</span>: dyaml.exception.YAMLException;
+</dt>
+<dd><p>Exception thrown at constructor errors.
+</p>
+<p>Can be thrown by custom constructor functions.</p>
+
+<dl><dt class="d_decl">this(string <b>msg</b>, Mark <b>start</b>, Mark <b>end</b>);
+</dt>
+<dd><p>Construct a ConstructorException.
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>string <b>msg</b></td>
+<td valign=top>Error message.</td></tr>
+<tr><td valign=top>Mark <b>start</b></td>
+<td valign=top>Start position of the error context.</td></tr>
+<tr><td valign=top>Mark <b>end</b></td>
+<td valign=top>End position of the error context.</td></tr>
+</table></div>
+
+</dd>
+</dl>
+</dd>
+<dt class="d_decl">class <a name="Constructor"></a><span class="ddoc_psymbol">Constructor</span>;
+</dt>
+<dd><p>Constructs YAML values.
+</p>
+<p>Each YAML scalar, sequence or mapping has a tag specifying its data type.
+ <a name="Constructor"></a><span class="ddoc_psymbol">Constructor</span> uses user-specifyable functions to create a node of desired
+ data type from a scalar, sequence or mapping.
+<br>
+
+ Each of these functions is associated with a tag, and can process either
+ a scalar, a sequence, or a mapping. The constructor passes each value to
+ the function with corresponding tag, which then returns the resulting value
+ that can be stored in a node.
+<br>
+
+ If a tag is detected with no known constructor function, it is considered an error.</p>
+
+<dl><dt class="d_decl">this(in bool <b>defaultConstructors</b> = true);
+</dt>
+<dd><p>Construct a Constructor.
+</p>
+<p>If you don't want to support default YAML tags/data types, you can use
+ <b>defaultConstructors</b> to disable constructor functions for these.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>bool <b>defaultConstructors</b></td>
+<td valign=top>Use constructors for default YAML tags?</td></tr>
+</table></div>
+
+</dd>
+<dt class="d_decl">void <a name="addConstructor"></a><span class="ddoc_psymbol">addConstructor</span>(T, U)(in string <b>tag</b>, T function(Mark, Mark, U) <b>ctor</b>);
+</dt>
+<dd><p>Add a constructor function.
+</p>
+<p>The function passed must two Marks (determining start and end positions of
+ the node in file) and either a string (if constructing from scalar),
+ an array of Nodes (from sequence) or an array of Node.Pair (from mapping).
+ The value returned by this function will be stored in the resulring node.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>tag</td>
+<td valign=top>Tag for the function to handle.</td></tr>
+<tr><td valign=top>ctor</td>
+<td valign=top>Constructor function.</td></tr>
+</table></div>
+
+</dd>
+</dl>
+</dd>
+<dt class="d_decl">YAMLNull <a name="constructNull"></a><span class="ddoc_psymbol">constructNull</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct a <b>null</b> node.</p>
+
+</dd>
+<dt class="d_decl">YAMLMerge <a name="constructMerge"></a><span class="ddoc_psymbol">constructMerge</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct a merge node - a node that merges another node into a mapping.</p>
+
+</dd>
+<dt class="d_decl">bool <a name="constructBool"></a><span class="ddoc_psymbol">constructBool</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct a boolean node.</p>
+
+</dd>
+<dt class="d_decl">long <a name="constructLong"></a><span class="ddoc_psymbol">constructLong</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct an integer (long) node.</p>
+
+</dd>
+<dt class="d_decl">real <a name="constructReal"></a><span class="ddoc_psymbol">constructReal</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct a floating point (real) node.</p>
+
+</dd>
+<dt class="d_decl">ubyte[] <a name="constructBinary"></a><span class="ddoc_psymbol">constructBinary</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct a binary (base64) node.</p>
+
+</dd>
+<dt class="d_decl">SysTime <a name="constructTimestamp"></a><span class="ddoc_psymbol">constructTimestamp</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct a timestamp (SysTime) node.</p>
+
+</dd>
+<dt class="d_decl">string <a name="constructString"></a><span class="ddoc_psymbol">constructString</span>(Mark <b>start</b>, Mark <b>end</b>, string <b>value</b>);
+</dt>
+<dd><p>Construct a string node.</p>
+
+</dd>
+<dt class="d_decl">Pair[] <a name="getPairs"></a><span class="ddoc_psymbol">getPairs</span>(string <b>type</b>, Mark <b>start</b>, Mark <b>end</b>, Node[] <b>nodes</b>);
+</dt>
+<dd><p>Convert a sequence of single-element mappings into a sequence of pairs.</p>
+
+</dd>
+<dt class="d_decl">Pair[] <a name="constructOrderedMap"></a><span class="ddoc_psymbol">constructOrderedMap</span>(Mark <b>start</b>, Mark <b>end</b>, Node[] <b>nodes</b>);
+</dt>
+<dd><p>Construct an ordered map (ordered sequence of key:value pairs without duplicates) node.</p>
+
+</dd>
+<dt class="d_decl">Pair[] <a name="constructPairs"></a><span class="ddoc_psymbol">constructPairs</span>(Mark <b>start</b>, Mark <b>end</b>, Node[] <b>nodes</b>);
+</dt>
+<dd><p>Construct a pairs (ordered sequence of key: value pairs allowing duplicates) node.</p>
+
+</dd>
+<dt class="d_decl">Node[] <a name="constructSet"></a><span class="ddoc_psymbol">constructSet</span>(Mark <b>start</b>, Mark <b>end</b>, Pair[] <b>pairs</b>);
+</dt>
+<dd><p>Construct a set node.</p>
+
+</dd>
+<dt class="d_decl">Node[] <a name="constructSequence"></a><span class="ddoc_psymbol">constructSequence</span>(Mark <b>start</b>, Mark <b>end</b>, Node[] <b>nodes</b>);
+</dt>
+<dd><p>Construct a sequence (array) node.</p>
+
+</dd>
+<dt class="d_decl">Pair[] <a name="constructMap"></a><span class="ddoc_psymbol">constructMap</span>(Mark <b>start</b>, Mark <b>end</b>, Pair[] <b>pairs</b>);
+</dt>
+<dd><p>Construct an unordered map (unordered set of key: value pairs without duplicates) node.</p>
+
+</dd>
+</dl>
+
+</div>
+
+<div id="copyright">
+Copyright &copy; Ferdinand Majerech 2011. Based on <a href="http://www.pyyaml.org">PyYAML</a> by Kirill Simonov. |
+Page generated by Autodoc and <a href="http://www.digitalmars.com/d/2.0/ddoc.html">Ddoc</a>.
+</div>
+
+</body>
+</html>

doc/html/api/dyaml.exception.html

@@ -0,0 +1,78 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+        "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang='en'>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" >
+<title>dyaml.exception - D:YAML 0.1 API documentation</title>
+<link rel="stylesheet" type="text/css" href="css/style.css">
+</head>
+
+<body><div id="top">
+<div id="header">
+<img id="logo" alt="D:YAML logo" src="images/logo.png"><a id="main-heading" href="index.html">D:YAML 0.1 API documentation</a>
+</div>
+</div>
+
+<div id="navigation">
+<div class="navblock">
+<div id="toctop">
+<ul><li><a href="../index.html">Documentation home</a></li>
+</ul>
+</div>
+</div>
+<div class="navblock">
+<ul><li><a href="index.html">Main page</a></li>
+<li><a href="dyaml.constructor.html">dyaml.constructor</a></li>
+<li><a href="dyaml.exception.html">dyaml.exception</a></li>
+<li><a href="dyaml.loader.html">dyaml.loader</a></li>
+<li><a href="dyaml.node.html">dyaml.node</a></li>
+<li><a href="dyaml.resolver.html">dyaml.resolver</a></li>
+</ul>
+</div>
+</div>
+
+<div id="content">
+<h1>dyaml.exception</h1>
+<!-- Generated by Ddoc from dyaml/exception.d -->
+<p><b>D:</b><br>
+YAML exceptions and <a name="exception"></a><span class="ddoc_psymbol">exception</span> related code.</p>
+
+<dl><dt class="d_decl">class <a name="YAMLException"></a><span class="ddoc_psymbol">YAMLException</span>: object.Exception;
+</dt>
+<dd><p>Base class for all exceptions thrown by D:YAML.</p>
+
+<dl><dt class="d_decl">this(string <b>msg</b>);
+</dt>
+<dd><p>Construct a YAMLException with specified message.</p>
+
+</dd>
+</dl>
+</dd>
+<dt class="d_decl">struct <a name="Mark"></a><span class="ddoc_psymbol">Mark</span>;
+</dt>
+<dd><p>Position in a YAML stream, used for error messages.</p>
+
+<dl><dt class="d_decl">this(in uint <b>line</b>, in uint <b>column</b>);
+</dt>
+<dd><p>Construct a Mark with specified <b>line</b> and <b>column</b> in the file.</p>
+
+</dd>
+<dt class="d_decl">const string <a name="toString"></a><span class="ddoc_psymbol">toString</span>();
+</dt>
+<dd><p>Get a string representation of the mark.</p>
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+</div>
+
+<div id="copyright">
+Copyright &copy; Ferdinand Majerech 2011. Based on <a href="http://www.pyyaml.org">PyYAML</a> by Kirill Simonov. |
+Page generated by Autodoc and <a href="http://www.digitalmars.com/d/2.0/ddoc.html">Ddoc</a>.
+</div>
+
+</body>
+</html>

doc/html/api/dyaml.loader.html

@@ -0,0 +1,216 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+        "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang='en'>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" >
+<title>dyaml.loader - D:YAML 0.1 API documentation</title>
+<link rel="stylesheet" type="text/css" href="css/style.css">
+</head>
+
+<body><div id="top">
+<div id="header">
+<img id="logo" alt="D:YAML logo" src="images/logo.png"><a id="main-heading" href="index.html">D:YAML 0.1 API documentation</a>
+</div>
+</div>
+
+<div id="navigation">
+<div class="navblock">
+<div id="toctop">
+<ul><li><a href="../index.html">Documentation home</a></li>
+</ul>
+</div>
+</div>
+<div class="navblock">
+<ul><li><a href="index.html">Main page</a></li>
+<li><a href="dyaml.constructor.html">dyaml.constructor</a></li>
+<li><a href="dyaml.exception.html">dyaml.exception</a></li>
+<li><a href="dyaml.loader.html">dyaml.loader</a></li>
+<li><a href="dyaml.node.html">dyaml.node</a></li>
+<li><a href="dyaml.resolver.html">dyaml.resolver</a></li>
+</ul>
+</div>
+</div>
+
+<div id="content">
+<h1>dyaml.loader</h1>
+<!-- Generated by Ddoc from dyaml/loader.d -->
+<p>Class and convenience functions used to load YAML documents.</p>
+
+<dl><dt class="d_decl">Node <a name="load"></a><span class="ddoc_psymbol">load</span>(in string <b>filename</b>);
+</dt>
+<dd><p>Load single YAML document from a file.
+</p>
+<p>If there is no or more than one YAML document in the file, this will throw.
+ Use <a href="#loadAll"><span class="d_inlinecode">loadAll</span></a> for such files.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>string <b>filename</b></td>
+<td valign=top>Name of the file to load from.</td></tr>
+</table></div>
+<b>Returns:</b><div class="pbr">Root node of the document.
+
+</div>
+<b>Throws:</b><div class="pbr">YAMLException if there wasn't exactly one document in the file,
+          the file could not be opened or on a YAML parsing error.</div>
+
+</dd>
+<dt class="d_decl">Node <a name="load"></a><span class="ddoc_psymbol">load</span>(Stream <b>input</b>, in string <b>name</b> = "&lt;unknown&gt;");
+</dt>
+<dd><p>Load single YAML document from a stream.
+</p>
+<p>You can use this to e.g load YAML from memory.
+<br>
+
+ If there is no or more than one YAML document in the stream, this will throw.
+ Use <a href="#loadAll"><span class="d_inlinecode">loadAll</span></a> for such files.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>Stream <b>input</b></td>
+<td valign=top>Stream to read from. Must be readable.</td></tr>
+<tr><td valign=top>string <b>name</b></td>
+<td valign=top>Name of the stream, used in error messages.</td></tr>
+</table></div>
+<b>Returns:</b><div class="pbr">Root node of the document.
+
+</div>
+<b>Throws:</b><div class="pbr">YAMLException if there wasn't exactly one document in the stream,
+          the stream could not be read from or on a YAML parsing error.
+
+</div>
+<b>Examples:</b><div class="pbr">Loading YAML from memory:
+<pre class="d_code"> <span class="d_keyword">import</span> std.stream;
+ <span class="d_keyword">import</span> std.stdio;
+
+ string yaml_input = <span class="d_string">"red:   '#ff0000'\n"</span>
+                     <span class="d_string">"green: '#00ff00'\n"</span>
+                     <span class="d_string">"blue:  '#0000ff'"</span>;
+
+ <span class="d_keyword">auto</span> colors = yaml.<span class="d_psymbol">load</span>(<span class="d_keyword">new</span> MemoryStream(<span class="d_keyword">cast</span>(<span class="d_keyword">char</span>[])yaml_input));
+
+ <span class="d_keyword">foreach</span>(string color, string value; colors)
+ {
+     writeln(color, <span class="d_string">" is "</span>, value, <span class="d_string">" in HTML/CSS"</span>);
+ }
+</pre>
+</div>
+
+</dd>
+<dt class="d_decl">Node[] <a name="loadAll"></a><span class="ddoc_psymbol">loadAll</span>(in string <b>filename</b>);
+</dt>
+<dd><p>Load all YAML documents from a file.
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>string <b>filename</b></td>
+<td valign=top>Name of the file to load from.</td></tr>
+</table></div>
+<b>Returns:</b><div class="pbr">Array of root nodes of documents in the stream.
+          If the stream is empty, empty array will be returned.
+
+</div>
+<b>Throws:</b><div class="pbr">YAMLException if the file could not be opened or on a YAML parsing error.</div>
+
+</dd>
+<dt class="d_decl">Node[] <a name="loadAll"></a><span class="ddoc_psymbol">loadAll</span>(Stream <b>input</b>, in string <b>name</b> = "&lt;unknown&gt;");
+</dt>
+<dd><p>Load all YAML documents from a stream.
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>Stream <b>input</b></td>
+<td valign=top>Stream to read from. Must be readable.</td></tr>
+<tr><td valign=top>string <b>name</b></td>
+<td valign=top>Name of the stream, used in error messages.</td></tr>
+</table></div>
+<b>Returns:</b><div class="pbr">Array of root nodes of documents in the file.
+          If the file is empty, empty array will be returned.
+
+</div>
+<b>Throws:</b><div class="pbr">YAMLException if the stream could not be read from or on a YAML parsing error.</div>
+
+</dd>
+<dt class="d_decl">struct <a name="Loader"></a><span class="ddoc_psymbol">Loader</span>;
+</dt>
+<dd><p>Loads YAML documents from files or streams.</p>
+
+<dl><dt class="d_decl">this(in string <b>filename</b>);
+</dt>
+<dd><p>Construct a Loader to load YAML from a file.
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>string <b>filename</b></td>
+<td valign=top>Name of the file to load from.</td></tr>
+</table></div>
+<b>Throws:</b><div class="pbr">YAMLException if the file could not be opened or read from.</div>
+
+</dd>
+<dt class="d_decl">this(in string <b>filename</b>, Constructor <b>constructor</b>, Resolver <b>resolver</b>);
+</dt>
+<dd><p>Construct a Loader to load YAML from a file, with provided constructor and resolver.
+</p>
+<p>Constructor and resolver can be used to implement custom data types in YAML.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>string <b>filename</b></td>
+<td valign=top>Name of the file to load from.</td></tr>
+<tr><td valign=top>Constructor <b>constructor</b></td>
+<td valign=top>Constructor to use.</td></tr>
+<tr><td valign=top>Resolver <b>resolver</b></td>
+<td valign=top>Resolver to use.</td></tr>
+</table></div>
+<b>Throws:</b><div class="pbr">YAMLException if the file could not be opened or read from.</div>
+
+</dd>
+<dt class="d_decl">this(Stream <b>input</b>, in string <b>name</b>, Constructor <b>constructor</b>, Resolver <b>resolver</b>);
+</dt>
+<dd><p>Construct a Loader to load YAML from a stream with provided constructor and resolver.
+</p>
+<p>Stream can be used to load YAML from memory and other sources.
+ Constructor and resolver can be used to implement custom data types in YAML.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>Stream <b>input</b></td>
+<td valign=top>Stream to read from. Must be readable.</td></tr>
+<tr><td valign=top>string <b>name</b></td>
+<td valign=top>Name of the stream. Used in error messages.</td></tr>
+<tr><td valign=top>Constructor <b>constructor</b></td>
+<td valign=top>Constructor to use.</td></tr>
+<tr><td valign=top>Resolver <b>resolver</b></td>
+<td valign=top>Resolver to use.</td></tr>
+</table></div>
+<b>Throws:</b><div class="pbr">YAMLException if the stream could not be read from.</div>
+
+</dd>
+<dt class="d_decl">Node <a name="loadSingleDocument"></a><span class="ddoc_psymbol">loadSingleDocument</span>();
+</dt>
+<dd><p>Load single YAML document.
+</p>
+<p>If no or more than one YAML document is found, this will throw a YAMLException.
+
+</p>
+<b>Returns:</b><div class="pbr">Root node of the document.
+
+</div>
+<b>Throws:</b><div class="pbr">YAMLException if there wasn't exactly one document
+          or on a YAML parsing error.</div>
+
+</dd>
+<dt class="d_decl">int <a name="opApply"></a><span class="ddoc_psymbol">opApply</span>(int delegate(ref Node) <b>dg</b>);
+</dt>
+<dd><p>Foreach over YAML documents.
+</p>
+<p>Parses documents lazily, as they are needed.
+
+</p>
+<b>Throws:</b><div class="pbr">YAMLException on a parsing error.</div>
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+</div>
+
+<div id="copyright">
+Copyright &copy; Ferdinand Majerech 2011. Based on <a href="http://www.pyyaml.org">PyYAML</a> by Kirill Simonov. |
+Page generated by Autodoc and <a href="http://www.digitalmars.com/d/2.0/ddoc.html">Ddoc</a>.
+</div>
+
+</body>
+</html>

doc/html/api/dyaml.node.html

@@ -0,0 +1,260 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+        "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang='en'>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" >
+<title>dyaml.node - D:YAML 0.1 API documentation</title>
+<link rel="stylesheet" type="text/css" href="css/style.css">
+</head>
+
+<body><div id="top">
+<div id="header">
+<img id="logo" alt="D:YAML logo" src="images/logo.png"><a id="main-heading" href="index.html">D:YAML 0.1 API documentation</a>
+</div>
+</div>
+
+<div id="navigation">
+<div class="navblock">
+<div id="toctop">
+<ul><li><a href="../index.html">Documentation home</a></li>
+</ul>
+</div>
+</div>
+<div class="navblock">
+<ul><li><a href="index.html">Main page</a></li>
+<li><a href="dyaml.constructor.html">dyaml.constructor</a></li>
+<li><a href="dyaml.exception.html">dyaml.exception</a></li>
+<li><a href="dyaml.loader.html">dyaml.loader</a></li>
+<li><a href="dyaml.node.html">dyaml.node</a></li>
+<li><a href="dyaml.resolver.html">dyaml.resolver</a></li>
+</ul>
+</div>
+</div>
+
+<div id="content">
+<h1>dyaml.node</h1>
+<!-- Generated by Ddoc from dyaml/node.d -->
+<p>Node of a YAML document. Used to read YAML data once it's loaded.</p>
+
+<dl><dt class="d_decl">class <a name="NodeException"></a><span class="ddoc_psymbol">NodeException</span>: dyaml.exception.YAMLException;
+</dt>
+<dd><p>Exception thrown at node related errors.</p>
+
+</dd>
+<dt class="d_decl">struct <a name="YAMLNull"></a><span class="ddoc_psymbol">YAMLNull</span>;
+</dt>
+<dd><p>Null YAML type. Used in nodes with null values.</p>
+
+</dd>
+<dt class="d_decl">struct <a name="Node"></a><span class="ddoc_psymbol">Node</span>;
+</dt>
+<dd><p>YAML node.
+</p>
+<p>This is a pseudo-dynamic type that can store any YAML value, including sequence
+ or a mapping of nodes. You can get data from a <a name="Node"></a><span class="ddoc_psymbol">Node</span> directly or iterate over it
+ if it's a sequence or a mapping.</p>
+
+<dl><dt class="d_decl">struct <a name="Pair"></a><span class="ddoc_psymbol">Pair</span>;
+</dt>
+<dd><p><a name="Pair"></a><span class="ddoc_psymbol">Pair</span> of YAML nodes, used in mappings.</p>
+
+<dl><dt class="d_decl">Node <a name="key"></a><span class="ddoc_psymbol">key</span>;
+</dt>
+<dd><p>Key node.</p>
+
+</dd>
+<dt class="d_decl">Node <a name="value"></a><span class="ddoc_psymbol">value</span>;
+</dt>
+<dd><p>Value node.</p>
+
+</dd>
+<dt class="d_decl">bool <a name="equals"></a><span class="ddoc_psymbol">equals</span>(ref Pair <b>rhs</b>);
+</dt>
+<dd><p>Test for equality with another Pair.</p>
+
+</dd>
+</dl>
+</dd>
+<dt class="d_decl">const @property bool <a name="isValid"></a><span class="ddoc_psymbol">isValid</span>();
+</dt>
+<dd><p>Is this node valid (initialized)? </p>
+
+</dd>
+<dt class="d_decl">const @property bool <a name="isScalar"></a><span class="ddoc_psymbol">isScalar</span>();
+</dt>
+<dd><p>Is this node a scalar value?</p>
+
+</dd>
+<dt class="d_decl">const @property bool <a name="isSequence"></a><span class="ddoc_psymbol">isSequence</span>();
+</dt>
+<dd><p>Is this node a sequence of nodes?</p>
+
+</dd>
+<dt class="d_decl">const @property bool <a name="isMapping"></a><span class="ddoc_psymbol">isMapping</span>();
+</dt>
+<dd><p>Is this node a mapping of nodes?</p>
+
+</dd>
+<dt class="d_decl">const @property bool <a name="isUserType"></a><span class="ddoc_psymbol">isUserType</span>();
+</dt>
+<dd><p>Is this node a user defined type?</p>
+
+</dd>
+<dt class="d_decl">bool <a name="opEquals"></a><span class="ddoc_psymbol">opEquals</span>(T)(ref T <b>rhs</b>);
+</dt>
+<dd><p>Equality test.
+</p>
+<p>If T is Node, recursively compare all
+ subnodes and might be quite expensive if testing entire documents.
+<br>
+
+ If T is not Node, convert the node to T and test equality with that.
+
+</p>
+<b>Examples:</b><div class="pbr"><pre class="d_code"> <span class="d_comment">//node is a Node that contains integer 42
+</span> <span class="d_keyword">assert</span>(node == 42);
+ <span class="d_keyword">assert</span>(node == <span class="d_string">"42"</span>);
+ <span class="d_keyword">assert</span>(node != <span class="d_string">"43"</span>);
+</pre>
+
+</div>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>rhs</td>
+<td valign=top>Variable to test equality with.</td></tr>
+</table></div>
+<b>Returns:</b><div class="pbr"><b>true</b> if equal, <b>false</b> otherwise.</div>
+
+</dd>
+<dt class="d_decl">T <a name="get"></a><span class="ddoc_psymbol">get</span>(T)();
+</dt>
+<dd><p>Get the value of the node as specified type.
+</p>
+<p>If the specifed type does not match type in the node,
+ conversion is attempted if possible.
+<br>
+
+ Timestamps are stored as std.datetime.SysTime.
+ Binary values are decoded and stored as ubyte[].
+<br>
+
+ <br><b>Mapping default values:</b>
+<br>
+
+ <div class="pbr">The '=' key can be used to denote the default value of a mapping.
+ This can be used when a node is scalar in early versions of a program,
+ but is replaced by a mapping later. Even if the node is a mapping, the
+ <a name="get"></a><span class="ddoc_psymbol">get</span> method can be used as if it was a scalar if it has a default value.
+ This way, new YAML files where the node is a mapping can still be read
+ by old versions of the program, which expects the node to be a scalar.
+ </div>
+
+</p>
+<b>Examples:</b><div class="pbr">Automatic type conversion:
+<pre class="d_code"> <span class="d_comment">//node is a node that contains integer 42
+</span> <span class="d_keyword">assert</span>(node.<span class="d_psymbol">get</span>!<span class="d_keyword">int</span> == 42);
+ <span class="d_keyword">assert</span>(node.<span class="d_psymbol">get</span>!string == <span class="d_string">"42"</span>);
+ <span class="d_keyword">assert</span>(node.<span class="d_psymbol">get</span>!<span class="d_keyword">double</span> == 42.0);
+</pre>
+
+</div>
+<b>Returns:</b><div class="pbr">Value of the node as specified type.
+
+</div>
+<b>Throws:</b><div class="pbr">NodeException if unable to convert to specified type.</div>
+
+</dd>
+<dt class="d_decl">void <a name="getToVar"></a><span class="ddoc_psymbol">getToVar</span>(T)(out T <b>target</b>);
+</dt>
+<dd><p>Write the value of the node to target.
+</p>
+<p>If the type of target does not match type of the node,
+ conversion is attempted, if possible.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>target</td>
+<td valign=top>Variable to write to.</td></tr>
+</table></div>
+<b>Throws:</b><div class="pbr">NodeException if unable to convert to specified type.</div>
+
+</dd>
+<dt class="d_decl">@property size_t <a name="length"></a><span class="ddoc_psymbol">length</span>();
+</dt>
+<dd><p>If this is a sequence or a mapping, return its <a name="length"></a><span class="ddoc_psymbol">length</span>.
+</p>
+<p>Otherwise, throw NodeException.
+
+</p>
+<b>Returns:</b><div class="pbr">Number of elements in a sequence or key-value pairs in a mapping.
+
+</div>
+<b>Throws:</b><div class="pbr">NodeException if this is not a sequence nor a mapping.</div>
+
+</dd>
+<dt class="d_decl">Node <a name="opIndex"></a><span class="ddoc_psymbol">opIndex</span>(T)(in T <b>index</b>);
+</dt>
+<dd><p>Get the element with specified index.
+</p>
+<p>If the node is a sequence, index must be integral.
+<br>
+
+ If the node is a mapping, return the value corresponding to the first
+ key equal to index, even after conversion. I.e; node["12"] will
+ return value of the first key that equals "12", even if it's an integer.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>index</td>
+<td valign=top>Index to use.</td></tr>
+</table></div>
+<b>Returns:</b><div class="pbr">Value corresponding to the index.
+
+</div>
+<b>Throws:</b><div class="pbr">NodeException if the index could not be found.</div>
+
+</dd>
+<dt class="d_decl">int <a name="opApply"></a><span class="ddoc_psymbol">opApply</span>(T)(int delegate(ref T) <b>dg</b>);
+</dt>
+<dd><p>Iterate over a sequence, getting each element as T.
+</p>
+<p>If T is Node, simply iterate over the nodes in the sequence.
+ Otherwise, convert each node to T during iteration.
+
+</p>
+<b>Throws:</b><div class="pbr">NodeException if the node is not a sequence or an
+          element could not be converted to specified type.</div>
+
+</dd>
+<dt class="d_decl">int <a name="opApply"></a><span class="ddoc_psymbol">opApply</span>(K, V)(int delegate(ref K, ref V) <b>dg</b>);
+</dt>
+<dd><p>Iterate over a mapping, getting each key/value as K/V.
+</p>
+<p>If the K and/or V is Node, simply iterate over the nodes in the mapping.
+ Otherwise, convert each key/value to T during iteration.
+
+</p>
+<b>Throws:</b><div class="pbr">NodeException if the node is not a mapping or an
+          element could not be converted to specified type.</div>
+
+</dd>
+<dt class="d_decl">alias <a name="isInt"></a><span class="ddoc_psymbol">isInt</span>;
+</dt>
+<dd><p>Is the value an integer of some kind?</p>
+
+</dd>
+<dt class="d_decl">alias <a name="isFloat"></a><span class="ddoc_psymbol">isFloat</span>;
+</dt>
+<dd><p>Is the value a floating point number of some kind?</p>
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+</div>
+
+<div id="copyright">
+Copyright &copy; Ferdinand Majerech 2011. Based on <a href="http://www.pyyaml.org">PyYAML</a> by Kirill Simonov. |
+Page generated by Autodoc and <a href="http://www.digitalmars.com/d/2.0/ddoc.html">Ddoc</a>.
+</div>
+
+</body>
+</html>

doc/html/api/dyaml.resolver.html

@@ -0,0 +1,99 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+        "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang='en'>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" >
+<title>dyaml.resolver - D:YAML 0.1 API documentation</title>
+<link rel="stylesheet" type="text/css" href="css/style.css">
+</head>
+
+<body><div id="top">
+<div id="header">
+<img id="logo" alt="D:YAML logo" src="images/logo.png"><a id="main-heading" href="index.html">D:YAML 0.1 API documentation</a>
+</div>
+</div>
+
+<div id="navigation">
+<div class="navblock">
+<div id="toctop">
+<ul><li><a href="../index.html">Documentation home</a></li>
+</ul>
+</div>
+</div>
+<div class="navblock">
+<ul><li><a href="index.html">Main page</a></li>
+<li><a href="dyaml.constructor.html">dyaml.constructor</a></li>
+<li><a href="dyaml.exception.html">dyaml.exception</a></li>
+<li><a href="dyaml.loader.html">dyaml.loader</a></li>
+<li><a href="dyaml.node.html">dyaml.node</a></li>
+<li><a href="dyaml.resolver.html">dyaml.resolver</a></li>
+</ul>
+</div>
+</div>
+
+<div id="content">
+<h1>dyaml.resolver</h1>
+<!-- Generated by Ddoc from dyaml/resolver.d -->
+<p>Implements a class that resolves YAML tags. This can be used to implicitly
+ resolve tags for custom data types, removing the need to explicitly
+ specify tags in YAML. A tutorial can be found
+ <a href="../tutorials/custom_types.html">here</a>.
+</p>
+<p>Code based on <a href="http://www.pyyaml.org">PyYAML</a>.</p>
+
+<dl><dt class="d_decl">class <a name="Resolver"></a><span class="ddoc_psymbol">Resolver</span>;
+</dt>
+<dd><p>Resolves YAML tags (data types).
+</p>
+<p>Can be used to implicitly resolve custom data types of scalar values.</p>
+
+<dl><dt class="d_decl">this(in bool <b>defaultImplicitResolvers</b> = true);
+</dt>
+<dd><p>Construct a Resolver.
+</p>
+<p>If you don't want to implicitly resolve default YAML tags/data types,
+ you can use <b>defaultImplicitResolvers</b> to disable default resolvers.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>bool <b>defaultImplicitResolvers</b></td>
+<td valign=top>Use default YAML implicit resolvers?</td></tr>
+</table></div>
+
+</dd>
+<dt class="d_decl">void <a name="addImplicitResolver"></a><span class="ddoc_psymbol">addImplicitResolver</span>(string <b>tag</b>, Regex!(char) <b>regexp</b>, in string <b>first</b>);
+</dt>
+<dd><p>Add an implicit scalar resolver.
+</p>
+<p>If a scalar matches <b>regexp</b> and starts with one of the characters in <b>first</b>,
+ its tag is set to <b>tag</b>.  If the scalar matches more than one resolver
+ regular expression, resolvers added first override those added later.
+ Default resolvers override any user specified resolvers.
+<br>
+
+ If a scalar is not resolved to anything, it is assigned the default
+ YAML tag for strings.
+
+</p>
+<b>Parameters:</b><div class="pbr"><table class=parms><tr><td valign=top>string <b>tag</b></td>
+<td valign=top>Tag to resolve to.</td></tr>
+<tr><td valign=top>Regex!(char) <b>regexp</b></td>
+<td valign=top>Regular expression the scalar must match to have this tag.</td></tr>
+<tr><td valign=top>string <b>first</b></td>
+<td valign=top>String of possible starting characters of the scalar.</td></tr>
+</table></div>
+
+</dd>
+</dl>
+</dd>
+</dl>
+
+</div>
+
+<div id="copyright">
+Copyright &copy; Ferdinand Majerech 2011. Based on <a href="http://www.pyyaml.org">PyYAML</a> by Kirill Simonov. |
+Page generated by Autodoc and <a href="http://www.digitalmars.com/d/2.0/ddoc.html">Ddoc</a>.
+</div>
+
+</body>
+</html>

doc/html/api/index.html

@@ -0,0 +1,61 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+        "http://www.w3.org/TR/html4/strict.dtd">
+
+<html lang='en'>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" >
+<title>D:YAML 0.1 API documentation - D:YAML 0.1 API documentation</title>
+<link rel="stylesheet" type="text/css" href="css/style.css">
+</head>
+
+<body><div id="top">
+<div id="header">
+<img id="logo" alt="D:YAML logo" src="images/logo.png"><a id="main-heading" href="index.html">D:YAML 0.1 API documentation</a>
+</div>
+</div>
+
+<div id="navigation">
+<div class="navblock">
+<div id="toctop">
+<ul><li><a href="../index.html">Documentation home</a></li>
+</ul>
+</div>
+</div>
+<div class="navblock">
+<ul><li><a href="index.html">Main page</a></li>
+<li><a href="dyaml.constructor.html">dyaml.constructor</a></li>
+<li><a href="dyaml.exception.html">dyaml.exception</a></li>
+<li><a href="dyaml.loader.html">dyaml.loader</a></li>
+<li><a href="dyaml.node.html">dyaml.node</a></li>
+<li><a href="dyaml.resolver.html">dyaml.resolver</a></li>
+</ul>
+</div>
+</div>
+
+<div id="content">
+<h1>D:YAML 0.1 API documentation</h1>
+<!-- Generated by Ddoc from doc/html/api/index.dd -->
+
+
+<p>This is the complete API documentation for D:YAML. It describes all classes, 
+methods and global functions provided by the library. This is not the best place
+to start learning how to use D:YAML. Rather, it should serve as a reference when
+you need detailed information about every bit of D:YAML functionality. You can 
+find more introductory material in D:YAML <a href="../index.html">tutorials</a>.
+</p>
+
+<p>In this API documentation, each D:YAML module is documented separately. However,
+to use D:YAML, you don't need to import these modules. All you need to do is 
+import the <i>yaml</i> module, which will import all needed modules.
+</p>
+
+
+</div>
+
+<div id="copyright">
+Copyright &copy; Ferdinand Majerech 2011. Based on <a href="http://www.pyyaml.org">PyYAML</a> by Kirill Simonov. |
+Page generated by Autodoc and <a href="http://www.digitalmars.com/d/2.0/ddoc.html">Ddoc</a>.
+</div>
+
+</body>
+</html>

doc/html/articles/spec_differences.html

@@ -0,0 +1,150 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Differences between D:YAML and the YAML specification &mdash; D:YAML v0.1 documentation</title>
+    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '../',
+        VERSION:     '0.1',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <link rel="top" title="D:YAML v0.1 documentation" href="../index.html" />
+    <link rel="prev" title="YAML syntax" href="../tutorials/yaml_syntax.html" /> 
+  </head>
+  <body>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../tutorials/yaml_syntax.html" title="YAML syntax"
+             accesskey="P">previous</a></li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body">
+            
+  <div class="section" id="differences-between-d-yaml-and-the-yaml-specification">
+<h1>Differences between D:YAML and the YAML specification<a class="headerlink" href="#differences-between-d-yaml-and-the-yaml-specification" title="Permalink to this headline">¶</a></h1>
+<p>There are some differences between D:YAML and the YAML 1.1 specification. Some
+are caused by difficulty of implementation of some features, such as multiple
+Unicode encodings within single stream, and some by unnecessary restrictions or
+ambiguities in the specification.</p>
+<p>Still, D:YAML tries to be as close to the specification as possible. D:YAML should
+never load documents with different meaning than according to the specification,
+and documents that fail to load should be very rare (for instance, very few
+files use multiple Unicode encodings).</p>
+<div class="section" id="list-of-known-differences">
+<h2>List of known differences:<a class="headerlink" href="#list-of-known-differences" title="Permalink to this headline">¶</a></h2>
+<p>Differences that can cause valid YAML documents not to load:</p>
+<ul>
+<li><p class="first">At the moment, all mappings in the internal representation are ordered,
+and a comparison for equality between equal mappings with differing order
+will return false. This will be fixed once Phobos has a usable map type or
+D associative arrays work with variants.</p>
+</li>
+<li><p class="first">No support for byte order marks and multiple Unicode encodings in a stream.</p>
+</li>
+<li><p class="first">Plain scalars in flow context cannot contain <tt class="docutils literal"><span class="pre">,</span></tt>, <tt class="docutils literal"><span class="pre">:</span></tt> and <tt class="docutils literal"><span class="pre">?</span></tt>.
+This might change with <tt class="docutils literal"><span class="pre">:</span></tt> in the future.
+See <a class="reference external" href="http://pyyaml.org/wiki/YAMLColonInFlowContext">http://pyyaml.org/wiki/YAMLColonInFlowContext</a> for details.</p>
+</li>
+<li><p class="first">The specification does not restrict characters for anchors and
+aliases. This may lead to problems, for instance, the document:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="p-Indicator">[</span> <span class="nv">*alias</span><span class="p-Indicator">,</span> <span class="nv">value</span> <span class="p-Indicator">]</span>
+</pre></div>
+</div>
+<p>can be interpteted in two ways, as:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="p-Indicator">[</span> <span class="s">&quot;value&quot;</span> <span class="p-Indicator">]</span>
+</pre></div>
+</div>
+<p>and:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="p-Indicator">[</span> <span class="nv">*alias</span> <span class="p-Indicator">,</span> <span class="s">&quot;value&quot;</span> <span class="p-Indicator">]</span>
+</pre></div>
+</div>
+<p>Therefore we restrict aliases and anchors to ASCII alphanumeric characters.</p>
+</li>
+<li><p class="first">The specification is confusing about tabs in plain scalars. We don&#8217;t use tabs
+in plain scalars at all.</p>
+</li>
+<li><p class="first">There is no support for recursive data structures in DYAML.</p>
+</li>
+</ul>
+<p>Other differences:</p>
+<ul>
+<li><p class="first">Indentation is ignored in the flow context, which is less restrictive than the
+specification. This allows code such as:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">key</span><span class="p-Indicator">:</span> <span class="p-Indicator">{</span>
+<span class="p-Indicator">}</span>
+</pre></div>
+</div>
+</li>
+<li><p class="first">Indentation rules for quoted scalars are loosed: They don&#8217;t need to adhere
+indentation as <tt class="docutils literal"><span class="pre">&quot;</span></tt> and <tt class="docutils literal"><span class="pre">'</span></tt> clearly mark the beginning and the end of them.</p>
+</li>
+<li><p class="first">We allow <tt class="docutils literal"><span class="pre">_</span></tt> in tag handles.</p>
+</li>
+<li><p class="first">Right now, two mappings with the same contents but different orderings are
+considered unequal, even if they are unordered mappings. This is because all
+mappings are ordered in the D:YAML implementation. This should change in
+future, once D associative arrays work with variant types or a map class or
+struct appears in Phobos.</p>
+</li>
+</ul>
+</div>
+</div>
+
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="../index.html">
+              <img class="logo" src="../_static/logo210.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="../index.html">Table Of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">Differences between D:YAML and the YAML specification</a><ul>
+<li><a class="reference internal" href="#list-of-known-differences">List of known differences:</a></li>
+</ul>
+</li>
+</ul>
+
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../tutorials/yaml_syntax.html" title="YAML syntax"
+             >previous</a></li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>
+    <div class="footer">
+        &copy; Copyright 2011, Ferdinand Majerech. Based on PyYAML http://www.pyyaml.org by Kirill Simonov.
+      Last updated on Aug 16, 2011.
+      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.1.
+    </div>
+  </body>
+</html>

doc/html/index.html

@@ -0,0 +1,110 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Welcome to D:YAML documentation! &mdash; D:YAML v0.1 documentation</title>
+    <link rel="stylesheet" href="_static/default.css" type="text/css" />
+    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '',
+        VERSION:     '0.1',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <link rel="top" title="D:YAML v0.1 documentation" href="#" />
+    <link rel="next" title="Getting started" href="tutorials/getting_started.html" /> 
+  </head>
+  <body>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="tutorials/getting_started.html" title="Getting started"
+             accesskey="N">next</a></li>
+        <li><a href="#">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body">
+            
+  <div class="section" id="welcome-to-d-yaml-documentation">
+<h1>Welcome to D:YAML documentation!<a class="headerlink" href="#welcome-to-d-yaml-documentation" title="Permalink to this headline">¶</a></h1>
+<p><a class="reference external" href="api/index.html">API Documentation</a></p>
+<p>Tutorials:</p>
+<div class="toctree-wrapper compound">
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="tutorials/getting_started.html">Getting started</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/getting_started.html#setting-up">Setting up</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/getting_started.html#your-first-d-yaml-project">Your first D:YAML project</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="tutorials/custom_types.html">Custom YAML data types</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/custom_types.html#constructor">Constructor</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/custom_types.html#resolver">Resolver</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="tutorials/yaml_syntax.html">YAML syntax</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/yaml_syntax.html#documents">Documents</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/yaml_syntax.html#sequences">Sequences</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/yaml_syntax.html#mappings">Mappings</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/yaml_syntax.html#scalars">Scalars</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/yaml_syntax.html#anchors-and-aliases">Anchors and aliases</a></li>
+<li class="toctree-l2"><a class="reference internal" href="tutorials/yaml_syntax.html#tags">Tags</a></li>
+</ul>
+</li>
+</ul>
+</div>
+<p>Articles:</p>
+<div class="toctree-wrapper compound">
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="articles/spec_differences.html">Differences between D:YAML and the YAML specification</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="articles/spec_differences.html#list-of-known-differences">List of known differences:</a></li>
+</ul>
+</li>
+</ul>
+</div>
+</div>
+
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="#">
+              <img class="logo" src="_static/logo210.png" alt="Logo"/>
+            </a></p>
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="tutorials/getting_started.html" title="Getting started"
+             >next</a></li>
+        <li><a href="#">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>
+    <div class="footer">
+        &copy; Copyright 2011, Ferdinand Majerech. Based on PyYAML http://www.pyyaml.org by Kirill Simonov.
+      Last updated on Aug 16, 2011.
+      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.1.
+    </div>
+  </body>
+</html>

doc/html/search.html

@@ -0,0 +1,94 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Search &mdash; D:YAML v0.1 documentation</title>
+    <link rel="stylesheet" href="_static/default.css" type="text/css" />
+    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '',
+        VERSION:     '0.1',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="_static/jquery.js"></script>
+    <script type="text/javascript" src="_static/underscore.js"></script>
+    <script type="text/javascript" src="_static/doctools.js"></script>
+    <script type="text/javascript" src="_static/searchtools.js"></script>
+    <link rel="top" title="D:YAML v0.1 documentation" href="index.html" />
+  <script type="text/javascript">
+    jQuery(function() { Search.loadIndex("searchindex.js"); });
+  </script>
+   
+
+  </head>
+  <body>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li><a href="index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body">
+            
+  <h1 id="search-documentation">Search</h1>
+  <div id="fallback" class="admonition warning">
+  <script type="text/javascript">$('#fallback').hide();</script>
+  <p>
+    Please activate JavaScript to enable the search
+    functionality.
+  </p>
+  </div>
+  <p>
+    From here you can search these documents. Enter your search
+    words into the box below and click "search". Note that the search
+    function will automatically search for all of the words. Pages
+    containing fewer words won't appear in the result list.
+  </p>
+  <form action="" method="get">
+    <input type="text" name="q" value="" />
+    <input type="submit" value="search" />
+    <span id="search-progress" style="padding-left: 10px"></span>
+  </form>
+  
+  <div id="search-results">
+  
+  </div>
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/logo210.png" alt="Logo"/>
+            </a></p>
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li><a href="index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>
+    <div class="footer">
+        &copy; Copyright 2011, Ferdinand Majerech. Based on PyYAML http://www.pyyaml.org by Kirill Simonov.
+      Last updated on Aug 16, 2011.
+      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.1.
+    </div>
+  </body>
+</html>

doc/html/tutorials/custom_types.html

@@ -0,0 +1,289 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Custom YAML data types &mdash; D:YAML v0.1 documentation</title>
+    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '../',
+        VERSION:     '0.1',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <link rel="top" title="D:YAML v0.1 documentation" href="../index.html" />
+    <link rel="next" title="YAML syntax" href="yaml_syntax.html" />
+    <link rel="prev" title="Getting started" href="getting_started.html" /> 
+  </head>
+  <body>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="yaml_syntax.html" title="YAML syntax"
+             accesskey="N">next</a></li>
+        <li class="right" >
+          <a href="getting_started.html" title="Getting started"
+             accesskey="P">previous</a> |</li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body">
+            
+  <div class="section" id="custom-yaml-data-types">
+<h1>Custom YAML data types<a class="headerlink" href="#custom-yaml-data-types" title="Permalink to this headline">¶</a></h1>
+<p>Often you will want to serialize complex data types such as classes. You can use
+functions to process nodes; e.g. a mapping containing class data members indexed
+by name. Alternatively, YAML supports custom data types using identifiers called
+<em>tags</em>. That is the topic of this tutorial.</p>
+<p>Each YAML node has a tag specifying its type. For instance: strings use the tag
+<tt class="docutils literal"><span class="pre">tag:yaml.org,2002:str</span></tt>. Tags of most default types are <em>implicitly resolved</em>
+during parsing, so you don&#8217;t need to specify tag for each float, integer, etc.
+It is also possible to implicitly resolve custom tags, as we will show later.</p>
+<div class="section" id="constructor">
+<h2>Constructor<a class="headerlink" href="#constructor" title="Permalink to this headline">¶</a></h2>
+<p>D:YAML uses the <em>Constructor</em> class to process each node to hold data type
+corresponding to its tag. <em>Constructor</em> stores a function for each supported
+tag to process it. These functions can be supplied by the user using the
+<em>addConstructor()</em> method. <em>Constructor</em> is then passed to <em>Loader</em>, which will
+parse YAML input.</p>
+<p>We will implement support for an RGB color type. It is implemented as the
+following struct:</p>
+<div class="highlight-d"><div class="highlight"><pre><span class="k">struct</span> <span class="n">Color</span>
+<span class="p">{</span>
+    <span class="kt">ubyte</span> <span class="n">red</span><span class="p">;</span>
+    <span class="kt">ubyte</span> <span class="n">green</span><span class="p">;</span>
+    <span class="kt">ubyte</span> <span class="n">blue</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>First, we need a function to construct our data type. It must take two <em>Mark</em>
+structs, which store position of the node in the file, and either a <em>string</em>, an
+array of <em>Node</em> or of <em>Node.Pair</em>, depending on whether we&#8217;re constructing our
+value from a scalar, sequence, or mapping, respectively. In this tutorial, we
+have functions to construct a color from a scalar, using HTML-like format,
+RRGGBB, or from a mapping, where we use the following format:
+{r:RRR, g:GGG, b:BBB} . Code of these functions:</p>
+<div class="highlight-d"><div class="highlight"><pre><span class="n">Color</span> <span class="n">constructColorScalar</span><span class="p">(</span><span class="n">Mark</span> <span class="n">start</span><span class="p">,</span> <span class="n">Mark</span> <span class="n">end</span><span class="p">,</span> <span class="nb">string</span> <span class="n">value</span><span class="p">)</span>
+<span class="p">{</span>
+    <span class="k">if</span><span class="p">(</span><span class="n">value</span><span class="p">.</span><span class="n">length</span> <span class="p">!=</span> <span class="mi">6</span><span class="p">)</span>
+    <span class="p">{</span>
+        <span class="k">throw</span> <span class="k">new</span> <span class="n">ConstructorException</span><span class="p">(</span><span class="s">&quot;Invalid color: &quot;</span> <span class="p">~</span> <span class="n">value</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">);</span>
+    <span class="p">}</span>
+    <span class="c1">//We don&#39;t need to check for uppercase chars this way.</span>
+    <span class="n">value</span> <span class="p">=</span> <span class="n">value</span><span class="p">.</span><span class="n">toLower</span><span class="p">();</span>
+
+    <span class="c1">//Get value of a hex digit.</span>
+    <span class="kt">uint</span> <span class="n">hex</span><span class="p">(</span><span class="kt">char</span> <span class="n">c</span><span class="p">)</span>
+    <span class="p">{</span>
+        <span class="k">if</span><span class="p">(!</span><span class="n">std</span><span class="p">.</span><span class="n">ascii</span><span class="p">.</span><span class="n">isHexDigit</span><span class="p">(</span><span class="n">c</span><span class="p">))</span>
+        <span class="p">{</span>
+            <span class="k">throw</span> <span class="k">new</span> <span class="n">ConstructorException</span><span class="p">(</span><span class="s">&quot;Invalid color: &quot;</span> <span class="p">~</span> <span class="n">value</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">);</span>
+        <span class="p">}</span>
+
+        <span class="k">if</span><span class="p">(</span><span class="n">std</span><span class="p">.</span><span class="n">ascii</span><span class="p">.</span><span class="n">isDigit</span><span class="p">(</span><span class="n">c</span><span class="p">))</span>
+        <span class="p">{</span>
+            <span class="k">return</span> <span class="n">c</span> <span class="p">-</span> <span class="sc">&#39;0&#39;</span><span class="p">;</span>
+        <span class="p">}</span>
+        <span class="k">return</span> <span class="n">c</span> <span class="p">-</span> <span class="sc">&#39;a&#39;</span> <span class="p">+</span> <span class="mi">10</span><span class="p">;</span>
+    <span class="p">}</span>
+
+    <span class="n">Color</span> <span class="n">result</span><span class="p">;</span>
+    <span class="n">result</span><span class="p">.</span><span class="n">red</span>   <span class="p">=</span> <span class="k">cast</span><span class="p">(</span><span class="kt">ubyte</span><span class="p">)(</span><span class="mi">16</span> <span class="p">*</span> <span class="n">hex</span><span class="p">(</span><span class="n">value</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="p">+</span> <span class="n">hex</span><span class="p">(</span><span class="n">value</span><span class="p">[</span><span class="mi">1</span><span class="p">]));</span>
+    <span class="n">result</span><span class="p">.</span><span class="n">green</span> <span class="p">=</span> <span class="k">cast</span><span class="p">(</span><span class="kt">ubyte</span><span class="p">)(</span><span class="mi">16</span> <span class="p">*</span> <span class="n">hex</span><span class="p">(</span><span class="n">value</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span> <span class="p">+</span> <span class="n">hex</span><span class="p">(</span><span class="n">value</span><span class="p">[</span><span class="mi">3</span><span class="p">]));</span>
+    <span class="n">result</span><span class="p">.</span><span class="n">blue</span>  <span class="p">=</span> <span class="k">cast</span><span class="p">(</span><span class="kt">ubyte</span><span class="p">)(</span><span class="mi">16</span> <span class="p">*</span> <span class="n">hex</span><span class="p">(</span><span class="n">value</span><span class="p">[</span><span class="mi">4</span><span class="p">])</span> <span class="p">+</span> <span class="n">hex</span><span class="p">(</span><span class="n">value</span><span class="p">[</span><span class="mi">5</span><span class="p">]));</span>
+
+    <span class="k">return</span> <span class="n">result</span><span class="p">;</span>
+<span class="p">}</span>
+
+<span class="n">Color</span> <span class="n">constructColorMapping</span><span class="p">(</span><span class="n">Mark</span> <span class="n">start</span><span class="p">,</span> <span class="n">Mark</span> <span class="n">end</span><span class="p">,</span> <span class="n">Node</span><span class="p">.</span><span class="n">Pair</span><span class="p">[]</span> <span class="n">pairs</span><span class="p">)</span>
+<span class="p">{</span>
+    <span class="kt">int</span> <span class="n">r</span><span class="p">,</span> <span class="n">g</span><span class="p">,</span> <span class="n">b</span><span class="p">;</span>
+    <span class="n">r</span> <span class="p">=</span> <span class="n">g</span> <span class="p">=</span> <span class="n">b</span> <span class="p">=</span> <span class="p">-</span><span class="mi">1</span><span class="p">;</span>
+    <span class="kt">bool</span> <span class="n">error</span> <span class="p">=</span> <span class="n">pairs</span><span class="p">.</span><span class="n">length</span> <span class="p">!=</span> <span class="mi">3</span><span class="p">;</span>
+
+    <span class="k">foreach</span><span class="p">(</span><span class="k">ref</span> <span class="n">pair</span><span class="p">;</span> <span class="n">pairs</span><span class="p">)</span>
+    <span class="p">{</span>
+        <span class="c1">//Key might not be a string, and value might not be an int,</span>
+        <span class="c1">//so we need to check for that</span>
+        <span class="k">try</span>
+        <span class="p">{</span>
+            <span class="k">switch</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="n">key</span><span class="p">.</span><span class="n">get</span><span class="p">!</span><span class="nb">string</span><span class="p">)</span>
+            <span class="p">{</span>
+                <span class="k">case</span> <span class="s">&quot;r&quot;</span><span class="p">:</span> <span class="n">r</span> <span class="p">=</span> <span class="n">pair</span><span class="p">.</span><span class="n">value</span><span class="p">.</span><span class="n">get</span><span class="p">!</span><span class="kt">int</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
+                <span class="k">case</span> <span class="s">&quot;g&quot;</span><span class="p">:</span> <span class="n">g</span> <span class="p">=</span> <span class="n">pair</span><span class="p">.</span><span class="n">value</span><span class="p">.</span><span class="n">get</span><span class="p">!</span><span class="kt">int</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
+                <span class="k">case</span> <span class="s">&quot;b&quot;</span><span class="p">:</span> <span class="n">b</span> <span class="p">=</span> <span class="n">pair</span><span class="p">.</span><span class="n">value</span><span class="p">.</span><span class="n">get</span><span class="p">!</span><span class="kt">int</span><span class="p">;</span> <span class="k">break</span><span class="p">;</span>
+                <span class="k">default</span><span class="p">:</span>  <span class="n">error</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
+            <span class="p">}</span>
+        <span class="p">}</span>
+        <span class="k">catch</span><span class="p">(</span><span class="n">NodeException</span> <span class="n">e</span><span class="p">)</span>
+        <span class="p">{</span>
+            <span class="n">error</span> <span class="p">=</span> <span class="kc">true</span><span class="p">;</span>
+        <span class="p">}</span>
+    <span class="p">}</span>
+
+    <span class="k">if</span><span class="p">(</span><span class="n">error</span> <span class="p">||</span> <span class="n">r</span> <span class="p">&lt;</span> <span class="mi">0</span> <span class="p">||</span> <span class="n">r</span> <span class="p">&gt;</span> <span class="mi">255</span> <span class="p">||</span> <span class="n">g</span> <span class="p">&lt;</span> <span class="mi">0</span> <span class="p">||</span> <span class="n">g</span> <span class="p">&gt;</span> <span class="mi">255</span> <span class="p">||</span> <span class="n">b</span> <span class="p">&lt;</span> <span class="mi">0</span> <span class="p">||</span> <span class="n">b</span> <span class="p">&gt;</span> <span class="mi">255</span><span class="p">)</span>
+    <span class="p">{</span>
+        <span class="k">throw</span> <span class="k">new</span> <span class="n">ConstructorException</span><span class="p">(</span><span class="s">&quot;Invalid color&quot;</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">);</span>
+    <span class="p">}</span>
+
+    <span class="k">return</span> <span class="n">Color</span><span class="p">(</span><span class="k">cast</span><span class="p">(</span><span class="kt">ubyte</span><span class="p">)</span><span class="n">r</span><span class="p">,</span> <span class="k">cast</span><span class="p">(</span><span class="kt">ubyte</span><span class="p">)</span><span class="n">g</span><span class="p">,</span> <span class="k">cast</span><span class="p">(</span><span class="kt">ubyte</span><span class="p">)</span><span class="n">b</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>Next, we need some YAML code using our new tag. Create a file called input.yaml
+with the following contents:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">scalar-red</span><span class="p-Indicator">:</span> <span class="kt">!color</span> <span class="l-Scalar-Plain">FF0000</span>
+<span class="l-Scalar-Plain">scalar-orange</span><span class="p-Indicator">:</span> <span class="kt">!color</span> <span class="l-Scalar-Plain">FFFF00</span>
+<span class="l-Scalar-Plain">mapping-red</span><span class="p-Indicator">:</span> <span class="kt">!color-mapping</span> <span class="p-Indicator">{</span><span class="nv">r</span><span class="p-Indicator">:</span> <span class="nv">255</span><span class="p-Indicator">,</span> <span class="nv">g</span><span class="p-Indicator">:</span> <span class="nv">0</span><span class="p-Indicator">,</span> <span class="nv">b</span><span class="p-Indicator">:</span> <span class="nv">0</span><span class="p-Indicator">}</span>
+<span class="l-Scalar-Plain">mapping-orange</span><span class="p-Indicator">:</span>
+    <span class="kt">!color-mapping</span>
+    <span class="l-Scalar-Plain">r</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">255</span>
+    <span class="l-Scalar-Plain">g</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">255</span>
+    <span class="l-Scalar-Plain">b</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">0</span>
+</pre></div>
+</div>
+<p>You can see that we&#8217;re using tag <tt class="docutils literal"><span class="pre">!color</span></tt> for scalar colors, and
+<tt class="docutils literal"><span class="pre">!color-mapping</span></tt> for colors expressed as mappings.</p>
+<p>Finally, the code to put it all together:</p>
+<div class="highlight-d"><div class="highlight"><pre><span class="kt">void</span> <span class="n">main</span><span class="p">()</span>
+<span class="p">{</span>
+    <span class="k">auto</span> <span class="n">red</span>    <span class="p">=</span> <span class="n">Color</span><span class="p">(</span><span class="mi">255</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
+    <span class="k">auto</span> <span class="n">orange</span> <span class="p">=</span> <span class="n">Color</span><span class="p">(</span><span class="mi">255</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
+
+    <span class="k">try</span>
+    <span class="p">{</span>
+        <span class="k">auto</span> <span class="n">constructor</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Constructor</span><span class="p">;</span>
+        <span class="c1">//both functions handle the same tag, but one handles scalar, one mapping.</span>
+        <span class="n">constructor</span><span class="p">.</span><span class="n">addConstructor</span><span class="p">(</span><span class="s">&quot;!color&quot;</span><span class="p">,</span> <span class="p">&amp;</span><span class="n">constructColorScalar</span><span class="p">);</span>
+        <span class="n">constructor</span><span class="p">.</span><span class="n">addConstructor</span><span class="p">(</span><span class="s">&quot;!color-mapping&quot;</span><span class="p">,</span> <span class="p">&amp;</span><span class="n">constructColorMapping</span><span class="p">);</span>
+
+        <span class="k">auto</span> <span class="n">loader</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Loader</span><span class="p">(</span><span class="s">&quot;input.yaml&quot;</span><span class="p">,</span> <span class="n">constructor</span><span class="p">,</span> <span class="k">new</span> <span class="n">Resolver</span><span class="p">);</span>
+
+        <span class="k">auto</span> <span class="n">root</span> <span class="p">=</span> <span class="n">loader</span><span class="p">.</span><span class="n">loadSingleDocument</span><span class="p">();</span>
+
+        <span class="k">if</span><span class="p">(</span><span class="n">root</span><span class="p">[</span><span class="s">&quot;scalar-red&quot;</span><span class="p">].</span><span class="n">get</span><span class="p">!</span><span class="n">Color</span> <span class="p">==</span> <span class="n">red</span> <span class="p">&amp;&amp;</span>
+           <span class="n">root</span><span class="p">[</span><span class="s">&quot;mapping-red&quot;</span><span class="p">].</span><span class="n">get</span><span class="p">!</span><span class="n">Color</span> <span class="p">==</span> <span class="n">red</span> <span class="p">&amp;&amp;</span>
+           <span class="n">root</span><span class="p">[</span><span class="s">&quot;scalar-orange&quot;</span><span class="p">].</span><span class="n">get</span><span class="p">!</span><span class="n">Color</span> <span class="p">==</span> <span class="n">orange</span> <span class="p">&amp;&amp;</span>
+           <span class="n">root</span><span class="p">[</span><span class="s">&quot;mapping-orange&quot;</span><span class="p">].</span><span class="n">get</span><span class="p">!</span><span class="n">Color</span> <span class="p">==</span> <span class="n">orange</span><span class="p">)</span>
+        <span class="p">{</span>
+            <span class="n">writeln</span><span class="p">(</span><span class="s">&quot;SUCCESS&quot;</span><span class="p">);</span>
+            <span class="k">return</span><span class="p">;</span>
+        <span class="p">}</span>
+    <span class="p">}</span>
+    <span class="k">catch</span><span class="p">(</span><span class="n">YAMLException</span> <span class="n">e</span><span class="p">)</span>
+    <span class="p">{</span>
+        <span class="n">writeln</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="n">msg</span><span class="p">);</span>
+    <span class="p">}</span>
+
+    <span class="n">writeln</span><span class="p">(</span><span class="s">&quot;FAILURE&quot;</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<p>First, we create a <em>Constructor</em> and pass functions to handle the <tt class="docutils literal"><span class="pre">!color</span></tt>
+and <tt class="docutils literal"><span class="pre">!color-mapping</span></tt> tag. We construct a <em>Loader</em> using the <em>Constructor</em>.
+We also need a <em>Resolver</em>, but for now we just default-construct it. We then
+load the YAML document, and finally, read the colors using <em>get()</em> method to
+test if they were loaded as expected.</p>
+<p>You can find the source code for what we&#8217;ve done so far in the
+<tt class="docutils literal"><span class="pre">examples/constructor</span></tt> directory in the D:YAML package.</p>
+</div>
+<div class="section" id="resolver">
+<h2>Resolver<a class="headerlink" href="#resolver" title="Permalink to this headline">¶</a></h2>
+<p>Specifying tag for every color value can be tedious. D:YAML can implicitly
+resolve tag of a scalar using a regular expression. This is how default types,
+e.g. int, are resolved. We will use the <em>Resolver</em> class to add implicit tag
+resolution for the Color data type (in its scalar form).</p>
+<p>We use the <em>addImplicitResolver</em> method of <em>Resolver</em>, passing the tag, regular
+expression the value must match to resolve to this tag, and a string of possible
+starting characters of the value. Then we pass the <em>Resolver</em> to the constructor
+of <em>Loader</em>.</p>
+<p>Note that resolvers added first override ones added later. If no resolver
+matches a scalar, YAML string tag is used. Therefore our custom values must not
+be resolvable as any non-string YAML data type.</p>
+<p>Add this to your code to add implicit resolution of <tt class="docutils literal"><span class="pre">!color</span></tt>.</p>
+<div class="highlight-d"><div class="highlight"><pre><span class="c1">//code from the previous example...</span>
+
+<span class="k">auto</span> <span class="n">resolver</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Resolver</span><span class="p">;</span>
+<span class="n">resolver</span><span class="p">.</span><span class="n">addImplicitResolver</span><span class="p">(</span><span class="s">&quot;!color&quot;</span><span class="p">,</span> <span class="n">std</span><span class="p">.</span><span class="n">regex</span><span class="p">.</span><span class="n">regex</span><span class="p">(</span><span class="s">&quot;[0-9a-fA-F]{6}&quot;</span><span class="p">,</span>
+                             <span class="s">&quot;0123456789abcdefABCDEF&quot;</span><span class="p">));</span>
+
+<span class="k">auto</span> <span class="n">loader</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Loader</span><span class="p">(</span><span class="s">&quot;input.yaml&quot;</span><span class="p">,</span> <span class="n">constructor</span><span class="p">,</span> <span class="n">resolver</span><span class="p">);</span>
+
+<span class="c1">//code from the previous example...</span>
+</pre></div>
+</div>
+<p>Now, change contents of input.dyaml to this:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">scalar-red</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">FF0000</span>
+<span class="l-Scalar-Plain">scalar-orange</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">FFFF00</span>
+<span class="l-Scalar-Plain">mapping-red</span><span class="p-Indicator">:</span> <span class="kt">!color-mapping</span> <span class="p-Indicator">{</span><span class="nv">r</span><span class="p-Indicator">:</span> <span class="nv">255</span><span class="p-Indicator">,</span> <span class="nv">g</span><span class="p-Indicator">:</span> <span class="nv">0</span><span class="p-Indicator">,</span> <span class="nv">b</span><span class="p-Indicator">:</span> <span class="nv">0</span><span class="p-Indicator">}</span>
+<span class="l-Scalar-Plain">mapping-orange</span><span class="p-Indicator">:</span>
+    <span class="kt">!color-mapping</span>
+    <span class="l-Scalar-Plain">r</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">255</span>
+    <span class="l-Scalar-Plain">g</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">255</span>
+    <span class="l-Scalar-Plain">b</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">0</span>
+</pre></div>
+</div>
+<p>We no longer need to specify the tag for scalar color values. Compile and test
+the example. If everything went as expected, it should report success.</p>
+<p>You can find the complete code in the <tt class="docutils literal"><span class="pre">examples/resolver</span></tt> directory in the
+D:YAML package.</p>
+</div>
+</div>
+
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="../index.html">
+              <img class="logo" src="../_static/logo210.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="../index.html">Table Of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">Custom YAML data types</a><ul>
+<li><a class="reference internal" href="#constructor">Constructor</a></li>
+<li><a class="reference internal" href="#resolver">Resolver</a></li>
+</ul>
+</li>
+</ul>
+
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="yaml_syntax.html" title="YAML syntax"
+             >next</a></li>
+        <li class="right" >
+          <a href="getting_started.html" title="Getting started"
+             >previous</a> |</li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>
+    <div class="footer">
+        &copy; Copyright 2011, Ferdinand Majerech. Based on PyYAML http://www.pyyaml.org by Kirill Simonov.
+      Last updated on Aug 16, 2011.
+      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.1.
+    </div>
+  </body>
+</html>

doc/html/tutorials/getting_started.html

@@ -0,0 +1,231 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>Getting started &mdash; D:YAML v0.1 documentation</title>
+    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '../',
+        VERSION:     '0.1',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <link rel="top" title="D:YAML v0.1 documentation" href="../index.html" />
+    <link rel="next" title="Custom YAML data types" href="custom_types.html" />
+    <link rel="prev" title="Welcome to D:YAML documentation!" href="../index.html" /> 
+  </head>
+  <body>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="custom_types.html" title="Custom YAML data types"
+             accesskey="N">next</a></li>
+        <li class="right" >
+          <a href="../index.html" title="Welcome to D:YAML documentation!"
+             accesskey="P">previous</a> |</li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body">
+            
+  <div class="section" id="getting-started">
+<h1>Getting started<a class="headerlink" href="#getting-started" title="Permalink to this headline">¶</a></h1>
+<p>Welcome to D:YAML! D:YAML is a <a class="reference external" href="http://en.wikipedia.org/wiki/YAML">YAML</a> parser
+library for the <a class="reference external" href="http://d-p-l.org">D programming language</a>. This tutorial will
+explain how to set D:YAML up and use it in your projects.</p>
+<p>This is meant to be the <strong>simplest possible</strong> introduction to D:YAML. Some of the
+information present might already be known to you. Only basic usage is covered.
+More advanced usage is described in other tutorials.</p>
+<div class="section" id="setting-up">
+<h2>Setting up<a class="headerlink" href="#setting-up" title="Permalink to this headline">¶</a></h2>
+<div class="section" id="install-the-dmd-compiler">
+<h3>Install the DMD compiler<a class="headerlink" href="#install-the-dmd-compiler" title="Permalink to this headline">¶</a></h3>
+<p>Digital Mars D compiler, or DMD, is the most commonly used D compiler. You can
+find its newest version <a class="reference external" href="http://www.digitalmars.com/d/download.html">here</a>.
+Download the version of DMD for your operating system and install it.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">Other D compilers exist, such as
+<a class="reference external" href="http://bitbucket.org/goshawk/gdc/wiki/Home">GDC</a> and
+<a class="reference external" href="http://www.dsource.org/projects/ldc/">LDC</a>.
+Setting up with either one of them should be similar to DMD,
+however, at the moment they are not as up to date as DMD.</p>
+</div>
+</div>
+<div class="section" id="download-and-compile-d-yaml">
+<h3>Download and compile D:YAML<a class="headerlink" href="#download-and-compile-d-yaml" title="Permalink to this headline">¶</a></h3>
+<p>The newest version of D:YAML can be found <a class="reference external" href="TODO">here</a>. Download a source
+archive, extract it, and move to the extracted directory.</p>
+<p>D:YAML uses a modified version of the <a class="reference external" href="http://dsource.org/projects/cdc/">CDC</a>
+script for compilation. To compile D:YAML, you first need to build CDC.
+Do this by typing the following command into the console:</p>
+<div class="highlight-python"><pre>dmd cdc.d</pre>
+</div>
+<p>Now you can use CDC to compile D:YAML.
+To do this on Unix/Linux, use the following command:</p>
+<div class="highlight-python"><pre>./cdc</pre>
+</div>
+<p>On Windows:</p>
+<div class="highlight-python"><div class="highlight"><pre><span class="n">cdc</span><span class="o">.</span><span class="n">exe</span>
+</pre></div>
+</div>
+<p>This will compile the library to a file called <tt class="docutils literal"><span class="pre">libdyaml.a</span></tt> on Unix/Linux or
+<tt class="docutils literal"><span class="pre">libdyaml.lib</span></tt> on Windows.</p>
+</div>
+</div>
+<div class="section" id="your-first-d-yaml-project">
+<h2>Your first D:YAML project<a class="headerlink" href="#your-first-d-yaml-project" title="Permalink to this headline">¶</a></h2>
+<p>Create a directory for your project and in that directory, create a file called
+<tt class="docutils literal"><span class="pre">input.yaml</span></tt> with the following contents:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">Hello World</span> <span class="p-Indicator">:</span>
+    <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Hello</span>
+    <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">World</span>
+<span class="l-Scalar-Plain">Answer</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">42</span>
+</pre></div>
+</div>
+<p>This will serve as input for our example.</p>
+<p>Now we need to parse it. Create a file called &#8220;main.d&#8221;. Paste following code
+into the file:</p>
+<div class="highlight-d"><div class="highlight"><pre><span class="k">import</span> <span class="n">std</span><span class="p">.</span><span class="n">stdio</span><span class="p">;</span>
+<span class="k">import</span> <span class="n">yaml</span><span class="p">;</span>
+
+<span class="kt">void</span> <span class="n">main</span><span class="p">()</span>
+<span class="p">{</span>
+    <span class="n">yaml</span><span class="p">.</span><span class="n">Node</span> <span class="n">root</span> <span class="p">=</span> <span class="n">yaml</span><span class="p">.</span><span class="n">load</span><span class="p">(</span><span class="s">&quot;input.yaml&quot;</span><span class="p">);</span>
+    <span class="k">foreach</span><span class="p">(</span><span class="nb">string</span> <span class="n">word</span><span class="p">;</span> <span class="n">root</span><span class="p">[</span><span class="s">&quot;Hello World&quot;</span><span class="p">])</span>
+    <span class="p">{</span>
+        <span class="n">writeln</span><span class="p">(</span><span class="n">word</span><span class="p">);</span>
+    <span class="p">}</span>
+    <span class="n">writeln</span><span class="p">(</span><span class="s">&quot;The answer is &quot;</span><span class="p">,</span> <span class="n">root</span><span class="p">[</span><span class="s">&quot;Answer&quot;</span><span class="p">].</span><span class="n">get</span><span class="p">!</span><span class="kt">int</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+<div class="section" id="explanation-of-the-code">
+<h3>Explanation of the code<a class="headerlink" href="#explanation-of-the-code" title="Permalink to this headline">¶</a></h3>
+<p>First, we import the <em>yaml</em> module. This is the only module you need to import
+to use D:YAML - it automatically imports all needed modules.</p>
+<p>Next we load the file using the <em>yaml.load()</em> function - this loads the file as
+<strong>one</strong> YAML document and throws <em>YAMLException</em>, D:YAML exception type, if the
+file could not be parsed or does not contain exactly one document. Note that we
+don&#8217;t do any error checking here in order to keep the example as simple as
+possible.</p>
+<p><em>yaml.Node</em> represents a node in a YAML document. It can be a sequence (array),
+mapping (associative array) or a scalar (value). Here the root node is a
+mapping, and we use the index operator to get subnodes with keys &#8220;Hello World&#8221;
+and &#8220;Answer&#8221;. We iterate over the first, as it is a sequence, and use the
+<em>yaml.Node.get()</em> method on the second to get its value as an integer.</p>
+<p>You can iterate over a mapping or sequence as if it was an associative or normal
+array. If you try to iterate over a scalar, it will throw a <em>YAMLException</em>.</p>
+<p>You can iterate over subnodes using yaml.Node as the iterated type, or specify
+the type subnodes are expected to have. D:YAML will automatically convert
+iterated subnodes to that type if possible. Here we specify the <em>string</em> type,
+so we iterate over the &#8220;Hello World&#8221; sequence as an array of strings. If it is
+not possible to convert to iterated type, a <em>YAMLException</em> is thrown. For
+instance, if we specified <em>int</em> here, we would get an error, as &#8220;Hello&#8221;
+cannot be converted to an integer.</p>
+<p>The <em>yaml.Node.get()</em> method is used to get value of a scalar node as specified
+type. D:YAML will try to return the scalar as specified type, converting if
+needed, throwing <em>YAMLException</em> if not possible.</p>
+</div>
+<div class="section" id="compiling">
+<h3>Compiling<a class="headerlink" href="#compiling" title="Permalink to this headline">¶</a></h3>
+<p>To compile your project, you must give DMD the directories containing import
+modules and the library. You also need to tell it to link with D:YAML. The import
+directory should be the D:YAML package directory. You can specify it using the
+<tt class="docutils literal"><span class="pre">-I</span></tt> option of DMD.  The library directory should point to where you put the
+compiled D:YAML library. On Unix/Linux you can specify it using the <tt class="docutils literal"><span class="pre">-L-L</span></tt>
+option, and link with D:YAML using the <tt class="docutils literal"><span class="pre">-L-l</span></tt> option. On Windows, the import
+directory is used as the library directory. To link with the library on Windows,
+just add the path to it relative to the current directory.</p>
+<p>For example, if you extracted D:YAML to <tt class="docutils literal"><span class="pre">/home/xxx/dyaml</span></tt> and compiled it in
+that directory, your project is in <tt class="docutils literal"><span class="pre">/home/xxx/dyaml-project</span></tt>, and you are
+currently in that directory, you can compile the project with the following
+command on Unix/Linux:</p>
+<div class="highlight-python"><pre>dmd -I../dyaml -L-L../dyaml -L-ldyaml main.d</pre>
+</div>
+<p>And the following on Windows:</p>
+<div class="highlight-python"><pre>dmd -I../dyaml ../dyaml/libdyaml.lib main.d</pre>
+</div>
+<p>This will produce an executable called <tt class="docutils literal"><span class="pre">main</span></tt> or <tt class="docutils literal"><span class="pre">main.exe</span></tt> in your
+directory. When you run it, it should produce the following output:</p>
+<div class="highlight-python"><pre>Hello
+World
+The answer is 42</pre>
+</div>
+</div>
+<div class="section" id="conclusion">
+<h3>Conclusion<a class="headerlink" href="#conclusion" title="Permalink to this headline">¶</a></h3>
+<p>You should now have a basic idea about how to use D:YAML. To learn more, look at
+the <a class="reference external" href="../api/index.html">API documentation</a> and other tutorials. You can find code for this
+example in the <tt class="docutils literal"><span class="pre">example/getting_started</span></tt> directory in the package.</p>
+</div>
+</div>
+</div>
+
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="../index.html">
+              <img class="logo" src="../_static/logo210.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="../index.html">Table Of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">Getting started</a><ul>
+<li><a class="reference internal" href="#setting-up">Setting up</a><ul>
+<li><a class="reference internal" href="#install-the-dmd-compiler">Install the DMD compiler</a></li>
+<li><a class="reference internal" href="#download-and-compile-d-yaml">Download and compile D:YAML</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#your-first-d-yaml-project">Your first D:YAML project</a><ul>
+<li><a class="reference internal" href="#explanation-of-the-code">Explanation of the code</a></li>
+<li><a class="reference internal" href="#compiling">Compiling</a></li>
+<li><a class="reference internal" href="#conclusion">Conclusion</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="custom_types.html" title="Custom YAML data types"
+             >next</a></li>
+        <li class="right" >
+          <a href="../index.html" title="Welcome to D:YAML documentation!"
+             >previous</a> |</li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>
+    <div class="footer">
+        &copy; Copyright 2011, Ferdinand Majerech. Based on PyYAML http://www.pyyaml.org by Kirill Simonov.
+      Last updated on Aug 16, 2011.
+      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.1.
+    </div>
+  </body>
+</html>

doc/html/tutorials/yaml_syntax.html

@@ -0,0 +1,338 @@
+
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    
+    <title>YAML syntax &mdash; D:YAML v0.1 documentation</title>
+    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '../',
+        VERSION:     '0.1',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '.html',
+        HAS_SOURCE:  true
+      };
+    </script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <link rel="top" title="D:YAML v0.1 documentation" href="../index.html" />
+    <link rel="next" title="Differences between D:YAML and the YAML specification" href="../articles/spec_differences.html" />
+    <link rel="prev" title="Custom YAML data types" href="custom_types.html" /> 
+  </head>
+  <body>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../articles/spec_differences.html" title="Differences between D:YAML and the YAML specification"
+             accesskey="N">next</a></li>
+        <li class="right" >
+          <a href="custom_types.html" title="Custom YAML data types"
+             accesskey="P">previous</a> |</li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body">
+            
+  <div class="section" id="yaml-syntax">
+<h1>YAML syntax<a class="headerlink" href="#yaml-syntax" title="Permalink to this headline">¶</a></h1>
+<p>This is an introduction to the most common YAML constructs. For more detailed
+information, see <a class="reference external" href="http://pyyaml.org/wiki/PyYAMLDocumentation">PyYAML documentation</a>,
+which this article is based on,
+<a class="reference external" href="http://yaml.org/spec/1.1/#id857168">Chapter 2 of the YAML specification</a>
+or the <a class="reference external" href="http://en.wikipedia.org/wiki/YAML">Wikipedia page</a>.</p>
+<p>YAML is a data serialization format designed to be as human readable as
+possible. YAML is a recursive acronym for &#8220;YAML Ain&#8217;t Markup Language&#8221;.</p>
+<p>YAML is similar to JSON, and in fact, JSON is a subset of YAML 1.2; but YAML has
+some more advanced features and is easier to read. However, YAML is also more
+difficult to parse (and probably somewhat slower). Data is stored in mappings
+(associative arrays), sequences (lists) and scalars (single values). Data
+structure hierarchy either depends on indentation (block context, similar to
+Python code), or nesting of brackets and braces (flow context, similar to JSON).
+YAML comments begin with <tt class="docutils literal"><span class="pre">#</span></tt> and continue until the end of line.</p>
+<div class="section" id="documents">
+<h2>Documents<a class="headerlink" href="#documents" title="Permalink to this headline">¶</a></h2>
+<p>A YAML stream consists of one or more documents starting with <tt class="docutils literal"><span class="pre">---</span></tt> and
+optionally ending with <tt class="docutils literal"><span class="pre">...</span></tt> . If there is only one document, <tt class="docutils literal"><span class="pre">---</span></tt> can be
+left out.</p>
+<p>Single document with no explicit start or end:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Red</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Green</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Blue</span>
+</pre></div>
+</div>
+<p>Same document with explicit start and end:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="nn">---</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Red</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Green</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Blue</span>
+<span class="nn">...</span>
+</pre></div>
+</div>
+<p>A stream containing multiple documents:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="nn">---</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Red</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Green</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Blue</span>
+<span class="nn">---</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Linux</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">BSD</span>
+<span class="nn">---</span>
+<span class="l-Scalar-Plain">answer</span> <span class="p-Indicator">:</span> <span class="l-Scalar-Plain">42</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="sequences">
+<h2>Sequences<a class="headerlink" href="#sequences" title="Permalink to this headline">¶</a></h2>
+<p>Sequences are arrays of nodes of any type, similar e.g. to Python lists.
+In block context, each item begins with hyphen+space &#8220;- &#8220;. In flow context,
+sequences have syntax similar to D arrays.</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Block context</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Red</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Green</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Blue</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Flow context</span>
+<span class="p-Indicator">[</span><span class="nv">Red</span><span class="p-Indicator">,</span> <span class="nv">Green</span><span class="p-Indicator">,</span> <span class="nv">Blue</span><span class="p-Indicator">]</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Nested</span>
+<span class="p-Indicator">-</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Red</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Green</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Blue</span>
+<span class="p-Indicator">-</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Linux</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">BSD</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Nested flow</span>
+<span class="p-Indicator">[[</span><span class="nv">Red</span><span class="p-Indicator">,</span> <span class="nv">Green</span><span class="p-Indicator">,</span> <span class="nv">Blue</span><span class="p-Indicator">],</span> <span class="p-Indicator">[</span><span class="nv">Linux</span><span class="p-Indicator">,</span> <span class="nv">BSD</span><span class="p-Indicator">]]</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Nested in a mapping</span>
+<span class="l-Scalar-Plain">Colors</span><span class="p-Indicator">:</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Red</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Green</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Blue</span>
+<span class="l-Scalar-Plain">Operating systems</span><span class="p-Indicator">:</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">Linux</span>
+  <span class="p-Indicator">-</span> <span class="l-Scalar-Plain">BSD</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="mappings">
+<h2>Mappings<a class="headerlink" href="#mappings" title="Permalink to this headline">¶</a></h2>
+<p>Mappings are associative arrays where each key and value can be of any type,
+similar e.g. to Python dictionaries. In block context, keys and values are
+separated by colon+space &#8220;: &#8220;. In flow context, mappings have syntax similar
+to D associative arrays, but with braces instead of brackets:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Block context</span>
+<span class="l-Scalar-Plain">CPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Athlon</span>
+<span class="l-Scalar-Plain">GPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Radeon</span>
+<span class="l-Scalar-Plain">OS</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Linux</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Flow context</span>
+<span class="p-Indicator">{</span><span class="nv">CPU</span><span class="p-Indicator">:</span> <span class="nv">Athlon</span><span class="p-Indicator">,</span> <span class="nv">GPU</span><span class="p-Indicator">:</span> <span class="nv">Radeon</span><span class="p-Indicator">,</span> <span class="nv">OS</span><span class="p-Indicator">:</span> <span class="nv">Linux</span><span class="p-Indicator">}</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Nested</span>
+<span class="l-Scalar-Plain">PC</span><span class="p-Indicator">:</span>
+  <span class="l-Scalar-Plain">CPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Athlon</span>
+  <span class="l-Scalar-Plain">GPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Radeon</span>
+  <span class="l-Scalar-Plain">OS</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Debian</span>
+<span class="l-Scalar-Plain">Phone</span><span class="p-Indicator">:</span>
+  <span class="l-Scalar-Plain">CPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Cortex</span>
+  <span class="l-Scalar-Plain">GPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">PowerVR</span>
+  <span class="l-Scalar-Plain">OS</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Android</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Nested flow</span>
+<span class="p-Indicator">{</span><span class="nv">PC</span><span class="p-Indicator">:</span> <span class="p-Indicator">{</span><span class="nv">CPU</span><span class="p-Indicator">:</span> <span class="nv">Athlon</span><span class="p-Indicator">,</span> <span class="nv">GPU</span><span class="p-Indicator">:</span> <span class="nv">Radeon</span><span class="p-Indicator">,</span> <span class="nv">OS</span><span class="p-Indicator">:</span> <span class="nv">Debian</span><span class="p-Indicator">},</span>
+ <span class="nv">Phone</span><span class="p-Indicator">:</span> <span class="p-Indicator">{</span><span class="nv">CPU</span><span class="p-Indicator">:</span> <span class="nv">Cortex</span><span class="p-Indicator">,</span> <span class="nv">GPU</span><span class="p-Indicator">:</span> <span class="nv">PowerVR</span><span class="p-Indicator">,</span> <span class="nv">OS</span><span class="p-Indicator">:</span> <span class="nv">Android</span><span class="p-Indicator">}}</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Nested in a sequence</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">CPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Athlon</span>
+  <span class="l-Scalar-Plain">GPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Radeon</span>
+  <span class="l-Scalar-Plain">OS</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Debian</span>
+<span class="p-Indicator">-</span> <span class="l-Scalar-Plain">CPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Cortex</span>
+  <span class="l-Scalar-Plain">GPU</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">PowerVR</span>
+  <span class="l-Scalar-Plain">OS</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Android</span>
+</pre></div>
+</div>
+<p>Complex keys start with question mark+space &#8220;? &#8220;.</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="c1">#Nested in a sequence</span>
+<span class="p-Indicator">?</span> <span class="p-Indicator">[</span><span class="nv">CPU</span><span class="p-Indicator">,</span> <span class="nv">GPU</span><span class="p-Indicator">]:</span> <span class="p-Indicator">[</span><span class="nv">Athlon</span><span class="p-Indicator">,</span> <span class="nv">Radeon</span><span class="p-Indicator">]</span>
+<span class="l-Scalar-Plain">OS</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Debian</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="scalars">
+<h2>Scalars<a class="headerlink" href="#scalars" title="Permalink to this headline">¶</a></h2>
+<p>Scalars are simple values such as integers, strings, timestamps and so on.
+There are multiple scalar styles.</p>
+<p>Plain scalars use no quotes, start with the first non-space and end with the
+last non-space character:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">scalar</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Plain scalar</span>
+</pre></div>
+</div>
+<p>Single quoted scalars start and end with single quotes. A single quote is
+represented by a pair of single quotes &#8216;&#8217;.</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">scalar</span><span class="p-Indicator">:</span> <span class="s">&#39;Single</span><span class="nv"> </span><span class="s">quoted</span><span class="nv"> </span><span class="s">scalar</span><span class="nv"> </span><span class="s">ending</span><span class="nv"> </span><span class="s">with</span><span class="nv"> </span><span class="s">some</span><span class="nv"> </span><span class="s">spaces</span><span class="nv">    </span><span class="s">&#39;</span>
+</pre></div>
+</div>
+<p>Double quoted scalars support C-style escape sequences.</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">scalar</span><span class="p-Indicator">:</span> <span class="s">&quot;Double</span><span class="nv"> </span><span class="s">quoted</span><span class="nv"> </span><span class="s">scalar</span><span class="nv"> </span><span class="s">\n</span><span class="nv"> </span><span class="s">with</span><span class="nv"> </span><span class="s">some</span><span class="nv"> </span><span class="s">\\</span><span class="nv"> </span><span class="s">escape</span><span class="nv"> </span><span class="s">sequences&quot;</span>
+</pre></div>
+</div>
+<p>Block scalars are convenient for multi-line values. They start either with
+<tt class="docutils literal"><span class="pre">|</span></tt> or with <tt class="docutils literal"><span class="pre">&gt;</span></tt>. With <tt class="docutils literal"><span class="pre">|</span></tt>, the newlines in the scalar are preserved.
+With <tt class="docutils literal"><span class="pre">&gt;</span></tt>, the newlines between two non-empty lines are removed.</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">scalar</span><span class="p-Indicator">:</span> <span class="p-Indicator">|</span>
+  <span class="no">Newlines are preserved</span>
+  <span class="no">First line</span>
+  <span class="no">Second line</span>
+</pre></div>
+</div>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">scalar</span><span class="p-Indicator">:</span> <span class="p-Indicator">&gt;</span>
+  <span class="no">Newlines are folded</span>
+  <span class="no">This is still the first paragraph</span>
+
+  <span class="no">This is the second</span>
+  <span class="no">paragraph</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="anchors-and-aliases">
+<h2>Anchors and aliases<a class="headerlink" href="#anchors-and-aliases" title="Permalink to this headline">¶</a></h2>
+<p>Anchors and aliases can reduce size of YAML code by allowing you to define a
+value once, assign an anchor to it and use alias referring to that anchor
+anywhere else you need that value. It is possible to use this to create
+recursive data structures and some parsers support this; however, D:YAML does
+not (this might change in the future, but it is unlikely).</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">Person</span><span class="p-Indicator">:</span> <span class="nl">&amp;AD</span>
+  <span class="l-Scalar-Plain">gender</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">male</span>
+  <span class="l-Scalar-Plain">name</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Arthur Dent</span>
+<span class="l-Scalar-Plain">Clone</span><span class="p-Indicator">:</span> <span class="nv">*AD</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="tags">
+<h2>Tags<a class="headerlink" href="#tags" title="Permalink to this headline">¶</a></h2>
+<p>Tags are identifiers that specify data types of YAML nodes. Most default YAML
+tags are resolved implicitly, so there is no need to specify them. D:YAML also
+supports implicit resolution for custom, user specified tags.</p>
+<p>Explicitly specified tags:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">answer</span><span class="p-Indicator">:</span> <span class="kt">!!int</span> <span class="s">&quot;42&quot;</span>
+<span class="l-Scalar-Plain">name</span><span class="p-Indicator">:</span>   <span class="kt">!!str</span> <span class="s">&quot;Arthur</span><span class="nv"> </span><span class="s">Dent&quot;</span>
+</pre></div>
+</div>
+<p>Implicit tags:</p>
+<div class="highlight-yaml"><div class="highlight"><pre><span class="l-Scalar-Plain">answer</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">42</span>        <span class="c1">#int</span>
+<span class="l-Scalar-Plain">name</span><span class="p-Indicator">:</span> <span class="l-Scalar-Plain">Arthur Dent</span> <span class="c1">#string</span>
+</pre></div>
+</div>
+<p>This table shows D types stored in <em>yaml.Node</em> default YAML tags are converted to.
+Some of these might change in the future (especially !!map and !!set).</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="58%" />
+<col width="42%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th class="head">YAML tag</th>
+<th class="head">D type</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td>!!null</td>
+<td>yaml.YAMLNull</td>
+</tr>
+<tr><td>!!bool</td>
+<td>bool</td>
+</tr>
+<tr><td>!!int</td>
+<td>long</td>
+</tr>
+<tr><td>!!float</td>
+<td>real</td>
+</tr>
+<tr><td>!!binary</td>
+<td>ubyte[]</td>
+</tr>
+<tr><td>!!timestamp</td>
+<td>datetime.SysTime</td>
+</tr>
+<tr><td>!!map, !!omap, !!pairs</td>
+<td>Node.Pair[]</td>
+</tr>
+<tr><td>!!seq, !!set</td>
+<td>Node[]</td>
+</tr>
+<tr><td>!!str</td>
+<td>string</td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="../index.html">
+              <img class="logo" src="../_static/logo210.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="../index.html">Table Of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">YAML syntax</a><ul>
+<li><a class="reference internal" href="#documents">Documents</a></li>
+<li><a class="reference internal" href="#sequences">Sequences</a></li>
+<li><a class="reference internal" href="#mappings">Mappings</a></li>
+<li><a class="reference internal" href="#scalars">Scalars</a></li>
+<li><a class="reference internal" href="#anchors-and-aliases">Anchors and aliases</a></li>
+<li><a class="reference internal" href="#tags">Tags</a></li>
+</ul>
+</li>
+</ul>
+
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../articles/spec_differences.html" title="Differences between D:YAML and the YAML specification"
+             >next</a></li>
+        <li class="right" >
+          <a href="custom_types.html" title="Custom YAML data types"
+             >previous</a> |</li>
+        <li><a href="../index.html">D:YAML v0.1 documentation</a> &raquo;</li> 
+      </ul>
+    </div>
+    <div class="footer">
+        &copy; Copyright 2011, Ferdinand Majerech. Based on PyYAML http://www.pyyaml.org by Kirill Simonov.
+      Last updated on Aug 16, 2011.
+      Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.1.
+    </div>
+  </body>
+</html>