## Table Of Contents
|
|
- [General Notes](#gn)
|
- [Namespace or Skin](#ns)
|
- [Class or Single Page](#cl)
|
- [Template or Member Function](#tmpl)
|
<!--toc-->
|
|
## <span id="gn"></span>General notes
|
## General notes
|
|
Each block begins with its definition and ends with special command `end`.
|
|
'end' [ 'namespace' | 'class' | 'template' ]
|
|
This command may optionally include block type after it. For example:
|
|
<% namespace vary %>
|
<% class master uses data %>
|
...
|
<% end class %>
|
<% end %>
|
|
So we closed `namespace` without block type and `class` with specification.
|
It may be used as additional checking of order of blocks.
|
|
|
## <span id="ns"></span>namespace
|
## namespace
|
|
### Syntax:
|
|
'namespace' (NAME|'vary')
|
|
It is topmost command in every template.
|
Namespace can be specified by specific name, or using `vary` keyword that mean that its name should be defined
|
externally during build process using switch `-n`.
|
|
### Notes
|
|
- If all the skin you create would not share any part with other skin, specify its name, otherwise use `vary`.
|
- You can't use both `vary` and predefined namespace withing same skin.
|
|
## <span id="cl"></span>class
|
## class
|
|
### Syntax:
|
|
'class' NAME 'uses' IDENTIFIER ['extends' NAME]
|
|
Creates new class that responsible on rendering specific type of content pages. `'uses' IDENTIFIER` specifies the type of the content that this class should render. It actually defines `content` reference member of this type.
|
|
Remember this note, in some cases, you would have to access `content` member directly.
|
|
You can specify `'extends' NAME` if you want that new created class would inherit from other template class.
|
|
### Derivation restrictions
|
|
When you create derived class the content of the child should be derived from the content of its parent as well.
|
For example:
|
|
<% class master uses data::master %>
|
..
|
<% end class %>
|
<% class page uses data::page extends master %>
|
...
|
<% end class %>
|
|
Then, `data::page` _must_ be derived from `data::master`.
|
|
_Rationale:_
|
|
When you create `master` parent you need provide for it a content as well. It receives its child content, thus it
|
may work if its child content derived from its parent content.
|
|
### Generated Code
|
|
The generated code for the above two examples would look like this (approximately):
|
|
class master : public base_view {
|
data::master &content;
|
master(settings s,data::master cnt) :
|
base_view(settings),
|
content(cnt)
|
{
|
...
|
}
|
...
|
};
|
class page : public master {
|
data::page &content;
|
page(settings s,data::page cnt) :
|
master(s,cnt),
|
content(cnt)
|
{
|
...
|
}
|
...
|
};
|
|
## <span id="tmpl"></span>template
|
## template
|
|
### Syntax
|
|
Definition of template consists of its name, round brackets and optional, comma separated list of parameters:
|
|
'template' NAME '(' [ parameter [',' parameter ... ] ] ')'
|
|
Where `parameters` is :
|
|
IDENTIFIER ['const' ] ['&'] NAME
|
|
For example:
|
|
<% template render() %>
|
<% template show_list(data::list_t const &list) %>
|
<% template show_numbers(int x,int y, double z) %>
|
|
Note: you can not specify template parameters like `list<int>`. You should define a type for them.
|
|
### Generated Code
|
|
Each template is translated to virtual member function of the class it defined in. This function
|
returns `void` and receives defined parameters, thus, `show_list` in the above example would be
|
translated to:
|
|
virtual void show_list(data::list_t const &list)
|
{
|
...
|
}
|
|
|
|
