IMPORTANT NOTICE This framework is currently under heavy development. For now, the use of this framework is not recommended for real projects.
Aiming for productivity and performance, the Icarus Framework is a Web Development Framework written in C/C++ with some ideas compatible with the Play Framework (Scala and Java).
Based on Model-View-Controller, the framework provides a facilities to integrate with the SOCI (database access library that provides backend for many servers as MySQL, Oracle, PostgreSQL).
For a better setup with different technologies and plataforms, the FastCGI is used for integration with HTTP Servers. Hence, the framework does not need to work with the complexity of a full web server implementation. Although it still can be applied in the future, as another method.
All the development of a project using this framework (not mandatory) will used CMake as the default build system. If you use another build tool, it can be used too, but is not default configured. You are very welcome to contribute.
Right now, we have no idea about the performance of the current implementation. Once we get a stable version done, tests will be performed in order to analyze and improve the general speed.
Internet Icarus
~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~
Request FastCGI
+--------+ +------------+ +-------------+ +------------+
| Client | => | HttpServer | => | Application | => | Dispatcher |
+--------+ +------------+ +-------------+ +------------+
||
\/
+------+ +------------+ +--------+
| View | <= | Controller | <= | Routes |
+------+ +------------+ +--------+
The routes is a simple text file that binds URIs with controller methods.
Internally, at the pre-build stage of the project compilation, the framework
will parse and transform the routes into C++ code. Afterwards, the temporary
C++ code will be compiled into the main executable (or into a library).
The basic structure is composed by the HTTP method, the corresponding URI (with a params description support) and the controller method that will handle that request.
The rules are checked in sequence from the top to bottom.
// This is a inline comment comment
/** This is a
* multiline comment
*/
GET / controllers::index::def()
GET /about controllers::static_pages::about()
GET /<user:[a-z_]+>/dashboard controllers::user::dashboard(string user)
// ON next, another way to write the param definition.
GET /<user>/dashboard controllers::user::dashboard(string user)
GET /user/create controllers::user::form()
POST /user/create controllers::user::create()
Another feature implemented are groups. Where
on /<user>
{
GET / controllers::user::dashboard(std::string user)
// On next, we do not need to use the `user` param.
GET /posts controllers::user::posts()
GET /posts/<month:[0-9]+> controllers::user::posts(std::string user, unsigned int month)
}
The model part still under development.
The view system is HTML/C++ (.hpp.html) based, which can receive parameters as input.
@(std::string title, unsigned int count)
<html>
<head>
<title>@title</title>
</head>
<body>
Sequence: @{
for (unsigned int i = 0; i < count; i++)
{
out << " " << count;
}
}
</body>
</html>The view is basically parsed and converted to a C++ class as an static method. It makes the template system very efficient, once it is a compiled code.
The controllers have a , general, simple implementation.
namespace controllers
{
class index
{
public:
static icarus::result def()
{
icarus::result r("<html>A string can be used as a content.</html>");
return r;
}
};
}Below, a example using a view:
namespace controllers
{
class signin
{
public:
static icarus::result sign_in_form()
{
icarus::result r;
views::login::signin(r);
return r;
}
};
}Other facilities as HTTP Session and WebSockets will be implemented in future versions.