delphi yaml

学战發表於 2021-1-2 19:49:00

delphi yaml
https://github.com/lim417dev/Neslib.Yaml
https://github.com/neslib/Neslib
<h1>Neslib.Yaml - A YAML library for Delphi</h1>
Neslib.Yaml is a library for parsing and emitting YAML and constructing YAML documents and streams.
Neslib.Yaml is build on top of the LibYaml library and works on:
<ul>
<li>Windows (32-bit and 64-bit)</li>
<li>MacOS (32-bit and soon 64-bit)</li>
<li>iOS (32-bit and 64-bit, no simulator)</li>
<li>Android (32-bit and 64-bit later)</li>
</ul>
<h2>Installation and Dependencies</h2>
To install:
<div class="highlight highlight-source-shell">
<pre>> git clone --recursive https://github.com/neslib/Neslib.Yaml</pre>
</div>
This library only depends on the Neslib repository, which is included as submodule with this repository.
For all platforms except MacOS 32-bit, there are no run-time dependencies: the LibYaml library is linked directly into the executable. For MacOS 32-bit, you need to deploy the <code>libyaml_mac32.dylib</code> library to the remote path <code>Contents\MacOS\</code>.
<h2>YAML in a Nutshell</h2>
Here is a very brief introduction for YAML. For more detailed information take a look at the official YAML site or one of the many on-line resources such as this one.
YAML (short for "YAML Ain't Markup Language") is a data serialization language. Unlike many other similar text-based languages (like JSON and XML) a primary goal of YAML is to be human-readable and also easy to create by humans. That's why its is commonly used for configuration files. However, it can be used for all kinds of data, such as this example from the YAML specification:
<div class="highlight highlight-source-yaml">
<pre>invoice: 34843
date : 2001-01-23
bill-to: &id001
given: Chris
family : Dumars
address:
 lines: |
 458 Walkman Dr.
 Suite #292
 city : Royal Oak
 state : MI
 postal: 48046
ship-to: *id001
product:
- sku : BL394D
 quantity : 4
 description : Basketball
 price : 450.00
- sku : BL4438H
 quantity : 1
 description : Super Hoop
 price : 2392.00
tax: 251.42
total: 4443.52
comments: >
 Late afternoon is best.
 Backup contact is Nancy
 Billsmer @ 338-4338.</pre>
</div>
A YAML document is a tree of values, called nodes (<code>TYamlNode</code> in this library). There are 4 kinds of nodes:
<h3>Mappings</h3>
Mappings are similar to Delphi dictionaries. A mapping is a collection of key/value pairs. The root note of the sample document above is a mapping: it maps the key <code>invoice</code> to the value <code>34843</code> and contains 7 other key/value pairs (from <code>date</code> to <code>comments</code>). Both keys and values can be any YAML type, although you probably want to stick to strings for keys.
Mappings can be written in block notation (as in the example) or flow notation (using curly braces <code>{}</code>).
When using block notation, YAML uses indentation for scoping. Only spaces are allowed for indentation (not tabs). The number of spaces doesn't matter as long as all values at the same level use the same amount of spaces. In the example, the value of the <code>bill-to</code> key is another mapping. This mapping is indented to indicate that it belongs to the <code>bill-to</code>key.
<h3>Sequences</h3>
Sequences are like Delphi arrays or lists. Small sequences can be written using flow notation (using square brackets <code>[]</code>). Larger or complex sequences are usually written in block notation as in the example: the value of the <code>product</code> key is a sequence of two products (a basketball and super hoop). Each item in the sequence starts with a dash and a space.
In this example, each product in the sequence is a mapping of 4 key/value pairs.
<h3>Aliases</h3>
All nodes have at least two properties: a <code>Tag</code> and an <code>Anchor</code>. Tags are used to describe the semantic type of a node. Tags are not that common, so I will skip them in this introduction. Neslib.Yaml has full support for tags though.
An anchor can be used to mark a node in the document. You can then later refer back to this node using an alias.
Anchors are prefixed with an ampersand (<code>&</code>). In the example, the value of the <code>bill-to</code> key has an anchor called <code>id001</code> (the ampersand is not part of the name). Later in the document, the <code>ship-to</code> key refers back to this anchor using an alias (an asterisk followed by the anchor name, eg. <code>*id001</code>). This is a way of saying that the shipping address is the same as the billing address. Note that an alias does not copy the referenced value; it really just refers to another node.
Anchors must appear in the document before they can be referenced. Their names don't have to be unique within the document; if an new anchor is declared with the same name, it replaces the old anchor.
<h3>Scalars</h3>
Scalars are the simplest types. Everything that is not a mapping, sequence or alias is a scalar. In practice, scalars are just strings. All the keys in the example above are string scalars, but a lot of the values are as well (such as <code>34843</code>, <code>2001-01-23</code> and <code>Chris</code>).
The YAML 1.1 specification (which is what LibYaml uses) treats all these scalars as strings, even if they are numbers or dates as in this example. You can use tags to explicitly state that a specific scalar is of a specific type.
The <code>TYamlNode</code> record in this library provides methods like <code>ToInteger</code> and <code>ToDouble</code> to (try to) convert to Delphi types, regardless of any tags that may be attached to a node.
Scalars can be written in different "styles":
<ul>
<li>The plain style is the most common style. It doesn't use any special symbols. Most scalars in the example are in plain style.</li>
<li>The double-quoted style is useful if you need escape sequences in the text.</li>
<li>The single-quoted style can be used if backslashes in text should not be un-escaped (eg. when using Windows file paths).</li>
<li>The literal style can be used for a block of text spanning multiple lines. It starts with a pipe symbol (<code>|</code>). In the example above, the <code>bill-to.address.lines</code> value is a literal. Any new-lines in a literal are preserved.</li>
<li>Finally, the folded style is similar to the literal style, but line breaks are folded (replaced with spaces). It is used with the <code>comments</code> key in the example.</li>
</ul>
There is much more to YAML, but this should cover many use cases.
<h2>Loading or Parsing YAML</h2>
The main entry point to this library is the <code>IYamlDocument</code> or <code>IYamlStream</code> interface.
A YAML file can contain multiple documents. If that is the case, you should use an <code>IYamlStream</code> to load it. A stream is just a collection of documents (of type <code>IYamlDocument</code>).
Most of the time though, a YAML file contains just a single document and it is easier to start with a <code>IYamlDocument</code>. Loading a document is easy:
<div class="highlight highlight-source-pascal">
<pre>var
Doc: IYamlDocument;
begin
Doc := TYamlDocument.Load('invoice.yaml');
end;</pre>
</div>
You can load from a file or stream, or you can parse YAML text using the <code>TYamlDocument.Parse</code> method.
You can now use the <code>IYamlDocument.Root</code> property to inspect the document. This property is of type <code>TYamlNode</code>, which is the building block for all documents.
<blockquote>
TYamlNode is implemented as a record to keep it light-weight. All nodes are "owner" by a document. This makes memory management fully automatic: once a document goes out of scope, all its nodes will be freed automatically. This does mean though that you should not "hang on" to nodes after a document has gone out of scope. Doing so results in undefined behavior or access violations.
</blockquote>
For example, to access the <code>price</code> of the first product in the example above, you can use the following code:
<div class="highlight highlight-source-pascal">
<pre>Price := Doc.Root.Values['product'].Nodes[0].Values['price'].ToDouble;</pre>
</div>
You use the <code>Values</code> property to access values by key in mapping. Likewise the <code>Nodes</code> property is used to access values by index in a sequence, and one of the <code>ToXXX</code> methods can be used to convert a scalar value to a Delphi datatype.
To check the type of a node, you can use the <code>NodeType</code> property or one of the <code>IsXXX</code> properties (<code>IsMapping</code>, <code>IsScalar</code> etc.).
<h2>Constructing and Emitting YAML</h2>
You can also create a YAML document from scratch and save it to a file or convert it to YAML. To create a YAML document, use one of the <code>TYamlDocument.CreateXXX</code> methods, depending on the type of root node you need. If you want to reconstruct the example document, you would start out with a mapping and call:
<div class="highlight highlight-source-pascal">
<pre>Doc := TYamlDocument.CreateMapping;</pre>
</div>
You can then start to add key/value pairs"
<div class="highlight highlight-source-pascal">
<pre>Doc.Root.AddOrSetValue('invoice', 34843);
Doc.Root.AddOrSetValue('date', '2001-01-23');</pre>
</div>
The <code>AddOrSetValue</code> method is used to add key/value pairs to a mapping. If the node is not a mapping, then an <code>EInvalidOperation</code> exception will be raised.
To add a non-scalar value, use one of the other <code>AddOrSetXXX</code> methods:
<div class="highlight highlight-source-pascal">
<pre>var
Products: TYamlNode;
begin
Products := Doc.Root.AddOrSetSequence('product');
end;</pre>
</div>
This adds a sequence to the mapping with the key <code>product</code>. You can then add values to the sequence using one of the <code>AddXXX</code> methods. Again, an <code>EInvalidOperation</code> exception will be raised if the node is not a sequence. In the example, we need to add another mapping to this sequence:
<div class="highlight highlight-source-pascal">
<pre>var
Product: TYamlNode;
begin
Product := Products.AddMapping;
Product.AddOrSetValue('sku', 'BL394D');
Product.AddOrSetValue('quantity', 4);
// etc...
end;</pre>
</div>
Once you have constructed your document, you can save it to a file or stream using the <code>Save</code> method, or convert it to YAML using the <code>ToYaml</code> method:
<div class="highlight highlight-source-pascal">
<pre>var
Yaml: String;
begin
Yaml := Doc.ToYaml;
end;</pre>
</div>
You can pass an optional <code>TYamlOutputSettings</code> record to customize the YAML formatting.
<h2>More Information</h2>
There is more to Neslib.Yaml than described above. For more details you can look at the well-document <code>Neslib.Yaml.pas</code> source file. Additional usage samples can be found in the unit tests, especially in the <code>Tests.Neslib.Yaml.Sample.pas</code> file.
<h2>License</h2>
Neslib.Yaml is licensed under the Simplified BSD License.
See License.txt for details.

</div>
<div id="MySignature" role="contentinfo">
本文来自博客园，作者：{咏南中间件}，转载请注明原文链接：https://www.cnblogs.com/hnxxcxg/p/14223698.html 
来源：https://www.cnblogs.com/hnxxcxg/p/14223698.html

頁: [1]

琼殿技术论坛's Archiver

delphi yaml