Main  /  Edit version 2  /  Edit version 3  /   /  Users Area

Difference "Tutorial: "Hello World" with templates." ver. 2 versus ver. 3

Content:

## Code
Now we are going to create our first project that uses templates.
CppCMS template system consists of two important parts:
1. The content that is rendered to HTML
2. The template that can render given content to HTML
First we create content -- `data.h`:
#ifndef DATA_H
#define DATA_H
#include <cppcms/base_view.h>
#include <string>
namespace data {
struct message : public cppcms::base_content {
std::string message;
};
}
#endif
We create a content class "message" that must be
derived from `cppcms::base_content` class. It includes the data we want to show. In our case it is a simple string "message".
It is recommended to put all "content" classes to separate namespace.
Once the content is created we can create the template
that would render out content `my_view.tmpl`:
<% c++ #include "data.h" %>
<% namespace my_view %>
<% class message uses data::message %>
<% template render() %>
<html>
<body>
<h1><% message %> World!</h1>
</body>
<html>
<% end template %>
<% end class %>
<% end namespace %>
Every template directive enclosed by pair of `<%`, `%>`.
First line `<% c++ ... %>` represents any C++ code string. We need tell our class what content should be used. Thus we give an "include" for appropriate header.
Then we define namespace where all our templates are placed `<% namespace my_view %>` and then create a class that renders our content.
<% class message uses data::message %>
Class my\_view::message would render data::message content. The primary function that should be implemented is "render()". After `<% template render() %>` we write the
body of our html message.
You can see `<% message %>` command. It tells that "message" member of our content class should be displayed.
**Note:** Every std::string automatically receives HTML escaping. Thus it is safe to show any row data there.
Now, lets see how we use it in our code.
First we call `use_template("my_view")` in the constructor of `my_hello_world`. It tells to application, which template set should be used for rendering.
Then, in `main()` function we write:
data::message c;
c.message=">>>Hello<<<";
render("message",c);
We create an instance of `data::message` --- "c". We set its `message` member with appropriate string we want to show. We may safely put any symbols like "<", they would be
automatically escaped.
Then we call `render("message",c)`. It would use `my_view::message` class for rendering template content "c".
That's it, the code is complete.
## Build
There are two options of building templates:
1. Statically compile them into the executable
2. Compile them as shared object and load them with application start-up.
### Static build
First we compile our template
cppcms_tmpl_cc my_view.tmpl -o my_view.cpp
Then we can build our project
g++ hello.cpp my_view.cpp -lcppcms -o hello.fcgi
Now we run as usuall `cppcms_run hello.fcgi -c conf.txt`
### Dynamic build is little bit more tricy.
### Dynamic build is little bit more tricky.
After we had build our `my_view.cpp` we should compile it
as shared object:
g++ -shared -fPIC my_view.cpp -lcppcms -o my_view.so
Then compile our application with additional flag `-export-dynamic`.
g++ -export-dynamic hello.cpp -lcppcms -o hello.fcgi
Without this flag, RTTI, would not work between application
and shared object and you may receive a error "incorrect content type".
Now we should let our application know where its templates
are placed. We edit conf.txt and add following line:
templates.dirs={ "." }
When `hello.fcgi` starts, it would look in this directory
and try load all shared object it finds.
Now we can start our application as usual.

About

CppCMS is a web development framework for performance demanding applications.

Support This Project

SourceForge.net Logo

Поддержать проект

CppCMS needs You


Navigation

Main Page


Valid CSS | Valid XHTML 1.0