POCO^PRO C++ Frameworks

Multi-Protocol Stack and Code Generator

Remoting for C++ is a web services and remote method call framework for C++. Remoting supports different communication protocols. This includes JSON-based REST APIs, JSON-RPC, SOAP and a highly efficient binary protocol.
Remote services are implemented as C++ classes, annotated with special comments. The Remoting code generator takes care of the rest. There is no need to maintain a separate interface definition using an interface definition language (IDL).

REST API Sample

The following code snipped shows an example for how to define a RESTful API with Remoting. This definition is specific to the Remoting REST transport. Note how the method names correspond to HTTP methods. Also note the special comments. The Remoting code generator (RemoteGen) parses these definitions and generates C++ code that implements serialization, deserialization and remote invocation.

//@ serialize
struct User
{
    Poco::Optional<std::string> name;
    Poco::Optional<std::string> password;
    Poco::Optional<std::set<std::string>> permissions;
    Poco::Optional<std::set<std::string>> roles;
};

//@ remote
//@ path="/api/1.0/users"
class UserCollectionEndpoint
{
public:
    User post(const User& user);
        /// Create a new user.

    //@ $maxResults={in=query, optional}
    //@ $start={in=query, optional}
    std::vector<User> get(int maxResults = 0, int start = 0);
        /// Return a list of user objects, starting with
        /// the given start index, and return at most
        /// maxResults items.
};

//@ remote
//@ path="/api/1.0/users/{name}"
class UserEndpoint
{
public:
    //@ $name={in=path}
    User put(const std::string& name, const User& user);
        /// Update a user (calls patch()).

    //@ $name={in=path}
    User patch(const std::string& name, const User& user);
        /// Update a user.

    //@ $name={in=path}
    User get(const std::string& name);
        /// Retrieve a user by name.

    //@ $name={in=path}
    void delete_(const std::string& name);
        /// Delete a user.
};

Build, deploy and manage dynamic, modular C++ applications

Open Service Platform (OSP) enables the creation, deployment and management of dynamically extensible, modular applications, based on a powerful plug-in and (nano-) services model. Applications built with OSP can be extended, upgraded and managed even when deployed in the field. At the core of OSP lies a powerful software component (plug-in) and services model based on the concept of bundles. A bundle is a deployable entity, consisting of both executable code (shared libraries) and the required configuration, data and resource files.