Reactorフレームワークを使うNetライブラリのサンプルとして、EchoServerプロジェクトがPOCOに付属しています。EchoServerプロジェクトを、Reactorフレームワークが提供するすべてのイベントハンドラをサポートするように改造してみます。

まずは、サンプルをそのままコンパイルして実行してみましょう。
$ EchoServer
これで、サーバが起動されたので、telnetでサーバと通信してみます。
$ telnet 127.0.0.1 9977
以下のように、接続したあと入力した文字をエコーすると思います。

$ telnet localhost 9977
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
hello
hello

それでは、何も入力しないで30秒経つとタイムアウトして接続を切断するように変更します。
変更したソースを以下に記載します。

#include "Poco/Net/SocketReactor.h"
#include "Poco/Net/SocketAcceptor.h"
#include "Poco/Net/SocketNotification.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/NObserver.h"
#include "Poco/Exception.h"
#include "Poco/Thread.h"
#include "Poco/Timespan.h"
#include "Poco/Util/ServerApplication.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"
#include <iostream>
#include <sstream>


using Poco::Net::SocketReactor;
using Poco::Net::SocketAcceptor;
using Poco::Net::ReadableNotification;
using Poco::Net::ShutdownNotification;
using Poco::Net::WritableNotification;
using Poco::Net::ErrorNotification;
using Poco::Net::TimeoutNotification;
using Poco::Net::IdleNotification;
using Poco::Net::ServerSocket;
using Poco::Net::StreamSocket;
using Poco::NObserver;
using Poco::AutoPtr;
using Poco::Thread;
using Poco::Timespan;
using Poco::Util::ServerApplication;
using Poco::Util::Application;
using Poco::Util::Option;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;


class EchoServiceHandler
{
public:
	EchoServiceHandler(StreamSocket& socket, SocketReactor& reactor)
		:_socket(socket)
		,_reactor(reactor)
		,_pBuffer(new char[BUFFER_SIZE])
		,_onWritableAdded(false)
		,_onTimeoutAdded(false)
	{
		Application& app = Application::instance();
		app.logger().information("Connection from " + socket.peerAddress().toString());

		_reactor.addEventHandler(_socket, NObserver<EchoServiceHandler, ReadableNotification>(*this, &EchoServiceHandler::onReadable));
		_reactor.addEventHandler(_socket, NObserver<EchoServiceHandler, ShutdownNotification>(*this, &EchoServiceHandler::onShutdown));
		_reactor.addEventHandler(_socket, NObserver<EchoServiceHandler, ErrorNotification>(*this, &EchoServiceHandler::onError));
		_reactor.addEventHandler(_socket, NObserver<EchoServiceHandler, IdleNotification>(*this, &EchoServiceHandler::onIdle));
	}
	
	~EchoServiceHandler()
	{
		Application& app = Application::instance();
		try
		{
			app.logger().information("Disconnecting " + _socket.peerAddress().toString());
		}
		catch (...)
		{
		}
		_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, ReadableNotification>(*this, &EchoServiceHandler::onReadable));
		_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, ShutdownNotification>(*this, &EchoServiceHandler::onShutdown));
		_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, ErrorNotification>(*this, &EchoServiceHandler::onError));
		_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, IdleNotification>(*this, &EchoServiceHandler::onIdle));
		if (_onWritableAdded)
			_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, WritableNotification>(*this, &EchoServiceHandler::onWritable));
		if (_onTimeoutAdded)
			_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, TimeoutNotification>(*this, &EchoServiceHandler::onTimeout));
		delete [] _pBuffer;
	}
	
	void onReadable(const AutoPtr<ReadableNotification>& pNf)
	{
		int n = _socket.receiveBytes(_pBuffer, BUFFER_SIZE);
		if (n > 0) {
			std::stringstream str;
			str.write(_pBuffer, n);
			_data = str.str();
			_reactor.addEventHandler(_socket, NObserver<EchoServiceHandler, WritableNotification>(*this, &EchoServiceHandler::onWritable));
			_onWritableAdded = true;
		}
		else {
			delete this;
		}
	}
	
	void onShutdown(const AutoPtr<ShutdownNotification>& pNf)
	{
		delete this;
	}
	
	void onWritable(const AutoPtr<WritableNotification>& pNf)
	{
		Application::instance().logger().information("onWritable called");
		std::string data = Poco::format("received %s", _data);
		_socket.sendBytes(data.data(), data.length());
		_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, WritableNotification>(*this, &EchoServiceHandler::onWritable));
		if (_onTimeoutAdded) {
			_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, TimeoutNotification>(*this, &EchoServiceHandler::onTimeout));
		}
		_reactor.addEventHandler(_socket, NObserver<EchoServiceHandler, TimeoutNotification>(*this, &EchoServiceHandler::onTimeout));
		_onTimeoutAdded = true;
	}

	void onError(const AutoPtr<ErrorNotification>& pNf)
	{
		Application::instance().logger().information("onError called");
	}

	void onTimeout(const AutoPtr<TimeoutNotification>& pNf)
	{
		Application::instance().logger().information("onTimeout called");
		_reactor.removeEventHandler(_socket, NObserver<EchoServiceHandler, TimeoutNotification>(*this, &EchoServiceHandler::onTimeout));
		delete this;
	}

	void onIdle(const AutoPtr<IdleNotification>& pNf)
	{
		Application::instance().logger().information("onIdle called");
	}

private:
	enum
	{
		BUFFER_SIZE = 1024
	};
	
	StreamSocket   _socket;
	SocketReactor& _reactor;
	char*          _pBuffer;
	std::string  	 _data;
	bool			 _onWritableAdded;
	bool			 _onTimeoutAdded;
};


class EchoServer: public Poco::Util::ServerApplication
	/// The main application class.
	///
	/// This class handles command-line arguments and
	/// configuration files.
	/// Start the EchoServer executable with the help
	/// option (/help on Windows, --help on Unix) for
	/// the available command line options.
	///
	/// To use the sample configuration file (EchoServer.properties),
	/// copy the file to the directory where the EchoServer executable
	/// resides. If you start the debug version of the EchoServer
	/// (EchoServerd[.exe]), you must also create a copy of the configuration
	/// file named EchoServerd.properties. In the configuration file, you
	/// can specify the port on which the server is listening (default
	/// 9977) and the format of the date/time string sent back to the client.
	///
	/// To test the EchoServer you can use any telnet client (telnet localhost 9977).
{
public:
	EchoServer(): _helpRequested(false)
	{
	}
	
	~EchoServer()
	{
	}

protected:
	void initialize(Application& self)
	{
		loadConfiguration(); // load default configuration files, if present
		ServerApplication::initialize(self);
	}
		
	void uninitialize()
	{
		ServerApplication::uninitialize();
	}

	void defineOptions(OptionSet& options)
	{
		ServerApplication::defineOptions(options);
		
		options.addOption(
			Option("help", "h", "display help information on command line arguments")
				.required(false)
				.repeatable(false));
	}

	void handleOption(const std::string& name, const std::string& value)
	{
		ServerApplication::handleOption(name, value);

		if (name == "help")
			_helpRequested = true;
	}

	void displayHelp()
	{
		HelpFormatter helpFormatter(options());
		helpFormatter.setCommand(commandName());
		helpFormatter.setUsage("OPTIONS");
		helpFormatter.setHeader("An echo server implemented using the Reactor and Acceptor patterns.");
		helpFormatter.format(std::cout);
	}

	int main(const std::vector<std::string>& args)
	{
		if (_helpRequested)
		{
			displayHelp();
		}
		else
		{
			// get parameters from configuration file
			unsigned short port = (unsigned short) config().getInt("EchoServer.port", 9977);
			
			// set-up a server socket
			ServerSocket svs(port);
			// set-up a SocketReactor...
			Timespan timeout(30000000);	// timeout is set to 30sec
			SocketReactor reactor(timeout);
			// ... and a SocketAcceptor
			SocketAcceptor<EchoServiceHandler> acceptor(svs, reactor);
			// run the reactor in its own thread so that we can wait for 
			// a termination request
			Thread thread;
			thread.start(reactor);
			// wait for CTRL-C or kill
			waitForTerminationRequest();
			// Stop the SocketReactor
			reactor.stop();
			thread.join();
		}
		return Application::EXIT_OK;
	}
	
private:
	bool _helpRequested;
};


int main(int argc, char** argv)
{
	EchoServer app;
	return app.run(argc, argv);
}

さて、このクラスローディングはPOCO独自の機能で、シェアドライブラリからプログラム実行時にクラスを動的生成することができます。
シェアドライブラリを追加・変更することで、プログラムの振る舞いを変更できますので、主な用途としてはプラグインが挙げられます。
クラスローディングのサンプルコードは、シェアドライブラリのコードとクラスローディングするコードの２つに分かれます。

シェアドライブラリ；TestPlugin.h

#ifndef TestPlugin_INCLUDED
#define TestPlugin_INCLUDED

#include "Poco/Foundation.h"

class TestPlugin
{
public:
	TestPlugin();
	virtual ~TestPlugin();
	virtual std::string name() const = 0;
};


#endif // TestPlugin_INCLUDED

シェアドライブラリ；TestPlugin.cpp

#include "TestPlugin.h"

TestPlugin::TestPlugin()
{
}

TestPlugin::~TestPlugin()
{
}

シェアドライブラリ；TestLibrary.cpp

#include "TestPlugin.h"
#include "Poco/ClassLibrary.h"
#include <iostream>


class PluginA: public TestPlugin
{
public:
	PluginA()
	{
	}
	
	~PluginA()
	{
	}
	
	std::string name() const
	{
		return "PluginA";
	}
};

POCO_BEGIN_MANIFEST(TestPlugin)
	POCO_EXPORT_CLASS(PluginA)
POCO_END_MANIFEST


void pocoInitializeLibrary()
{
	std::cout << "TestLibrary initializing" << std::endl;
}


void pocoUninitializeLibrary()
{
	std::cout << "TestLibrary uninitialzing" << std::endl;
}

実行コード：ClassLoaderSample.cpp

#include "Poco/ClassLoader.h"
#include "Poco/Manifest.h"
#include "Poco/Exception.h"
#include "Poco/Util/Application.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"
#include "Poco/Util/AbstractConfiguration.h"
#include <iostream>
#include "TestPlugin.h"

using Poco::ClassLoader;
using Poco::Manifest;
using Poco::SharedLibrary;
using Poco::AbstractMetaObject;
using Poco::NotFoundException;
using Poco::InvalidAccessException;
using Poco::Util::Application;
using Poco::Util::Option;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;
using Poco::Util::AbstractConfiguration;
using Poco::Util::OptionCallback;


class ClassLoaderSample: public Application
	/// This sample demonstrates some of the features of the Poco::ClassLoader class.
{
public:
	ClassLoaderSample(): _helpRequested(false)
	{
	}

protected:
	void initialize(Application& self)
	{
		loadConfiguration(); // load default configuration files, if present
		Application::initialize(self);
		// add your own initialization code here
	}

	void uninitialize()
	{
		// add your own uninitialization code here
		Application::uninitialize();
	}

	void reinitialize(Application& self)
	{
		Application::reinitialize(self);
		// add your own reinitialization code here
	}

	void defineOptions(OptionSet& options)
	{
		Application::defineOptions(options);

		options.addOption(
			Option("help", "h", "display help information on command line arguments")
				.required(false)
				.repeatable(false)
				.callback(OptionCallback<ClassLoaderSample>(this, &ClassLoaderSample::handleHelp)));
	}

	void handleHelp(const std::string& name, const std::string& value)
	{
		_helpRequested = true;
		displayHelp();
		stopOptionsProcessing();
	}

	void handleConfig(const std::string& name, const std::string& value)
	{
		loadConfiguration(value);
	}

	void displayHelp()
	{
		HelpFormatter helpFormatter(options());
		helpFormatter.setCommand(commandName());
		helpFormatter.setUsage("OPTIONS");
		helpFormatter.setHeader("A PropertySample application that demonstrates how to use Poco::ClassLoader.");
		helpFormatter.format(std::cout);
	}

	int main(const std::vector<std::string>& args)
	{
		if (!_helpRequested)
		{
			// ライブラリをロードします。
			std::string path = "libTestLibrary";
			path.append(SharedLibrary::suffix());

			ClassLoader<TestPlugin> cl;
			cl.loadLibrary(path);
			cl.findClass("PluginA");
			cl.findManifest(path);

			// ライブラリからインスタンスを作成します。
			TestPlugin* pPluginA = cl.classFor("PluginA").create();
			std::cout << pPluginA->name() << std::endl;

			// 後始末をします。
			delete pPluginA;
			cl.unloadLibrary(path);
		}

		return Application::EXIT_OK;
	}

private:
	bool _helpRequested;
};


POCO_APP_MAIN(ClassLoaderSample)

#include "Poco/Util/RegExpValidator.h"
#include "Poco/Util/IntValidator.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionException.h"
#include "Poco/AutoPtr.h"
#include "Poco/Util/Application.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"
#include "Poco/Util/AbstractConfiguration.h"
#include <iostream>

using Poco::Util::Validator;
using Poco::Util::RegExpValidator;
using Poco::Util::IntValidator;
using Poco::Util::Option;
using Poco::Util::InvalidArgumentException;
using Poco::AutoPtr;
using Poco::Util::Application;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;
using Poco::Util::AbstractConfiguration;
using Poco::Util::OptionCallback;


class ValidatorSample: public Application
	/// This sample demonstrates some of the features of the Poco::Util::Validator class.
{
public:
	ValidatorSample(): _helpRequested(false)
	{
	}

protected:
	void initialize(Application& self)
	{
		loadConfiguration(); // load default configuration files, if present
		Application::initialize(self);
		// add your own initialization code here
	}

	void uninitialize()
	{
		// add your own uninitialization code here
		Application::uninitialize();
	}

	void reinitialize(Application& self)
	{
		Application::reinitialize(self);
		// add your own reinitialization code here
	}

	void defineOptions(OptionSet& options)
	{
		Application::defineOptions(options);

		options.addOption(
			Option("help", "h", "display help information on command line arguments")
				.required(false)
				.repeatable(false)
				.callback(OptionCallback<ValidatorSample>(this, &ValidatorSample::handleHelp)));
	}

	void handleHelp(const std::string& name, const std::string& value)
	{
		_helpRequested = true;
		displayHelp();
		stopOptionsProcessing();
	}

	void handleConfig(const std::string& name, const std::string& value)
	{
		loadConfiguration(value);
	}

	void displayHelp()
	{
		HelpFormatter helpFormatter(options());
		helpFormatter.setCommand(commandName());
		helpFormatter.setUsage("OPTIONS");
		helpFormatter.setHeader("A PropertySample application that demonstrates how to use Poco::Util::PropertyFileConfiguration.");
		helpFormatter.format(std::cout);
	}

	int main(const std::vector<std::string>& args)
	{
		if (!_helpRequested)
		{
			// 正規表現でバリデーションします。
			Option strField("string field", "s");
			AutoPtr<Validator> pRegVal(new RegExpValidator("[0-9]+"));

			pRegVal->validate(strField, "0");
			pRegVal->validate(strField, "12345");

			try
			{
				pRegVal->validate(strField, "234asdf");
			}
			catch (InvalidArgumentException& exc)
			{
				std::cout << exc.message() << std::endl;
			}

			// 整数(最大値、最小値)でバリデーションします。
			Option intField("integer field", "i");
			AutoPtr<Validator> pIntVal(new IntValidator(0, 100));

			pIntVal->validate(intField, "0");
			pIntVal->validate(intField, "100");
			pIntVal->validate(intField, "55");

			try
			{
				pIntVal->validate(intField, "-1");
			}
			catch (InvalidArgumentException& exc)
			{
				std::cout << exc.message() << std::endl;
			}

			try
			{
				pIntVal->validate(intField, "101");
			}
			catch (InvalidArgumentException& exc)
			{
				std::cout << exc.message() << std::endl;
			}

			try
			{
				pIntVal->validate(intField, "asdf");
			}
			catch (InvalidArgumentException& exc)
			{
				std::cout << exc.message() << std::endl;
			}
		}

		return Application::EXIT_OK;
	}

private:
	bool _helpRequested;
};


POCO_APP_MAIN(ValidatorSample)

host=localhost
port=3306
user=test
password=test
db=test

実装ファイル：PropertySample.cpp

#include "Poco/AutoPtr.h"
#include "Poco/FileStream.h"
#include "Poco/Util/PropertyFileConfiguration.h"
#include "Poco/Util/Application.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"
#include "Poco/Util/AbstractConfiguration.h"
#include <vector>
#include <iostream>

using Poco::AutoPtr;
using Poco::FileInputStream;
using Poco::Util::PropertyFileConfiguration;
using Poco::Util::Application;
using Poco::Util::Option;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;
using Poco::Util::AbstractConfiguration;
using Poco::Util::OptionCallback;


class PropertySample: public Application
	/// This sample demonstrates some of the features of the Poco::Util::PropertyFileConfiguration class.
{
public:
	PropertySample(): _helpRequested(false)
	{
	}

protected:
	void initialize(Application& self)
	{
		loadConfiguration(); // load default configuration files, if present
		Application::initialize(self);
		// add your own initialization code here
	}

	void uninitialize()
	{
		// add your own uninitialization code here
		Application::uninitialize();
	}

	void reinitialize(Application& self)
	{
		Application::reinitialize(self);
		// add your own reinitialization code here
	}

	void defineOptions(OptionSet& options)
	{
		Application::defineOptions(options);

		options.addOption(
			Option("help", "h", "display help information on command line arguments")
				.required(false)
				.repeatable(false)
				.callback(OptionCallback<PropertySample>(this, &PropertySample::handleHelp)));
	}

	void handleHelp(const std::string& name, const std::string& value)
	{
		_helpRequested = true;
		displayHelp();
		stopOptionsProcessing();
	}

	void handleConfig(const std::string& name, const std::string& value)
	{
		loadConfiguration(value);
	}

	void displayHelp()
	{
		HelpFormatter helpFormatter(options());
		helpFormatter.setCommand(commandName());
		helpFormatter.setUsage("OPTIONS");
		helpFormatter.setHeader("A PropertySample application that demonstrates how to use Poco::Util::PropertyFileConfiguration.");
		helpFormatter.format(std::cout);
	}

	int main(const std::vector<std::string>& args)
	{
		if (!_helpRequested)
		{
			// プロパティファイルを開きます。
			FileInputStream istr("./mysql.properties");
			AutoPtr<PropertyFileConfiguration> pConf = new PropertyFileConfiguration(istr);

			// プロパティを取得します。
			std::cout << "host:" << pConf->getString("host") << std::endl;
			std::cout << "port:" << pConf->getString("port") << std::endl;
			std::cout << "user:" << pConf->getString("user") << std::endl;
			std::cout << "password:" << pConf->getString("password") << std::endl;
			std::cout << "db:" << pConf->getString("db") << std::endl;
		}

		return Application::EXIT_OK;
	}

private:
	bool _helpRequested;
};


POCO_APP_MAIN(PropertySample)

英語サイトですが、データベースフレームワークの使い方を丁寧に説明しています。
英語を苦にしない人は、上記サイトを見てもらえればOKです。
でも、これだけだとこの記事が寂しすぎるので、MySQLでのCRUDのサンプルプログラムを紹介しておきます。

#include "Poco/Tuple.h"
#include "Poco/Data/Common.h"
#include "Poco/Data/Session.h"
#include "Poco/Data/MySQL/Connector.h"
#include "Poco/Util/Application.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"
#include "Poco/Util/AbstractConfiguration.h"
#include <vector>
#include <iostream>

using namespace Poco::Data;

using Poco::Util::Application;
using Poco::Util::Option;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;
using Poco::Util::AbstractConfiguration;
using Poco::Util::OptionCallback;


typedef Poco::Tuple<std::string, std::string, int> Person;
typedef std::vector<Person> People;


class MysqlSample: public Application
	/// This sample demonstrates some of the features of the Poco::Data::MySQL class.
{
public:
	MysqlSample(): _helpRequested(false), _dbConnString("host=localhost;port=3306;user=test;password=test;db=test;compress=true;auto-reconnect=true")
	{
	}

protected:
	void initialize(Application& self)
	{
		loadConfiguration(); // load default configuration files, if present
		Application::initialize(self);
		// add your own initialization code here
	}

	void uninitialize()
	{
		// add your own uninitialization code here
		Application::uninitialize();
	}

	void reinitialize(Application& self)
	{
		Application::reinitialize(self);
		// add your own reinitialization code here
	}

	void defineOptions(OptionSet& options)
	{
		Application::defineOptions(options);

		options.addOption(
			Option("help", "h", "display help information on command line arguments")
				.required(false)
				.repeatable(false)
				.callback(OptionCallback<MysqlSample>(this, &MysqlSample::handleHelp)));
	}

	void handleHelp(const std::string& name, const std::string& value)
	{
		_helpRequested = true;
		displayHelp();
		stopOptionsProcessing();
	}

	void handleConfig(const std::string& name, const std::string& value)
	{
		loadConfiguration(value);
	}

	void displayHelp()
	{
		HelpFormatter helpFormatter(options());
		helpFormatter.setCommand(commandName());
		helpFormatter.setUsage("OPTIONS");
		helpFormatter.setHeader("A MysqlSample application that demonstrates how to use Poco::Data.");
		helpFormatter.format(std::cout);
	}

	int main(const std::vector<std::string>& args)
	{
		if (!_helpRequested)
		{
			// MySQLコネクタを登録します
			MySQL::Connector::registerConnector();

			// MySQLセッションを作成します。
			Session session(SessionFactory::instance().create(MySQL::Connector::KEY, _dbConnString));

			// もし存在していたら、サンプルテーブルを削除します。
			session << "DROP TABLE IF EXISTS Person", now;

			// サンプルテーブルを作成します。
			session << "CREATE TABLE Person (Name VARCHAR(30), Address VARCHAR(30), Age INTEGER)", now;

			// レコードを追加します。[C]
			Statement insert(session);
			Person person("Bart Simpson", "Springfield", 35);
			insert << "INSERT INTO Person VALUES(?, ?, ?)", use(person);
			insert.execute();

			person.set<0>("Lisa Obama");
			person.set<1>("Washington");
			person.set<2>(10);
			insert.execute();

			// レコードを照会します。[R]
			Statement select(session);
			People people;
			select << "SELECT Name, Address, Age FROM Person", into(people), now;
			for (unsigned int i = 0; i < people.size(); ++i)
			{
				std::cout << people.at(i).get<0>() << "," << people.at(i).get<1>() << "," << people.at(i).get<2>() << std::endl;
			}

			// レコードを更新します。[U]
			Statement update(session);
			person.set<2>(12);
			update << "UPDATE Person set Age = ? where Name = ?", use(person.get<2>()), use(person.get<0>()), now;

			// レコードを削除します。[D]
			Statement del(session);
			person.set<0>("Bart Simpson");
			del << "DELETE from Person where Name = ?", use(person.get<0>()), now;
		}

		return Application::EXIT_OK;
	}

private:
	bool _helpRequested;
	std::string _dbConnString;
};


POCO_APP_MAIN(MysqlSample)

POCOをXcodeで使うには、以下の３点が必要です。
・POCOをiPhone用にビルド＆デプロイする。
・Xcodeプロジェクト設定をPOCO用に変更する。
・Object-C++で、POCOを使う。

それでは、ボタンを押したときにPOCOサンプルのTimeServerから現在時刻を取得してラベルに表示するようにHello Worldプロジェクトを改造してみましょう。

1. 以下の手順で、POCOをiPhone用にビルド＆デプロイします。

$ ./configure --config=iPhone --omit=Crypto,NetSSL_OpenSSL,Data/ODBC,Data/MySQL
$ make -s
$ sudo make -s install

2. Xcodeプロジェクト設定画面を開いて(Project->Edit Project Settings)、Buildタブの設定を変更／追加します。

Other Linker Flags =	-l PocoFoundationd -l PocoNetd
Header Search Paths	= /usr/local/include
Library Search Paths	= /usr/local/lib
GCC_ENABLE_CPP_EXCEPTIONS = YES （追加）
GCC_ENABLE_CPP_RTTI = YES（追加）

3. Object-C++からはFacadeを経由してPOCOを使うものとしてHello Worldプロジェクトを改造します。

まず、MainView.mファイルをMainView.mmへ名前変更して、Object-C++用にします。
ラベルの文字列セットをFacadeメソッド呼び出しで行うように改造します。改造後のソースは以下のようになります。

#import "MainView.h"
#import "PocoFacade.h"

@implementation MainView

@synthesize mainText;

- (IBAction)showText {
//    mainText.text = @"Hello World";
	
	PocoFacade* facade = [[PocoFacade alloc] init];
    mainText.text = [facade getCurrentDate];
	[facade release];
}

@end

次にFacadeクラスのヘッダファイルと実装ファイルを追加します。追加したヘッダファイルと実装ファイルはそれぞれ以下のようになります。

ヘッダファイル；

#import <Foundation/Foundation.h>

class PocoFacadeImpl {
	
public:
	PocoFacadeImpl();
	void setCurrentDate(char* buffer);
	
};


@interface PocoFacade : NSObject {
	
@private
	PocoFacadeImpl *poco;
	
}

- (id)init;
- (void)dealloc;
- (NSString*)getCurrentDate;
@end

実装ファイル：

#import "PocoFacade.h"
#import <string>
#include "Poco/Net/DialogSocket.h"
#include "Poco/Net/SocketAddress.h"

using Poco::Net::DialogSocket;
using Poco::Net::SocketAddress;


PocoFacadeImpl::PocoFacadeImpl(){}

void PocoFacadeImpl::setCurrentDate(char* buffer) {
	DialogSocket ds;
	ds.connect(SocketAddress("localhost", 9911));
	std::string now;
	ds.receiveMessage(now);
	strncpy(buffer, now.c_str(), now.length());
}

@implementation PocoFacade
- (id)init {
   if (self = [super init]) {
        poco = new PocoFacadeImpl();
    }
	
    return self;
}

- (void)dealloc {
    delete poco;
    [super dealloc];
}

- (NSString*)getCurrentDate {
	char buffer[128];
	poco->setCurrentDate(buffer);
	return [NSString stringWithUTF8String:buffer];
}

@end

その方法はとても簡単で、SplitterChannelを使う設定をプロパティファイルに記述するだけです。プロパティファイルは指定しない場合は、実行ファイルと同じディレクトリの{実行ファイル名}.propertiesが読み込まれます。
プロパティファイルの記述例は以下のようになります。

logging.loggers.root.channel.class = ConsoleChannel
logging.loggers.app.name = Application
logging.loggers.app.channel = c0
logging.formatters.f1.class = PatternFormatter
logging.formatters.f1.pattern = %Y/%m/%d %H:%M:%S[%q] %s - %t
logging.channels.c0.class = SplitterChannel
logging.channels.c0.channel1 = c1
logging.channels.c0.channel2 = c2
logging.channels.c1.class = ConsoleChannel
logging.channels.c1.formatter = f1
logging.channels.c2.class = FileChannel
logging.channels.c2.path = ./Logging.log
logging.channels.c2.formatter = f1

ログ出力をするサンプルプログラムです。

#include "Poco/Util/Application.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"
#include "Poco/Util/AbstractConfiguration.h"
#include "Poco/AutoPtr.h"
#include <iostream>


using Poco::Util::Application;
using Poco::Util::Option;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;
using Poco::Util::AbstractConfiguration;
using Poco::Util::OptionCallback;
using Poco::AutoPtr;


class Logging: public Application
	/// This sample demonstrates some of the features of the Util::Application class,
	/// such as configuration file handling and command line arguments processing.
	///
	/// Try Logging --help (on Unix platforms) or Logging /help (elsewhere) for
	/// more information.
{
public:
	Logging(): _helpRequested(false)
	{
	}

protected:
	void initialize(Application& self)
	{
		loadConfiguration(); // load default configuration files, if present
		Application::initialize(self);
		// add your own initialization code here
	}

	void uninitialize()
	{
		// add your own uninitialization code here
		Application::uninitialize();
	}

	void reinitialize(Application& self)
	{
		Application::reinitialize(self);
		// add your own reinitialization code here
	}

	void defineOptions(OptionSet& options)
	{
		Application::defineOptions(options);

		options.addOption(
			Option("help", "h", "display help information on command line arguments")
				.required(false)
				.repeatable(false)
				.callback(OptionCallback<Logging>(this, &Logging::handleHelp)));

		options.addOption(
			Option("config-file", "f", "load configuration data from a file")
				.required(false)
				.repeatable(true)
				.argument("file")
				.callback(OptionCallback<Logging>(this, &Logging::handleConfig)));
	}

	void handleHelp(const std::string& name, const std::string& value)
	{
		_helpRequested = true;
		displayHelp();
		stopOptionsProcessing();
	}

	void handleConfig(const std::string& name, const std::string& value)
	{
		loadConfiguration(value);
	}

	void displayHelp()
	{
		HelpFormatter helpFormatter(options());
		helpFormatter.setCommand(commandName());
		helpFormatter.setUsage("OPTIONS");
		helpFormatter.setHeader("A logging application that demonstrates how to use logging.");
		helpFormatter.format(std::cout);
	}

	int main(const std::vector<std::string>& args)
	{
		if (!_helpRequested)
		{
			logger().trace("trace ログ出力です");
			logger().debug("debug ログ出力です");
			logger().information("info ログ出力です");
			logger().warning("warn ログ出力です");
			logger().error("error ログ出力です");
			logger().fatal("fatal ログ出力です");
		}
		return Application::EXIT_OK;
	}

private:
	bool _helpRequested;
};


POCO_APP_MAIN(Logging)

終わりに、ロギングについての参考情報のポインタを示します。
http://codezine.jp/article/detail/1901

ポーリングとロングポーリングについては、ググればサンプルソースがたくさん見つかりますが、ストリーミングについてはまったく見つかりませんでした。
ここでは、POCOを使ってストリーミングを実装していきます。

通信アプリケーション開発をサポートするために、POCOはNetライブラリを提供しています。
その中のPoco::Net::TCPServerクラスは、スレッドプールによるマルチスレッドのソケット通信処理を行うことができるので、ストリーミング実装にはこれを使うこととします。
TCPServerクラスを使うNetライブラリのサンプルとして、TimeServerプロジェクトがPOCOに付属しています。
TimeServerプロジェクトを、サーバの現在時刻をプッシュするように改造してみます。

まずは、サンプルをそのままコンパイルして実行してみましょう。
$ TimeServer
これで、サーバが起動されたので、telnetでサーバと通信してみます。
$ telnet 127.0.0.1 9911
以下のように、telnetにサーバの現在時刻が表示されて接続が切断されたと思います。

$ telnet 127.0.0.1 9911
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
2009-07-04T02:31:52Z
Connection closed by foreign host.

接続をつなぎっぱなしにしてサーバからプッシュできるように、TimeServerConnection#runで現在時刻を送信していたのを、イベントに現在時刻送信メソッドを登録した後サスペンドするように変更します。イベント発生は、便宜的に１秒間隔で発生するものとしました。
このイベントの実装には、FoundationライブラリのPoco::BasicEventクラスを使うだけです。
Poco::BasicEventは、C#プログラマにはおなじみのC#のイベント機能のC++実装です。

変更したソースを以下に記載します。プロトタイプとして動作を確認するレベルですが、POCOを使うことでスレッドプールでの通信という高度なアプリケーションが、このように簡単に作れてしまいます。

#include "Poco/Net/TCPServer.h"
#include "Poco/Net/TCPServerConnection.h"
#include "Poco/Net/TCPServerConnectionFactory.h"
#include "Poco/Net/TCPServerParams.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/Timestamp.h"
#include "Poco/DateTimeFormatter.h"
#include "Poco/DateTimeFormat.h"
#include "Poco/Exception.h"
#include "Poco/Util/ServerApplication.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"
#include <iostream>
#include "Poco/BasicEvent.h"
#include "Poco/Delegate.h"


using Poco::Net::ServerSocket;
using Poco::Net::StreamSocket;
using Poco::Net::TCPServerConnection;
using Poco::Net::TCPServerConnectionFactory;
using Poco::Net::TCPServer;
using Poco::Timestamp;
using Poco::DateTimeFormatter;
using Poco::DateTimeFormat;
using Poco::Util::ServerApplication;
using Poco::Util::Application;
using Poco::Util::Option;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;

static Poco::BasicEvent<int> push_event;

class PushRunnable: public Poco::Runnable
{
public:
	PushRunnable(): _stopped(false)
	{
	}

	void run()
	{
		int tmp = 0;
		while (!_stopped)
		{
			++tmp;
			push_event.notify(this, tmp);
			Poco::Thread::sleep(1000);
		}
	}

	void notify()
	{
		_stopped = true;
	}

private:
	bool _stopped;
};


class TimeServerConnection: public TCPServerConnection
	/// This class handles all client connections.
	///
	/// A string with the current date and time is sent back to the client.
{
public:
	TimeServerConnection(const StreamSocket& s, const std::string& format)
		: TCPServerConnection(s)
		, _format(format)
		, _stopped(false)
	{
	}
	
	void run()
	{
		Application& app = Application::instance();
		app.logger().information("Request from " + this->socket().peerAddress().toString());
		try
		{
			push_event += Poco::delegate(this, &TimeServerConnection::onPush);
			while (!_stopped)
			{
				Poco::Thread::sleep(1);
			}
		}
		catch (Poco::Exception& exc)
		{
			app.logger().log(exc);
		}
	}
	
	void onPush(const void* pSender, int& i)
	{
		try
		{
			Timestamp now;
			std::string dt(DateTimeFormatter::format(now, _format));
			dt.append("\r\n");
			socket().sendBytes(dt.data(), (int) dt.length());
		}
		catch (Poco::Exception& exc)
		{
			push_event -= Poco::delegate(this, &TimeServerConnection::onPush);
			_stopped = true;
			Application::instance().logger().log(exc);;
		}
	}

private:
	std::string _format;
	bool _stopped;
};


class TimeServerConnectionFactory: public TCPServerConnectionFactory
	/// A factory for TimeServerConnection.
{
public:
	TimeServerConnectionFactory(const std::string& format):
		_format(format)
	{
	}
	
	TCPServerConnection* createConnection(const StreamSocket& socket)
	{
		return new TimeServerConnection(socket, _format);
	}

private:
	std::string _format;
};


class TimeServer: public Poco::Util::ServerApplication
	/// The main application class.
	///
	/// This class handles command-line arguments and
	/// configuration files.
	/// Start the TimeServer executable with the help
	/// option (/help on Windows, --help on Unix) for
	/// the available command line options.
	///
	/// To use the sample configuration file (TimeServer.properties),
	/// copy the file to the directory where the TimeServer executable
	/// resides. If you start the debug version of the TimeServer
	/// (TimeServerd[.exe]), you must also create a copy of the configuration
	/// file named TimeServerd.properties. In the configuration file, you
	/// can specify the port on which the server is listening (default
	/// 9911) and the format of the date/time string sent back to the client.
	///
	/// To test the TimeServer you can use any telnet client (telnet localhost 9911).
{
public:
	TimeServer(): _helpRequested(false)
	{
	}
	
	~TimeServer()
	{
	}

protected:
	void initialize(Application& self)
	{
		loadConfiguration(); // load default configuration files, if present
		ServerApplication::initialize(self);
	}
		
	void uninitialize()
	{
		ServerApplication::uninitialize();
	}

	void defineOptions(OptionSet& options)
	{
		ServerApplication::defineOptions(options);
		
		options.addOption(
			Option("help", "h", "display help information on command line arguments")
				.required(false)
				.repeatable(false));
	}

	void handleOption(const std::string& name, const std::string& value)
	{
		ServerApplication::handleOption(name, value);

		if (name == "help")
			_helpRequested = true;
	}

	void displayHelp()
	{
		HelpFormatter helpFormatter(options());
		helpFormatter.setCommand(commandName());
		helpFormatter.setUsage("OPTIONS");
		helpFormatter.setHeader("A server application that serves the current date and time.");
		helpFormatter.format(std::cout);
	}

	int main(const std::vector<std::string>& args)
	{
		if (_helpRequested)
		{
			displayHelp();
		}
		else
		{
			// get parameters from configuration file
			unsigned short port = (unsigned short) config().getInt("TimeServer.port", 9911);
			std::string format(config().getString("TimeServer.format", DateTimeFormat::ISO8601_FORMAT));
			
			// set-up a server socket
			ServerSocket svs(port);
			// set-up a TCPServer instance
			TCPServer srv(new TimeServerConnectionFactory(format), svs);
			// start the TCPServer
			srv.start();

			// start push thread
			Poco::Thread thread;
			PushRunnable runnable;
			thread.start(runnable);

			// wait for CTRL-C or kill
			waitForTerminationRequest();
			// Stop the TCPServer
			srv.stop();
		}
		return Application::EXIT_OK;
	}
	
private:
	bool _helpRequested;
};


int main(int argc, char** argv)
{
	TimeServer app;
	return app.run(argc, argv);
}

終わりに、PUSH技術についての参考情報のポインタを示します。
http://www.atmarkit.co.jp/fjava/column/andoh/andoh38.html
http://feed.designlinkdatabase.net/feed/outsite_106801.aspx

上記については、ググれば見つかる情報はポインタを示すだけで、一般に周知されていなものについてのみ詳解していく予定です。

終わりに、POCOについての参考情報のポインタを示します。
http://pocoproject.org/
POCO Fanatic
http://codezine.jp/article/corner/46
http://d.hatena.ne.jp/tullio/20090617/1245252894