Poco基础类型【转】

原文：http://www.cnblogs.com/zhihuichien/archive/2011/02/10/1951023.html
Poco实现了一组通用的C++类型，列举如下，以防再造轮子

Poco::Any

来自于Boost，保存任意类型的数据，并提供与其他类型数据之间的转换，转换时用Poco::AnyCast<>或Poco::RefAnyCast<>,如把数值转换成字符串，这个类的真实类型可以是一个复杂的类定义，不仅限于基本数据类型，如下例：

Any a = 13;

int i = AnyCast<int>(a);

std::string s = AnyCast<std::string>(a);

 

Poco::DynamicAny

提供了安全的数据转换功能，这个类主要解决的问题是保证数值类型与字符串类型在相互转化过程中保持精度。一个非常有用的功能是在字符串与数值之间的转换，也包括字符串、bool值、字符串、整数类型、泛点和双精度值之间的转换，也就是说配置文件中可以用字符串，用DynamicAny转化成具体的数值，或是将数值转换成字符串显示出来，如下例：

Poco::Int8 src = 32;

DynamicAny a1 = src;

std::string s1;

a1.convert(s1);

std::string s2 = a1.convert<std::string>();

assert (s1 == "32");

 

Poco::format

是一组C++版的sprintf，但生成的字符串是std::string，与标准库无缝衔接，这一组函数都得益于Poco::Any和Poco::DynamicAny才得以实现，但用时完全感觉不到这两个中间类型的存在。因为前面已介绍过，基本类型和标准库的类型可以实现与Poco::Any或Poco::DynamicAny之间的转化，在这两个类对象中保存信息，Poco::format实现时便利用了这些信息，同时实现了格式化输出的功能。

也就是说，Poco::format是Poco提供代替C的sprintf,而Poco::Any和Poco::DynamicAny部分的实现了sscanf的功能。

Poco::NumberFormatter包含专门将数值类型转化成字符串的一组函数，Poco::NumberParser正相反，从字符串中提取一个数值。

Poco::AtomicCounter

包装了操作系统的原子操作，用于实现引用计数。

Poco::AutoPtr<>、Poco::SharedPtr<>和Poco::RefCountedObject

Poco::AutoPtr<>管理实现了引用计数的对象，Poco::RefCountedObject实现了引用计数的接口，在Poco中被广泛的用做基类。如果一个类没有实现引用计数的接口，没有以Poco::RefCountedObject为基类，也可以用实现引用计数的功能，方法是用Poco::SharedPtr<>,这个智能指针实现了引用计数的功能，而且可以管理数组指针，只要在定义时指定为Poco::ReleaseArrayPolicy。

范例

执行完一项操作后，删除对象本身，下面一段代码，来自于Poco::ActiveRunnable的实现

void run()

{

　　ActiveRunnableBase::Ptr guard(this, false); // ensure automatic release when done

　　try

　　{

　　　　_result.data(new ResultType((_pOwner->*_method)(_arg)));

　　}

　　catch (Exception& e)

　　{

　　　　_result.error(e);

　　}

　　catch (std::exception& e)

　　{

　　　　_result.error(e.what());

　　}

　　catch (...)

　　{

　　　　_result.error("unknown exception");

　　}

　　_result.notify();

}

 

Poco::AutoReleasePool<>

管理实现了引用计数的对象，放入其中的对象可以一起delete掉，实现了垃圾回收。

Poco::Buffer<>

简化了申请内存的工作，为指定的类型分配一定大小的内存。

Poco::ByteOrder和Types.h

Types.h定义了诸如UInt8, Uint16等类型，作用相当于stdint.h

Poco::ByteOrder在大端、小端和网络传输的字节三者之间转换。

Poco::Checksum

用于计算CRC-32和Adler-32两种校验和

Poco::DynamicFactory<>

是一个即时可用的Factory，下图是该类的实现细节，使用该类的例子见Poco::LoggingFactory。

使用这组类的例子如下，典型的做法是在一个组件中提供一个DynamicFactory<Base>的实例，这样使用这个实例和一组以字符串形式的表达的类型就可以在很大程度上分离实现和接口。

namespace
{
    class Base
    {
    public:
        Base()
        {
        }

        virtual ~Base()
        {
        }
    };

    class A: public Base
    {
    };

    class B: public Base
    {
    };
}

////
DynamicFactory<Base> dynFactory;    
dynFactory.registerClass<A>("A");
dynFactory.registerClass<B>("B");
std::auto_ptr<A> a(dynamic_cast<A*>(dynFactory.createInstance("A")));
std::auto_ptr<B> b(dynamic_cast<B*>(dynFactory.createInstance("B")));
try
{
    dynFactory.registerClass<A>("A");
}
catch (Poco::ExistsException&)
{
}

dynFactory.unregisterClass("B");
try
{
    std::auto_ptr<B> b(dynamic_cast<B*>(dynFactory.createInstance("B")));
}
catch (Poco::NotFoundException&)
{
}

 

实现Factory, 用于生成一个基类下全部子类的Factory, 用类名注册

int main(int argc, char** argv)

{

　　DynamicFactory<Base> factory;

　　factory.registerClass<A>("A"); // creates Instantiator<A, Base>

　　factory.registerClass<B>("B"); // creates Instantiator<B, Base>

　　SharedPtr<Base> pA = factory.createInstance("A");

　　SharedPtr<Base> pB = factory.createInstance("B");

　　// you can unregister classes

　　factory.unregisterClass("B");

　　// you can also check for the existence of a class

　　bool haveA = factory.isClass("A"); // true

　　bool haveB = factory.isClass("B"); // false (unregistered)

　　bool haveC = factory.isClass("C"); // false (never registered)

　　return 0;

}

 

Poco::Environment

用于在不同平台上查询和设置环境变量

Poco::FPEnvironment

用于表示不同平台上的浮点数的精度。

Poco::MemoryPool

内存池，用于减小因频繁衍申请和释放内存带来的系统开销，一是可以直接使用，从内存池中取内存块或是放回内存块，二是C++的方式：为一个类实现operator new和operator delete，这也是Poco中使用该类的标准做法，如下

// HTTPChunkedOutputStream.h

class Net_API HTTPChunkedOutputStream: public HTTPChunkedIOS, public std::ostream

/// This class is for internal use by HTTPSession only.

{

　　public:

　　HTTPChunkedOutputStream(HTTPSession& session);

　　~HTTPChunkedOutputStream();

 

　　void* operator new(std::size_t size);

　　void operator delete(void* ptr);

 

　　private:

　　static Poco::MemoryPool _pool;

};

 

 

// HTTPChunkedOutputStream.cpp

Poco::MemoryPool HTTPChunkedOutputStream::_pool(sizeof(HTTPChunkedOutputStream));

 

void* HTTPChunkedOutputStream::operator new(std::size_t size)

{

　　return _pool.get();

}

void HTTPChunkedOutputStream::operator delete(void* ptr)

{

　　_pool.release(ptr);

}

也可以定义如下的allocator，供其他类使用

class Net_API HTTPBufferAllocator

/// A BufferAllocator for HTTP streams.

{

　　public:

　　static char* allocate(std::streamsize size);

　　static void deallocate(char* ptr, std::streamsize size);

 

　　enum

　　{

　　　　BUFFER_SIZE = 4096

　　};

 

　　private:

　　static Poco::MemoryPool _pool;

};

 

Poco::SingletonHolder<>

用于多线程条件上的单件模式，Poco中大量的使用了这个模板，实例如下：

TextEncodingManager& TextEncoding::manager()

{

　　static SingletonHolder<TextEncodingManager> sh;

　　return *sh.get();

}

 

Poco/String.h和Poco::StringTokenizer

String.h操作std::string的一组函数，Poco::StringTokenizer将一个字符串分解为多个词。

范型编程

Tuple.h，TypeList.h，NamedTuple.h

Void 是一个类型定义,不包含任何值,充当模板类的无意义参数