POCO C++ Libraries Intro and Overview

POCO C++ Libraries Intro & Overview

Günter ObiltschnigFounder, POCO C++ Libraries ProjectApplied Informatics Software Engineering GmbHguenter@pocoproject.org

"Without a good library, most interesting tasks are hard to do in C++;

but given a good library, almost any task can be made easy."

Bjarne Stroustrup(designer and original implementor of C++)

The POCO C++ Libraries are...

> a collection of C++ class libraries, similar in concept to the Java Class Library, the .NET Framework or Apple's Cocoa;

> focused on "internet-age" network-centric applications;

> written in efficient, modern ANSI/ISO Standard C++ and based on the C++ Standard Library/STL;

> highly portable and available on many different platforms;

> Open Source, licensed under the Boost Software License,

> and thus completely free for both commercial and non-commercial use.

POSIX, WIN32, other (RT)OS API

Foundation

XML

C++ and C Standard Libraries

Appl

icat

ion

Crypto

Util

NetSSL

Data

SQLi

te

OD

BC

MyS

QL

Zip

Net

Tools & Utilities

POCO Objectives and Mission

> POCO is a powerful, yet easy to use platform to build your applications upon

> POCO allows you to build highly portable applications (write once – compile and run anywhere)

> POCO is modular and scalable from embedded to enterprise applications (you only pay for what you use)

> POCO provides consistent, comprehensive and comprehensible programming interfaces

> POCO is written in fast, efficient C++

Objectives and Mission (cont'd)

> POCO favors simplicity over complexity ("as simple as possible, but not simpler")

> POCO aims for consistency in design, coding style and documentation

> POCO emphasizes source code quality, in terms of readability, comprehensiveness, consistency, style and testability

> POCO aims to make C++ programming fun again

Guiding Principles

> Strong focus on code quality, style, consistency and code readability –all code must satisfy our coding styleguide(and it works – we frequently get compliments on our code quality)

> Strong focus on tests (automated unit tests with high coverage)

> Favor pragmatic and elegant design over "solving all the worlds problems" (if we can satisfy 95 % of all use cases with an elegant solution, and the remaining 5 % would require an overly complex design, we focus on the 95 %)

> Build on top of solid foundations – use existing proven C libraries (e.g., expat, zlib, PCRE, SQLite) where it makes sense

History & Milestones

08.2004project started

05.2006> 1000 downloads/month

03.2005!rst contributor

11.2006!rst major commercial user (> 100 devs)03.2006

release 1.1applied informatics founded

02.2005!rst release on sourceforge

01.2006release 1.0

06.2006boost license, new website

History & Milestones

01.2011> 5000 downloads/month

05.2012joined wg21> 5500 downloads/month

01.2007> 2000 downloads/month

05.2007relese 1.3

12.2010release 1.4

08.2012work on 1.5/1.6

12.2008bjarne mentions poco in interview

Windows XP/Vista/7/Server

OS X

Linux

Server/Desktop Mobile/Embedded

WindowsEmbedded/Compact (CE)

iOS

Embedded Linux

POCO – Scalability Embedded

> POCO is well-suited for embedded systems running under Embedded Linux, Windows Embedded CE or QNX.

> POCO-based applications (using the built-in web server) run on 75 MHz ARM9-based Linux systems (uClibc) with 8 MB RAM and 4 MB Flash (e.g. Digi Connect ME 9210).

> A typical POCO-based application using theweb server from the Net library has a staticallylinked size of 2 MB and uses about 2 – 3 MB of RAM.

> Typical mid-ranged embedded platforms (32 – 64 MB RAM, 16 – 64 MB Flash, 180 MHz ARM9) provide plenty of resources even for more complex applications (using OSP and Remoting).

POCO and Embedded – Code Size

> POCO (including SSL/Crypto) + OSP + Remoting libraries use less than 4 MB of Flash storage (compressed jffs2 or squashfs).

> The RAM overhead for such an application is below 8 MB.

guenter@cis-digiel:~/ws/poco-1.3$ ls -l lib/Linux/armv5tejl/*.so.*-rwxr-xr-x 1 guenter guenter  103616 2009-03-03 18:48 lib/Linux/armv5tejl/libPocoBinary.so.6-rwxr-xr-x 1 guenter guenter  103752 2009-03-03 19:12 lib/Linux/armv5tejl/libPocoCrypto.so.6-rwxr-xr-x 1 guenter guenter 1582720 2009-03-03 18:43 lib/Linux/armv5tejl/libPocoFoundation.so.6-rwxr-xr-x 1 guenter guenter  907192 2009-03-03 18:47 lib/Linux/armv5tejl/libPocoNet.so.6-rwxr-xr-x 1 guenter guenter  293960 2009-03-03 19:11 lib/Linux/armv5tejl/libPocoNetSSL.so.6-rwxr-xr-x 1 guenter guenter  685008 2009-03-03 18:54 lib/Linux/armv5tejl/libPocoOSP.so.2-rwxr-xr-x 1 guenter guenter  196264 2009-03-03 18:48 lib/Linux/armv5tejl/libPocoRemoting.so.6-rwxr-xr-x 1 guenter guenter  182932 2009-03-03 18:48 lib/Linux/armv5tejl/libPocoSoapLite.so.6-rwxr-xr-x 1 guenter guenter  281048 2009-03-03 18:45 lib/Linux/armv5tejl/libPocoUtil.so.6-rwxr-xr-x 1 guenter guenter  577588 2009-03-03 18:44 lib/Linux/armv5tejl/libPocoXML.so.6-rwxr-xr-x 1 guenter guenter  353312 2009-03-03 18:54 lib/Linux/armv5tejl/libPocoZip.so.6

POCO and Applied Informatics

> Applied Informatics provides project infrastructure and leads the open source project.

> Professional, commercial support and training.

> Additional C++ libraries and tools.

POSIX, WIN32, other (RT)OS API

POCO C++ Libraries(Foundation, XML, Crypto, Net, NetSSL, Data, Util, Zip)

Remoting

Code Generator

C++ and C Standard Libraries

Appl

icat

ion

Binary SOAP

OSP Universal Plug and Play

Bundle Creator

Standard Services

Commercial Open Source Third party/customer-specific

Fast Infoset ZeroconfUPnP Core

HTTPMU, SSDP

SOAP, GENA

Devices & Services

Device Management

Roadmap

08.2012release 1.4.4production releasebug!xes, minor new features

11.2012release 1.6production releasebased on 1.5 dev branch

06.2013release 2.0c++11 alignment

09.2012release 1.5development releasenew data librarymajor new features

01.2013release 1.4.5bug!xes

Getting Started

http://pocoproject.org/download

> Source packages for Windows have CR-LF line endings and are in Zip format.

> Source packages for other platforms have LF line endings and are in .tar.gz format.

External Dependencies

> Basic Edition (only Foundation, XML, Util, Net) has no external dependencies.

> Complete Edition needs third-party libraries:

> OpenSSL(for Crypto and NetSSL)

> ODBC(for Data/ODBC)

> MySQL Client(for Data/MySQL)

External Dependencies: OpenSSL

> needed by Crypto and NetSSL libraries

> integrated in Mac OS X and most Linux distributions

> alternatively, build from source (http://openssl.org)

> Windows

> use installer from Shining Light Productionshttp://www.slproweb.com/products/Win32OpenSSL.html

> or build from source

External Dependencies: ODBC

> needed by Data/ODBC

> part of the Windows SDK

> Mac OS X: includes iodbc

> Linux/other Unix platforms:get unixodbc or iodbc.

External Dependencies: MySQL

> needed by Data/MySQL

> get from http://dev.mysql.com/downloads/

> or use Linux packagesudo apt-get install libmysqlclient-dev

Building on Windows

> Source code distribution includes Visual Studio solutions and project files for:

> Visual Studio .NET 2003

> Visual Studio 2005

> Visual Studio 2008 (32 and 64-bit, Windows CE)

> Visual Studio 2010/2012 (32 and 64-bit)

> Build Script buildwin.cmd for command-line batch builds

Building on Windows: Configurations

debug release

static_md PocoFoundationmdd.lib PocoFoundationmd.lib

static_mt PocoFoundationmtd.lib PocoFoundationmt.lib

shared PocoFoundationd.dll PocoFoundation.dll

Build Results

Building on Windows: Configurations

debug release

static_md msvcpXXd.dllmsvcrXXd.dll

msvcpXX.dllmsvcrXX.dll

static_mt – –

shared msvcpXXd.dllmsvcrXXd.dll

msvcpXX.dllmsvcrXX.dll

Runtime Dependencies

Building on Windows: Build Script

> buildwin.cmd builds all libraries, testsuites and (optionally) samples

> arguments specify Visual Studio version, build configuration and platform

> External Dependencies (OpenSSL, etc.):

> either add search paths to INCLUDE and LIB environment vars

> or edit buildwin.cmd and add search paths

Building on Windows: Build Script Examples

> build everything (Visual Studio 2008)buildwin 90 build all both Win32 samples

> build 64-bit static libs, no samples (Visual Studio 2008)buildwin 90 build static_mt both x64 nosamplesImportant: run from Visual Studio 2008 x64 Cross Tools Command Prompt

> show all options – launch buildwin with no arguments

Building on Windows: Build Output

> Dynamic Link Libraries will be placed in:%POCO_BASE%\bin (32-bit)%POCO_BASE%\bin64 (64-bit)%POCO_BASE%\bin\%PLATFORM_NAME% (Windows CE)

> Static and import libraries will be placed in:%POCO_BASE%\lib (32-bit)%POCO_BASE%\lib64 (64-bit)%POCO_BASE%\lib\%PLATFORM_NAME% (Windows CE)

> Binaries go into:binbin\static_md (statically linked, multithreaded DLL, new in 1.4)bin\static_mt (statically linked, multithreaded, new in 1.4)

Building on Unix/Linux

> Unix/Linux platforms use a build system based on GNU Make

> can be used on Linux, Mac OS X, FreeBSD, QNX, Solaris, HP-UX, etc. (also Cygwin)

> supports cross-builds for Embedded Linux

> supports automatic computation of dependencies

> can be used for custom projects

> requires GNU Make 3.80 or newer

> configure script to simplify setup

Building on Unix/Linux

> $ ./configure$ make -s -j4

Building on Unix/Linux: Customizing

> Don't build samples and testsuites:./configure --no-samples --no-tests

> Don't build a specific library (Data/MySQL):./configure --omit=Data/MySQL

> Use a specific build configuration (cross build):./configure --config=iPhone

> Typical Embedded Linux build:./configure --config=DigiEL --poquito --static --no-samples --no-tests

> Show all options:./configure --help

Building on Unix/Linux: Build Output

> Shared and static libraries will be placed in:${POCO_BASE}/lib/${OSNAME}/${OSARCH}

> Examples:${POCO_BASE}/Linux/i686${POCO_BASE}/Linux/armv5tejl${POCO_BASE}/Darwin/x86_64

> Binaries go into:bin/${OSNAME}/${OSARCH}bin/${OSNAME}/${OSARCH}/static (statically linked, new in 1.4)

> Code for different architectures can be built within same source tree

Building on Unix/Linux: Environment

> Set environment variable POCO_BASE:export POCO_BASE=/ws/poco-1.4cd $POCO_BASE/XMLmake -s -j4

> Use a specific build configuration:export POCO_CONFIG=DigiEL

> Clean rebuild:make cleanmake -s -j4

Example

// hello.cpp

#include "Poco/Thread.h"#include "Poco/Runnable.h"#include <iostream>

class HelloThread: public Poco::Runnable{ void run() { for (int i = 0; i < 10; i++) { std::cout << "Hello, world!" << std::endl; } }};

int main(int argc, char** argv){ Poco::Thread thread; HelloThread hello; thread.start(hello); thread.join(); return 0;}

# Makefile

include $(POCO_BASE)/build/rules/global

objects = hello

target = hellotarget_libs = PocoFoundation

include $(POCO_BASE)/build/rules/exec

XML

XML Programming Interfaces

> POCO supports two standard interfaces for working with (reading and writing) XML data:

> The Simple API for XML, Version 2

> The Document Object Model

> There's also Poco::Util::XMLConfigurationfor the lazy ones ;-)

The Simple API for XML (SAX)

> SAX was originally a Java-only API for reading XML data.

> The API has been developed by a group of volunteers, not by an "official" standardization group.

> The current version of the API is 2.0.2 (since April 2004)

> POCO supports a C++ variant of the original Java API.

> For more information: http://www.saxproject.org

Event-driven Parsing

> SAX is an event-driven interface.

> The XML document is not loaded into memory as a whole for parsing.

> Instead, the parser scans the XML document, and for every XML construct (element, text, processing instruction, etc.) it finds, calls a certain member function of a handler object.

> SAX basically defines the interfaces of these handler objects, as well as the interface you use to start and configure the parser.

<?xml version="1.0"?><root>

<elem1> some text </elem1> <elem2 attr1="val2" attr2="val3"/>

</root>

startDocument()

startElement()

startElement()

characters()

endElement()

startElement()

endElement()

endElement()

endDocument()

SAX Interfaces

> Attributes(access attributes values by index or name)

> ContentHandler(startElement(), endElement(), characters(), ...)

> DeclHandler(partly supported for reporting entity declarations)

> DTDHandler(notationDecl(), unparsedEntityDecl())

> LexicalHandler(startDTD(), endDTD(), startCDATA(), endCDATA(), comment())

#include "Poco/SAX/ContentHandler.h"

class MyHandler: public Poco::XML::ContentHandler{public: MyHandler(); void setDocumentLocator(const Locator* loc); void startDocument(); void endDocument(); void startElement( const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes); void endElement( const XMLString& uri, const XMLString& localName, const XMLString& qname);

void characters(const XMLChar ch[], int start, int length); void ignorableWhitespace(const XMLChar ch[], int start, int len); void processingInstruction( const XMLString& target, const XMLString& data); void startPrefixMapping( const XMLString& prefix, const XMLString& uri); void endPrefixMapping(const XMLString& prefix); void skippedEntity(const XMLString& name);};

> XMLReader defines the interface of the parser.

> Methods for registering handlers(setContentHandler(), etc.)

> Methods for parser configuration:

> setFeature(), getFeature()e.g. for enabling/disabling namespaces support

> setProperty(), getProperty()e.g. for registering LexicalHandler, DeclHandler

SAX Parser Configuration

class MyHandler: public ContentHandler{

...};

MyHandler handler;SAXParser parser;parser.setFeature(XMLReader::FEATURE_NAMESPACES, true);parser.setFeature(XMLReader::FEATURE_NAMESPACE_PREFIXES, true);parser.setContentHandler(&handler);

try{ parser.parse(“test.xml”);}catch (Poco::Exception& e) { std::cerr << e.displayText() << std::endl;}

> The Document Object Model is an API specified by the World Wide Web Consortium (W3C)

> DOM uses a tree representation of the XML document

> The entire document has to be loaded into memory

> You can modify the XML document directly

The Document Object Model

<xml version="1.0"><root>

<elem1> some text </elem1> <elem2 attr1="val2" attr2="val3"/>

</root>

Document

Element

Text

Element ElementAttr

Attr

EventTarget

Node

Document Element ProcessingInstructionCharacterData

Text

CDATASection

Comment

Navigating the DOM

> Node has

> parentNode()

> firstChild(), lastChild()

> nextSibling(), previousSibling()

> NodeIterator for document-order traversal:nextNode(), previousNode()

> TreeWalker for arbitraty navigation:parentNode(), firstChild(), lastChild(), etc.

> NodeIterator and TreeWalker support node filtering

Memory Management in the DOM

> DOM Nodes are reference counted.

> If you create a new node and add it to a document, the document increments its reference count. So use an AutoPtr.

> You only get ownership of non-tree objects implementing the NamedNodeMap and NodeList interface.You have to release them (or use an AutoPtr).

> The document keeps ownership of nodes you remove from the tree. These nodes end up in the document's AutoReleasePool.

#include "Poco/DOM/DOMParser.h"#include "Poco/DOM/Document.h"#include "Poco/DOM/NodeIterator.h"#include "Poco/DOM/NodeFilter.h"#include "Poco/DOM/AutoPtr.h"#include "Poco/SAX/InputSource.h"

[...]

std::ifstream in(“test.xml”);Poco::XML::InputSource src(in);

Poco::XML::DOMParser parser;Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&src); Poco::XML::NodeIterator it(pDoc, Poco::XML::NodeFilter::SHOW_ELEMENTS);Poco::XML::Node* pNode = it.nextNode();while (pNode){ std::cout<<pNode->nodeName()<<":"<< pNode->nodeValue()<<std::endl; pNode = it.nextNode();}

> You can create an XML document by:

> building a DOM document from scratch, or

> by using the XMLWriter class,

> or by generating the XML yourself.

> XMLWriter supports a SAX interface for generating XML data.

Creating XML Documents

#include "Poco/DOM/Document.h"#include "Poco/DOM/Element.h"#include "Poco/DOM/Text.h"#include "Poco/DOM/AutoPtr.h" //typedef to Poco::AutoPtr#include "Poco/DOM/DOMWriter.h"#include "Poco/XML/XMLWriter.h"using namespace Poco::XML;

...

AutoPtr<Document> pDoc = new Document;AutoPtr<Element> pRoot = pDoc->createElement("root");pDoc->appendChild(pRoot);AutoPtr<Element> pChild1 = pDoc->createElement("child1");AutoPtr<Text> pText1 = pDoc->createTextNode("text1");pChild1->appendChild(pText1);pRoot->appendChild(pChild1);AutoPtr<Element> pChild2 = pDoc->createElement("child2");AutoPtr<Text> pText2 = pDoc->createTextNode("text2");pChild2->appendChild(pText2);pRoot->appendChild(pChild2);DOMWriter writer;writer.setNewLine("\n");writer.setOptions(XMLWriter::PRETTY_PRINT);writer.writeNode(std::cout, pDoc);

#include "Poco/XML/XMLWriter.h"#include "Poco/SAX/AttributesImpl.h"

...

std::ofstream str(“test.xml”)XMLWriter writer(str, XMLWriter::WRITE_XML_DECLARATION | XMLWriter::PRETTY_PRINT);writer.setNewLine("\n");writer.startDocument();AttributesImpl attrs;attrs.addAttribute("", "", "a1", "", "v1");attrs.addAttribute("", "", "a2", "", "v2");writer.startElement("urn:mynamespace", "root", "", attrs);writer.startElement("", "", "sub");writer.endElement("", "", "sub");writer.endElement("urn:mynamespace", "root", "");writer.endDocument();

> The DOM parser offers minimal XPath support for finding elements and attributes in DOM trees.

> Node* getNodeByPath(const XMLString& path) constsearches a node (element or attribute) based on a simplified XPath expression:

> elem1/elem2/elem3

> /elem1/elem2[1]

> /elem1/elem2[@attr1]

> //elem1/elem2[@attr1='value2']

DOM and XPath

<root> <elem1> <elem2 attr1="value1"> <elem3> </elem3> </elem2> <elem2 attr1="value2"> </elem2> </elem1></root>

Network and Internet

Socket

StreamSocket ServerSocket DatagramSocket RawSocket

DialogSocket

MulticastSocket

ICMPSocket

SecureServerSocket

SecureStreamSocket

WebSocket

The Socket Class

> Poco::Net::Socket is the root class of the sockets inheritance tree.

> It supports methods that can be used with some or all kinds of sockets, like:

> select() and poll()

> setting and getting various socket options (timeouts, buffer sizes, reuse address flag, etc.)

> getting the socket's local address and the peer's address

The StreamSocket Class

> Poco::Net::StreamSocket is used for creating a TCP connection to a server.

> Use sendBytes() and receiveBytes() to send and receive data, or use the Poco::Net::SocketStream class, which provides an I/O streams interface to a StreamSocket.

#include "Poco/Net/SocketAddress.h"#include "Poco/Net/StreamSocket.h"#include "Poco/Net/SocketStream.h"#include "Poco/StreamCopier.h"#include <iostream>

int main(int argc, char** argv){

Poco::Net::SocketAddress sa("www.appinf.com", 80);Poco::Net::StreamSocket socket(sa)Poco::Net::SocketStream str(socket);

str << "GET / HTTP/1.1\r\n" "Host: www.appinf.com\r\n" "\r\n";str.flush();

Poco::StreamCopier::copyStream(str, std::cout);

return 0;}

> Poco::Net::ServerSocket is used to create a TCP server socket.

> It is pretty low level.

> For an actual server, consider using the TCPServer or the Reactor framework.

The ServerSocket Class

#include "Poco/Net/ServerSocket.h"#include "Poco/Net/StreamSocket.h"#include "Poco/Net/SocketStream.h"#include "Poco/Net/SocketAddress.h"

int main(int argc, char** argv){

Poco::Net::ServerSocket srv(8080); // does bind + listen

for (;;){

Poco::Net::StreamSocket ss = srv.acceptConnection();Poco::Net::SocketStream str(ss);str << "HTTP/1.0 200 OK\r\n" "Content-Type: text/html\r\n" "\r\n" "<html><head><title>My 1st Web Server</title></head>" "<body><h1>Hello, world!</h1></body></html>" << std::flush;

}return 0;

}

> Poco::Net::TCPServer implements a multithreaded TCP server.

> The server uses a ServerSocket to accept incoming connections. You must put the ServerSocket into listening mode before passing it to the TCPServer.

> The server maintains a queue for incoming connections.

> A variable number of worker threads fetches connections from the queue to process them. The number of worker threads is adjusted automatically, depending on the number of connections waiting in the queue.

The TCPServer Framework

The TCPServer Framework (cont'd)

> The number of connections in the queue can be limited to prevent the server from being flooded with requests. Incoming connections that no longer fit into the queue are closed immediately.

> TCPServer creates its own thread that accepts connections and places them in the queue.

> TCPServer uses TCPServerConnection objects to handle a connection. You must create your own subclass of TCPServerConnection, as well as a factory for it. The factory object is passed to the constructor of TCPServer.

The TCPServer Framework (cont'd)

> Your subclass of TCPServerConnection must override the run() method. In the run() method, you handle the connection.

> When run() returns, the TCPServerConnection object will be deleted, and the connection closed.

> A new TCPServerConnection will be created for every accepted connection.

The HTTPServer Framework

> POCO contains a ready-to-use HTTP Server framework

> multithreaded

> HTTP 1.0/1.1

> authentication support

> cookie support

> HTTPS by using the NetSSL library

HTTPServer

> configurable multi-threading

> maximum number of threads

> uses thread pool

> queue size for pending connections

> similar to TCPServer

> expects a HTTPRequestHandlerFactory which creates HTTPRequestHandler based on the URI

HTTPRequestHandlerFactory

> manages all known HTTPRequestHandlers

> sole purpose is to decide which request handler will answer a request

> can be used to check cookies, authentication info but this is mostly done by the request handlers

Poco::UInt16 port = 9999; HTTPServerParams::Ptr pParams = new HTTPServerParams; pParams->setMaxQueued(100); pParams->setMaxThreads(16);

ServerSocket svs(port);

HTTPServer srv(new MyRequestHandlerFactory, svs, pParams);

// start the HTTPServer srv.start();

waitForTerminationRequest();

// Stop the HTTPServer srv.stop();

#include "Poco/Net/HTTPRequestHandlerFactory.h"#include "Poco/Net/HTTPServerRequest.h"#include "RootHandler.h"#include "DataHandler.h"

class MyRequestHandlerFactory: public Poco::Net::HTTPRequestHandlerFactory { public:

MyRequestHandlerFactory() {} Poco::Net::HTTPRequestHandler* createRequestHandler(

const Poco::Net::HTTPServerRequest& request){

if (request.getURI() == "/") return new RootHandler;

else return new DataHandler;

} };

> created by the server

> passed as parameter to the HTTPRequestHandler/-Factory

> contains URI

> cookies

> authentification information

> HTML form data

HTTPServerRequest

HTTPServerResponse

> created by the server but initialized by the request handler

> sets:

> cookies

> content type of the answerresponse.setContentType("text/html");

> either (a) the length of the content or (b) chunked transfer encodingresponse.setContentLength(1024);response.setChunkedTransferEncoding(true);

HTTPServerResponse (cont)

> set response typeresponse.setStatus[AndReason]( HTTPResponse::HTTP_OK); // defaultresponse.setStatus[AndReason]( HTTPResponse::HTTP_UNAUTHORIZED)

> after response is fully configured, send the headerstd::ostream& out = response.send();

> if required, write data content to the returned stream

> send() must be invoked exactly once!

class RootHandler: public Poco::Net::HTTPRequestHandler{ public:

void handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)

{ Application& app = Application::instance(); app.logger().information("Request from "

+ request.clientAddress().toString()); response.setChunkedTransferEncoding(true); response.setContentType("text/html");

std::ostream& ostr = response.send(); ostr << "<html><head>" "<title>HTTP Server powered by POCO C++ Libraries</title>" "</head>"; ostr << "<body>"; ...ostr << "</body></html>";

};

> Support for handling cookies is provided by the Poco::Net::HTTPCookie class, as well as by the Poco::Net::HTTPRequest and Poco::Net::HTTPResponse classes.

Handling Cookies

// set cookie in responsePoco::Net::HTTPCookie cookie(“name”, “Peter”); cookie.setPath(“/”); cookie.setMaxAge(3600); // 1 hour response.addCookie(cookie);

// extract cookie from requestPoco::Net::NameValueCollection cookies; request.getCookies(cookies); Poco::Net::NameValueCollection::ConstIterator it = cookies.find(“name”); std::string userName;if (it != cookies.end())

userName = it->second;

Handling Credentials

void handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)

{ if (!request.hasCredentials()) {

response.requireAuthentication("My Realm");response.setContentLength(0);response.send(); return;

}else {

Poco::Net::HTTPBasicCredentials cred(request); const std::string& user = cred.getUsername(); const std::string& pwd = cred.getPassword(); [...]

}}

HTMLForm

> helper class to handle HTML form data

> to handle file uploads (POST with attachments) you must combine it with a Poco::Net::PartHandler

MyPartHandler myHandler;Poco::Net::HTMLForm form(request, request.stream(), myHandler);

Poco::Net::HTMLForm form(request); form[“entry1”] == “somedata”;

#include “Poco/Net/PartHandler.h”#include “Poco/Net/MessageHeader.h”

class MyPartHandler: public Poco::Net::PartHandler { public:

void handlePart(const Poco::Net::MessageHeader& header, std::istream& stream) {

_disp = header["Content-Disposition"]; _type = header["Content-Type"];

// read from stream and do something with it }

private:std::string _disp;std::string _type;

};

> Poco::Net::HTTPClientSession

> allows you set GET/POST

> authentication information

> proxy support

> Poco::Net::HTTPStreamFactory and Poco::StreamCopier if you only want to download something

HTTP Client

using namespace Poco::Net;

HTTPClientSession s("www.somehost.com"); //s.setProxy("localhost", srv.port()); HTTPRequest request(HTTPRequest::HTTP_GET, "/large"); HTMLForm form; form.add(“entry1”, “value1”); form.prepareSubmit(request); s.sendRequest(request);

HTTPResponse response; std::istream& rs = s.receiveResponse(response); StreamCopier::copyStream(rs, std::cout);

> Allows to write HTML (or other) files with embedded C++ code.(similar to PHP, JSP, ASP, etc.)

> Compiles pages into header and implementation file containing a Poco::Net::HTTPRequestHandler subclass.

> Makes it a lot easier to implement web servers.

PageCompiler

<%@ page class="TimeHandler" %>

<%@ impl include="Poco/DateTime.h" include="Poco/DateTimeFormatter.h"%>

<% Poco::DateTime now; std::string dt(Poco::DateTimeFormatter::format(now, "%W, %e %b %y %H:%M:%S %Z"));%>

<html><head><title>HTTPTimeServer powered by POCO C++ Libraries and PageCompiler</title><meta http-equiv="refresh" content="1"></head><body><p style="text-align: center; font-size: 48px;"><%= dt %></p></body></html>

> Poco::URIStreamOpener is used to create and open input streams for resources identified by URIs.

> #include "Poco/URIStreamOpener.h"

> For every URI scheme used, a subclass of Poco::URIStreamFactory must be registered.

> POCO provides stream factories for files, HTTP, HTTPS and FTP resources.

URIStreamOpener

#include "Poco/URIStreamOpener.h"#include "Poco/Net/HTTPStreamFactory.h"#include "Poco/Net/FTPStreamFactory.h"#include <memory>

int main(int argc, char** argv){

Poco::Net::HTTPStreamFactory::registerFactory();Poco::Net::FTPStreamFactory::registerFactory();

Poco::URIStreamOpener& opener = Poco::URIStreamOpener::defaultOpener();

std::unique_ptr<std::istream> istr1(opener.open("http://www.appinf.com/index.html")

);std::unique_ptr<std::istream> istr2(

opener.open("ftp://ftp.appinf.com/pub/poco/poco-1.4.3p1.tar.gz"));std::unique_ptr<std::istream> istr3(

opener.open("file:///usr/include/stdio.h"));

return 0;}

SQL Database Access

Poco::Data Features

> Transactions

> all builtin C++ data types (and more) supported:bool, short, int, long, Poco::Int64, std::string, Poco::Data::BLOB

> container support: vector, map, multimap, set, multiset, list

> complex type support: map classes to database tables

> supports Oracle, DB2, SQLServer and PostgreSQL (using ODBC), SQLite and MySQL

> elegant, easy to use interface

#include "Poco/Data/Common.h"#include "Poco/Data/SQLite/Connector.h"#include <iostream>

using namespace Poco::Data;

void init(){ SQLite::Connector::registerConnector();}

void shutdown(){ SQLite::Connector::unregisterConnector();}

int main(int argc, char* argv[]){

init();

Session ses(SessionFactory::instance().create(

SQLite::Connector::KEY, "dummy.db")

);

int count = 0;

ses << "SELECT COUNT(*) FROM PERSON", into(count), now;

std::cout << "People in DB " << count;

shutdown();

return 0;}

Statement stmt(ses << "SELECT COUNT(*) FROM PERSON",into(count));stmt.execute();

std::string str;Statement insert(ses << "INSERT INTO Strings VALUES(?)", use(str));

insert.execute(); // inserts the empty string

str = "Hi";insert.execute(); // inserts "Hi"

std::set<std::string> setStr; // [...] init with 100s of stringsStatement bulk(ses << "INSERT INTO Strings VALUES(?)", use(setStr));bulk.execute();

> intowhere should we write data to

> usewhere should we read data from

> lowerLimit, upperLimit, limithow many rows should we fetch at least/at most

> rangedefines a range (lowerLimit, upperLimit)

> nowexecute the query immediately

Keywords

Session Pooling

> Creating a Session is a potentially expensive operation.(involving network activity, user authentication/authorization, etc.)

> A SessionPool stores Session objects for eventual later reuse.

> Unused sessions are closed automatically.

Complex Type Mapping

> You can create mappings from your own types to database tables.

> You do this by specializing the Poco::Data::TypeHandler template for your type.

> A generic way to access data in an SQL table (e.g., you don't know the exact schema)

> Find out about the columns in a table(name, type, size, etc.)

> Get the data from columns as DynamicAny

RecordSet

Session session("SQLite", "sample.db");Statement select(session);select << "SELECT * FROM Person";select.execute();

RecordSet rs(select);std::size_t cols = rs.columnCount();

for (std::size_t col = 0; col < cols; ++col){ std::cout << rs.columnName(col) << std::endl;}

bool more = rs.moveFirst();while (more){ for (std::size_t col = 0; col < cols; ++col) { std::cout << rs[col].convert<std::string>() << " "; } std::cout << std::endl; more = rs.moveNext();}

Q & A

Friday, August 31, 2–6pm

Plug and Play Tech Center, Sunnyvale, CA

Register and more info at pocodevconsv.eventbrite.com

POCODevConSiliconValley