Update ReadMe.md

Author: flexferrum

README.md

@@ -36,3 +36,109 @@ Helloworld!!!
 Hello, world!!!
 Hello; world!!!
 ```
+
+# Getting started
+
+In order to use Jinja2Cpp in your project you have to:
+* Clone the Jinja2Cpp repository
+* Build it according with the instructions
+* Link with your project.
+
+Usage of Jinja2Cpp in the code is pretty simple:
+1. Declare the jinja2::Template object:
+
+```c++
+jinja2::Template tpl;
+```
+
+2. Populate it with template:
+
+```c++
+tpl.Load("{{'Hello World' }}!!!");
+```
+
+3. Render the template:
+
+```c++
+std::cout << tpl.RenderAsString(jinja2::ValuesMap{}) << std::endl;
+```
+
+and get:
+
+`
+Hello World!!!
+`
+
+That's all!
+
+The render procedure is stateless, so you can perform several renderings simultaneously in different threads. Even if you pass parameters:
+
+```c++
+    ValuesMap params = {
+        {"intValue", 3},
+        {"doubleValue", 12.123f},
+        {"stringValue", "rain"},
+        {"boolFalseValue", false},
+        {"boolTrueValue", true},
+    };
+
+    std::string result = tpl.RenderAsString(params);
+    std::cout << result << std::endl;
+```
+
+Parameters could have the following types:
+- std::string/std::wstring
+- integer (int64_t)
+- double
+- boolean (bool)
+- Tuples (also known as arrays)
+- Dictionaries (also known as maps)
+
+Tuples and dictionaries can be mapped to the C++ types. So you can smoothly reflect your structures and collections into the template engine:
+
+```c++
+namespace jinja2
+{
+template<>
+struct TypeReflection<reflection::EnumInfo> : TypeReflected<reflection::EnumInfo>
+{
+    static auto& GetAccessors()
+    {
+        static std::unordered_map<std::string, FieldAccessor> accessors = {
+            {"name", [](const reflection::EnumInfo& obj) {return Reflect(obj.name);}},
+            {"scopeSpecifier", [](const reflection::EnumInfo& obj) {return Reflect(obj.scopeSpecifier);}},
+            {"namespaceQualifier", [](const reflection::EnumInfo& obj) { return obj.namespaceQualifier;}},
+            {"isScoped", [](const reflection::EnumInfo& obj) {return obj.isScoped;}},
+            {"items", [](const reflection::EnumInfo& obj) {return Reflect(obj.items);}},
+        };
+
+        return accessors;
+    }
+};
+
+// ...
+    jinja2::ValuesMap params = {
+        {"enum", jinja2::Reflect(enumInfo)},
+    };
+```
+
+In this cases method 'jinja2::reflect' reflects regular C++ type into jinja2 template param. If type is a user-defined class or structure then handwritten mapper 'TypeReflection<>' should be provided.
+
+# Current Jinja2 support
+Currently, Jinja2Cpp supports the limited number of Jinja2 features. By the way, Jinja2Cpp is planned to be full [jinja2 specification](http://jinja.pocoo.org/docs/2.10/templates/)-conformant. The current support is limited to:
+- expressions. You can use almost every style of expressions: simple, filtered, conditional, and so on.
+- limited number of filters (**join**, **sort**)
+- limited number of testers (**defined**, **startsWith**)
+- limited number of functions (**range**, **loop.cycle**)
+- 'if' statement (with 'elif' and 'else' branches)
+- 'for' statement (with 'else' branch support)
+- 'set' statement
+
+# Supported compilers
+Compilation of Jinja2Cpp tested on the following compilers (with C++14 enabled feature):
+- Linux gcc 5.0
+- Linux gcc 6.0
+- Linux gcc 7.0
+- Linux clang 5.0
+- Microsoft Visual Studio 2015 x86
+- Microsoft Visual Studio 2017 x86