Top Qs
Timeline
Chat
Perspective

POCO C++ Libraries

From Wikipedia, the free encyclopedia

POCO C++ Libraries
Remove ads

The Portable Components (POCO) C++ Libraries are computer software, a set of class libraries for developing computer network-centric, portable applications in the programming language C++, and can supplement the C++ Standard Library. The libraries cover functions such as threads, thread synchronizing, file system access, streams, shared libraries and class loading, Internet sockets, and network communications protocols (HTTP, FTP, SMTP, etc.), and include an HTTP server, and an XML parser with SAX2 and DOM interfaces and SQL database access. The modular and efficient design and implementation makes the libraries well suited for embedded system development.

Quick facts Developers, Initial release ...

The libraries are free and open-source software distributed under the Boost Software License 1.0.

Remove ads

Overview

POCO is a set of C++ libraries providing users with library support similar to that found in other development environments, like the Java Class Library, .NET Framework, or Apple's Cocoa. POCO is centered on network-centric application domains and developed with modern ANSI/ISO Standard C++ and C++ Standard Library facilities and techniques with emphasis on powerful functionality, ease of use, and consistency. Governed primarily by code quality, consistent style and unit testing, POCO is highly portable, and already ported to a variety of different platforms.

It describes itself as not a replacement to Boost, but rather can be used complementarily with Boost and the C++ standard library, stating "In regards to Boost, in spite of some functional overlapping, POCO is best thought of as a Boost complement (rather than replacement). Side-by-side use of Boost and POCO is a very common occurrence."[3]

Remove ads

Library

Summarize
Perspective

One design goal of many targeted decisions are based around POCO C++ providing an easy to use component library that works out of the box. As of 2017, the libraries are available in two package formats: the basic and the complete editions. The complete edition covers NetSSL, Crypto, Zip, and Data abilities, among others. The basic edition does not, and thus eliminates dependence on external facilities such as OpenSSL, ODBC, and MySQL dependencies. Its namespace and module are both named Poco.

Being open source enables and encourages development of further library functions. Design and development of existing and upcoming library support is driven by the pragmatic needs of the user base. Library additions occur in a sandbox development environment and are reviewed and integrated into the main library releases as approved by the core development team with input from contributors.

POCO also provides a proprietary "POCOPRO C++ Frameworks" library offering web services frameworks, open service platform with web application servers, authentication with OAuth and one-time passwords, and Internet-of-Things edge computing with datapoint APIs and JavaScript engines, and remote access (HTTP, Secure Shell (SSH), Secure Copy Protocol (SCP), SSH File Transfer Protocol (SFTP)) and remote desktop through macchina.io.[4]

Library hierarchy

As of 2025, POCO C++ Libraries are split into five core libraries with optional add-on libraries available with each release. The design and hierarchy of POCO C++ is considered well designed.[5][6]

The component libraries cover the following areas that can be found in the basic edition:

Foundation (Poco)

  • Platform abstraction – Eases porting issues of fundamental types, etc.
  • Memory management – Resource Acquisition Is Initialization (RAII), smart pointers, reference counting garbage collection, etc.
  • String utilities
  • Error handling – Extended exception classes
  • Streams – Encoding and decoding and filtering support
  • Threads – Concurrent processing support
  • Date and time – Date and time support including formatting and high precision timers
  • File system – Abstracted file system support
  • Logging – Application and system logging, filtering and logging strategies
  • Processes – Interprocess communication and memory sharing
  • Shared libraries – Dynamic library support
  • Notifications – Abstracted notification support
  • Events – Abstracted event support and strategies
  • Text – Unicode encoding support
  • Regular expressions – Based on Perl compatible regular expression
  • URI – Universal Resource Identifier support
  • UUID – Universally Unique Identifiers support and generators
  • Cache support – Abstracted strategy support

Active Record (Poco::ActiveRecord)

Cryptography (Poco::Crypto)

Data (Poco::Data)

JSON (Poco::JSON)

  • APIs for reading and writing JSON

JWT (Poco::JWT)

MongoDB (Poco::MongoDB)

Networking (Poco::Net)

  • Sockets – Abstracted low level network support
  • Reactor pattern – Popular network abstraction pattern support
  • MIME messages – Encoding support
  • HTTP – High level HTTP support for client and servers
  • FTP – High level FTP support
  • Mail – POP3, SMTP stream based support
  • HTML – Form support

Prometheus (Poco::Prometheus)

  • APIs for interacting with the Prometheus event monitoring software
  • Counters, gauges, histograms

Redis (Poco::Redis)

  • APIs for interacting with the Redis (Remote Dictionary Server) software

Utility (Poco::Util)

XML (Poco::XML)

Zip (Poco::Zip)

Example

import Poco;

using Poco::ConsoleChannel;
using Poco::FormattingChannel;
using Poco::FileChannel;
using Poco::Logger;
using Poco::Message;
using Poco::PatternFormatter;
using Poco::SharedPtr;
 
int main(int argc, char* argv[]) {
    // set up two channel chains - one to the
    // console and the other one to a log file.
    SharedPtr<FormattingChannel> fcConsole(new PatternFormatter("%s:%p:%t"));
    fcConsole->setChannel(new ConsoleChannel());
    fcConsole->open();
 
    SharedPtr<FormattingChannel> fcFile(new PatternFormatter("%Y-%m-%d %H:%M:%S.%c %N[%P]:%s:%q:%t"));
    fcFile->setChannel(new FileChannel("sample.log"));
    fcFile->open();
 
    // create two Logger objects - one for
    // each channel chain.
    Logger& consoleLogger = Logger::create("ConsoleLogger", fcConsole, Message::PRIO_INFORMATION);
    Logger& fileLogger = Logger::create("FileLogger", fcFile, Message::PRIO_WARNING);
 
    // log some messages
    consoleLogger.error("An error message");
    fileLogger.error("An error message");
 
    consoleLogger.warning("A warning message");
    fileLogger.error("A warning message");
 
    consoleLogger.information("An information message");
    fileLogger.information("An information message");
 
    Logger::get("ConsoleLogger").error("Another error message");
 
    return 0;
}
Remove ads

Release history

Summarize
Perspective

POCO has undergone a long update history since its inception in 2004 and release in 2005.[7]

  • 2004 – Günter Obiltschnig began POCO by developing the class libraries because of being dissatisfied by what was available in C++ class libraries for network centric programming.
  • February 21, 2005 – The first public release on SourceForge, under the Sleepycat License, contained the Foundation and XML support libraries.
  • May 2005 – Aleksandar Fabijanic made the first contribution.
  • January 19, 2006 – POCO 1.0 was released, including the Net library.
  • July 2006 – POCO was relicensed under the Boost license.
  • August 2006 – POCO 1.2 was released, splitting the library namespaces.
  • May 2007 – POCO 1.3 was released, including the Data library, HashMap and HashSet support,
  • December 2010 – POCO 1.4 was released, including many improvements.
  • October 2012 – POCO 1.5 was released, adding a JSON library and CMake support.
  • December 2014 – POCO 1.6 was released, including the JSON and MongoDB libraries and many other improvements.
  • March 2016 – POCO 1.7 was released, including many improvements.
  • November 2017 – POCO 1.8 was released, introducing Unix domain sockets and XML stream parsers, and Zip64 support. The Redis library was added.
  • March 2018 – POCO 1.9 was released, including support for internationalized Domain Names and additions to supported text encodings.
  • January 2020 – POCO 1.10 was released, moving the minimum version to C++14, adding a JSON Web Token library and migrating from raw pointers to smart pointers.
  • June 2021 – POCO 1.11 was released, introducing the active record pattern framework.
  • July 2022 – POCO 1.12 was released, introducing the Prometheus library.
  • December 2023 – POCO 1.13 was released, moving the minimum version to C++17 and introducing support for a SQL parser.
  • December 2024 – POCO 1.14 was released, deprecating several old features and including Version 6 and 7 UUID support.

The upcoming release, POCO 1.15, will introduce asynchronous notifying and support for C++ modules.

Remove ads

Users

Users include:[8]

See also

References

External links

Loading related searches...

Wikiwand - on

Seamless Wikipedia browsing. On steroids.

Remove ads
Remove ads