Example #1
0
int TextConverter::convert(const void* source, int length, std::string& destination, Transform trans)
{
	poco_check_ptr (source);

	int errors = 0;
	const unsigned char* it  = (const unsigned char*) source;
	const unsigned char* end = (const unsigned char*) source + length;
	unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
	
	while (it < end)
	{
		int n = _inEncoding.queryConvert(it, 1);
		int uc;
		int read = 1;

		while (-1 > n && (end - it) >= -n)
		{
			read = -n;
			n = _inEncoding.queryConvert(it, read);
		}

		if (-1 > n)
		{
			it = end;
		}
		else
		{
			it += read;
		}

		if (-1 >= n)
		{
			uc = _defaultChar;
			++errors;
		}
		else
		{
			uc = n;
		}

		uc = trans(uc);
		n = _outEncoding.convert(uc, buffer, sizeof(buffer));
		if (n == 0) n = _outEncoding.convert(_defaultChar, buffer, sizeof(buffer));
		poco_assert (n <= sizeof(buffer));
		destination.append((const char*) buffer, n);
	}
	return errors;
}
v8::Handle<v8::ObjectTemplate> ServiceListenerWrapper::objectTemplate(v8::Isolate* pIsolate)
{
	v8::EscapableHandleScope handleScope(pIsolate);
	Poco::JS::Core::PooledIsolate* pPooledIso = Poco::JS::Core::PooledIsolate::fromIsolate(pIsolate);
	poco_check_ptr (pPooledIso);
	v8::Persistent<v8::ObjectTemplate>& pooledObjectTemplate(pPooledIso->objectTemplate("OSP.ServiceListener"));
	if (pooledObjectTemplate.IsEmpty())
	{
		v8::Handle<v8::ObjectTemplate> objectTemplate = v8::ObjectTemplate::New(pIsolate);
		objectTemplate->SetInternalFieldCount(1);
		objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "dispose"), v8::FunctionTemplate::New(pIsolate, dispose));
		pooledObjectTemplate.Reset(pIsolate, objectTemplate);
	}
	v8::Local<v8::ObjectTemplate> serviceListenerTemplate = v8::Local<v8::ObjectTemplate>::New(pIsolate, pooledObjectTemplate);
	return handleScope.Escape(serviceListenerTemplate);
}
Example #3
0
void NotificationQueue::enqueueUrgentNotification(Notification* pNotification)
{
	poco_check_ptr (pNotification);
	FastMutex::ScopedLock lock(_mutex);
	if (_waitQueue.empty())
	{
		_nfQueue.push_front(pNotification);
	}
	else
	{
		WaitInfo* pWI = _waitQueue.front();
		_waitQueue.pop_front();
		pWI->pNf = pNotification;
		pWI->nfAvailable.set();
	}	
}
Example #4
0
void SocketChannel::init()
{
    delete _pSocket;

    if (isStream())
        _pSocket = new Poco::Net::StreamSocket();
    else if (isDatagram())
        _pSocket = new Poco::Net::DatagramSocket();
    else
        throw IllegalStateException();

    poco_check_ptr (_pSocket);

    open();
    if (!_pSocket) throw NullPointerException();
}
void PriorityNotificationQueue::enqueueNotification(Notification::Ptr pNotification, int priority)
{
    poco_check_ptr (pNotification);
    FastMutex::ScopedLock lock(_mutex);
    if (_waitQueue.empty())
    {
        _nfQueue.insert(NfQueue::value_type(priority, pNotification));
    }
    else
    {
        poco_assert_dbg(_nfQueue.empty());
        WaitInfo* pWI = _waitQueue.front();
        _waitQueue.pop_front();
        pWI->pNf = pNotification;
        pWI->nfAvailable.set();
    }
}
Example #6
0
Poco::Net::Socket& NetChannel::newSocket()
{
	delete _pSocket;

	if (isStream())
		_pSocket = new Poco::Net::StreamSocket();
	else if (isDatagram())
		_pSocket = new Poco::Net::DatagramSocket();
	else 
		throw InvalidArgumentException();

	poco_check_ptr (_pSocket);

	open();
	if (!_pSocket) throw NullPointerException();
	return *_pSocket;
}
Example #7
0
v8::Handle<v8::ObjectTemplate> HTMLFormWrapper::objectTemplate(v8::Isolate* pIsolate)
{
	v8::EscapableHandleScope handleScope(pIsolate);
	Poco::JS::Core::PooledIsolate* pPooledIso = Poco::JS::Core::PooledIsolate::fromIsolate(pIsolate);
	poco_check_ptr (pPooledIso);
	v8::Persistent<v8::ObjectTemplate>& pooledObjectTemplate(pPooledIso->objectTemplate("Net.HTMLForm"));
	if (pooledObjectTemplate.IsEmpty())
	{
		v8::Handle<v8::ObjectTemplate> objectTemplate = v8::ObjectTemplate::New();
		objectTemplate->SetInternalFieldCount(1);
		objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "hasField"), v8::FunctionTemplate::New(pIsolate, hasField));
		objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "getField"), v8::FunctionTemplate::New(pIsolate, getField));
		pooledObjectTemplate.Reset(pIsolate, objectTemplate);
	}
	v8::Local<v8::ObjectTemplate> formTemplate = v8::Local<v8::ObjectTemplate>::New(pIsolate, pooledObjectTemplate);
	return handleScope.Escape(formTemplate);
}
Example #8
0
void DOMWriter::writeNode(XMLByteOutputStream& ostr, const Node* pNode)
{
	poco_check_ptr (pNode);

	bool isFragment = pNode->nodeType() != Node::DOCUMENT_NODE;

	XMLWriter writer(ostr, _options, _encodingName, _pTextEncoding);
	writer.setNewLine(_newLine);
	
	DOMSerializer serializer;
	serializer.setContentHandler(&writer);
	serializer.setDTDHandler(&writer);
	serializer.setProperty(XMLReader::PROPERTY_LEXICAL_HANDLER, static_cast<LexicalHandler*>(&writer));
	if (isFragment) writer.startFragment();
	serializer.serialize(pNode);
	if (isFragment) writer.endFragment();
}
Example #9
0
v8::Handle<v8::ObjectTemplate> TimerWrapper::objectTemplate(v8::Isolate* pIsolate)
{
    v8::EscapableHandleScope handleScope(pIsolate);
    Poco::JS::Core::PooledIsolate* pPooledIso = Poco::JS::Core::PooledIsolate::fromIsolate(pIsolate);
    poco_check_ptr (pPooledIso);
    v8::Persistent<v8::ObjectTemplate>& pooledObjectTemplate(pPooledIso->objectTemplate("Core.Timer"));
    if (pooledObjectTemplate.IsEmpty())
    {
        v8::Handle<v8::ObjectTemplate> objectTemplate = v8::ObjectTemplate::New();
        objectTemplate->SetInternalFieldCount(1);
        objectTemplate->SetAccessor(v8::String::NewFromUtf8(pIsolate, "cancelled"), cancelled);
        objectTemplate->Set(v8::String::NewFromUtf8(pIsolate, "cancel"), v8::FunctionTemplate::New(pIsolate, cancel));
        pooledObjectTemplate.Reset(pIsolate, objectTemplate);
    }
    v8::Local<v8::ObjectTemplate> timerTemplate = v8::Local<v8::ObjectTemplate>::New(pIsolate, pooledObjectTemplate);
    return handleScope.Escape(timerTemplate);
}
Example #10
0
const std::string ChildrenFirstTraverse::next(Stack* itStack, bool* isFinished)
{
	// pointer mustn't point to NULL and iteration mustn't be finished
	poco_check_ptr(isFinished);
	poco_assert(!(*isFinished));

	std::stack<DirectoryIterator> it;

	//_depthDeterminer(it);

	// go deeper into not empty directory
	// (if depth limit allows)
	bool isDepthLimitReached = isFiniteDepth() && _depthDeterminer(*itStack) >= _maxDepth;
	if (!isDepthLimitReached && isDirectory(*itStack->top()))
	{
		DirectoryIterator child_it(itStack->top().path());
		// check if directory is empty
		if (child_it != _itEnd)
		{
			itStack->push(child_it);
			return child_it->path();
		}
	}

	++(itStack->top());

	poco_assert(!itStack->empty());
	// return up until there isn't right sibling
	while (itStack->top() == _itEnd)
	{
		itStack->pop();

		// detect end of traversal
		if (itStack->empty())
		{
			*isFinished = true;
			return _itEnd->path();
		}
		else
		{
			++(itStack->top());
		}
	}

	return itStack->top()->path();
}
Example #11
0
SOAPEnvelope::SOAPEnvelope(Document* pDoc, SOAPElement::Version version, bool header):
	SOAPElement(pDoc, version),
	_pHeader(0),
	_pBody(0)
{
	_pEnvelope = document().createElement(envelopeTag());
	Element* pEnv = _pEnvelope.get();
	poco_check_ptr(pEnv);
	pEnv->setAttribute("xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");
	pEnv->setAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
	pEnv->setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
	pEnv->setAttribute("xmlns:SE", "http://schemas.xmlsoap.org/soap/encoding/");
	document().appendChild(pEnv);

	if (header) _pHeader =  new SOAPHeader(&document());
	_pBody = new SOAPBody(&document());
}
Example #12
0
int SecureSocketImpl::completeHandshake()
{
	poco_assert (_pSocket->initialized());
	poco_check_ptr (_pSSL);

	int rc;
	do
	{
		rc = SSL_do_handshake(_pSSL);
	}
	while (rc <= 0 && _pSocket->lastError() == POCO_EINTR);
	if (rc <= 0) 
	{
		return handleError(rc);
	}
	_needHandshake = false;
	return rc;
}
Example #13
0
Bundle::Bundle(int id, BundleLoader& loader, BundleStorage::Ptr pStorage, const LanguageTag& language):
	_id(id),
	_state(BUNDLE_INSTALLED),
	_loader(loader),
	_pStorage(pStorage),
	_language(language),
	_pProperties(new BundleProperties),
	_pActivator(0)
{
	poco_check_ptr (_pStorage);
	
	loadManifest();
	loadProperties();
	
	_name      = _pProperties->expand(_pManifest->name());
	_vendor    = _pProperties->expand(_pManifest->vendor());
	_copyright = _pProperties->expand(_pManifest->copyright());
}
Example #14
0
TCPServerDispatcher::TCPServerDispatcher(TCPServerConnectionFactory::Ptr pFactory, Poco::ThreadPool& threadPool, TCPServerParams::Ptr pParams):
	_rc(1),
	_pParams(pParams),
	_currentThreads(0),
	_totalConnections(0),
	_currentConnections(0),
	_maxConcurrentConnections(0),
	_refusedConnections(0),
	_stopped(false),
	_pConnectionFactory(pFactory),
	_threadPool(threadPool)
{
	poco_check_ptr (pFactory);

	if (!_pParams)
		_pParams = new TCPServerParams;
	
	if (_pParams->getMaxThreads() == 0)
		_pParams->setMaxThreads(threadPool.capacity());
}
Example #15
0
BinaryWriter& BinaryWriter::operator << (const char* value)
{
	poco_check_ptr (value);
	
	if (_pTextConverter)
	{
		std::string converted;
		_pTextConverter->convert(value, static_cast<int>(std::strlen(value)), converted);
		UInt32 length = (UInt32) converted.size();
		write7BitEncoded(length);
		_ostr.write(converted.data(), length);
	}
	else
	{
		UInt32 length = static_cast<UInt32>(std::strlen(value));
		write7BitEncoded(length);
		_ostr.write(value, length);
	}
	return *this;
}
Example #16
0
void Notifier::sqliteUpdateCallbackFn(void* pVal, int opCode, const char* pDB, const char* pTable, Poco::Int64 row)
{
	poco_check_ptr(pVal);
	Notifier* pV = reinterpret_cast<Notifier*>(pVal);
	if (opCode == Utility::OPERATION_INSERT)
	{
		pV->_row = row;
		pV->insert.notify(pV);
	}
	else if (opCode == Utility::OPERATION_UPDATE)
	{
		pV->_row = row;
		pV->update.notify(pV);
	}
	else if (opCode == Utility::OPERATION_DELETE)
	{
		pV->_row = row;
		pV->erase.notify(pV);
	}
}
Example #17
0
void ZipStreamBuf::close()
{
    if (_ptrOBuf && _pHeader)
    {
        _ptrOBuf->flush();
        DeflatingOutputStream* pDO = dynamic_cast<DeflatingOutputStream*>(_ptrOBuf.get());
        if (pDO)
            pDO->close();
        if (_ptrOHelper)
        {
            _ptrOHelper->flush();
            _ptrOHelper->close();
        }
        _ptrOBuf = 0;
        poco_assert (*_pOstr);
        // write an extra datablock if required
        // or fix the crc entries
        if (_pHeader->searchCRCAndSizesAfterData())
        {
            ZipDataInfo info;
            info.setCRC32(_crc32.checksum());
            info.setUncompressedSize(_bytesWritten);
            info.setCompressedSize(static_cast<Poco::UInt32>(_ptrOHelper->bytesWritten()));
            _pOstr->write(info.getRawHeader(), static_cast<std::streamsize>(info.getFullHeaderSize()));
        }
        else
        {
            poco_check_ptr (_pHeader);
            _pHeader->setCRC(_crc32.checksum());
            _pHeader->setUncompressedSize(_bytesWritten);
            _pHeader->setCompressedSize(static_cast<Poco::UInt32>(_ptrOHelper->bytesWritten()));
            _pOstr->seekp(_pHeader->getStartPos(), std::ios_base::beg);
            poco_assert (*_pOstr);
            std::string header = _pHeader->createHeader();
            _pOstr->write(header.c_str(), static_cast<std::streamsize>(header.size()));
            _pOstr->seekp(0, std::ios_base::end);
            poco_assert (*_pOstr);
        }
        _pHeader = 0;
    }
}
Example #18
0
void NodeAppender::appendChild(Node* newChild)
{
	poco_check_ptr (newChild);
	poco_assert (_pLast == 0 || _pLast->_pNext == 0);

	if (static_cast<AbstractNode*>(newChild)->_pOwner != _pParent->_pOwner)
		throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
		
	if (newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE)
	{
		AbstractContainerNode* pFrag = static_cast<AbstractContainerNode*>(newChild);
		AbstractNode* pChild = pFrag->_pFirstChild;
		if (pChild)
		{
			if (_pLast)
				_pLast->_pNext = pChild;
			else
				_pParent->_pFirstChild = pChild;
			while (pChild)
			{
				_pLast = pChild;
				pChild->_pParent = _pParent;
				pChild = pChild->_pNext;
			}
			pFrag->_pFirstChild = 0;
		}
	}
	else
	{
		AbstractNode* pAN = static_cast<AbstractNode*>(newChild);
		pAN->duplicate();
		if (pAN->_pParent) 
			pAN->_pParent->removeChild(pAN);
		pAN->_pParent = _pParent;
		if (_pLast)
			_pLast->_pNext = pAN;
		else
			_pParent->_pFirstChild = pAN;
		_pLast = pAN;
	}
}
Example #19
0
Row& RecordSet::row(std::size_t pos)
{
	std::size_t rowCnt = rowCount();
	if (0 == rowCnt || pos > rowCnt - 1)
		throw RangeException("Invalid recordset row requested.");

	RowMap::const_iterator it = _rowMap.find(pos);
	Row* pRow = 0;
	std::size_t columns = columnCount();
	if (it == _rowMap.end())
	{
		if (_rowMap.size())
		{
			//reuse first row column names and sorting fields to save some memory 
			pRow = new Row(_rowMap.begin()->second->names(),
				_rowMap.begin()->second->getSortMap(),
				getRowFormatter());

			for (std::size_t col = 0; col < columns; ++col)
				pRow->set(col, value(col, pos));
		}
		else 
		{
			pRow = new Row;
			pRow->setFormatter(getRowFormatter());
			for (std::size_t col = 0; col < columns; ++col)
				pRow->append(metaColumn(static_cast<UInt32>(col)).name(), value(col, pos));
		}

		_rowMap.insert(RowMap::value_type(pos, pRow));
	}
	else 
	{
		pRow = it->second;
		poco_check_ptr (pRow);
	}

	return *pRow;
}
Example #20
0
int TextIterator::operator * () const
{
	poco_check_ptr (_pEncoding);
	poco_assert (_it != _end);
	
	unsigned char c = (unsigned char) *_it;
	int n = _pEncoding->characterMap()[c];
	if (n >= -1)
		return n;
	else
	{
		poco_assert_dbg (n >= -TextEncoding::MAX_SEQUENCE_LENGTH);
		unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
		unsigned char* p = buffer;
		std::string::const_iterator it = _it;
		while (n < 0 && it != _end) { *p++ = *it++; ++n; }
		if (n == 0)
			return _pEncoding->convert(buffer);
		else
			return -1;
	}
}
Example #21
0
void UnicodeConverter::toUTF16(const char* utf8String, int length, std::wstring& utf16String)
{
	poco_check_ptr (utf8String);

	utf16String.clear();

	UTF8Encoding utf8Encoding;
	UTF16Encoding utf16Encoding;
	const unsigned char* it  = (const unsigned char*) utf8String;
	const unsigned char* end = (const unsigned char*) utf8String + length;
	
	while (it < end)
	{
		unsigned char c = *it;
		int n = utf8Encoding.characterMap()[c];
		int uc = '?';
		if (n == -1) 
		{
			++it;
		}
		else if (n >= 0)
		{
			uc = n;
			++it;
		}
		else
		{
			if (it - n <= end)
			{
				uc = utf8Encoding.convert(it);
				if (uc == -1) uc = '?';
			}
			it -= n;
		}
		utf16String += (wchar_t) uc; // TODO: surrogates
	}
}
Example #22
0
Node* AbstractContainerNode::removeChild(Node* oldChild)
{
	poco_check_ptr (oldChild);

	bool doEvents = events();
	if (oldChild == _pFirstChild)
	{
		if (doEvents)
		{
			static_cast<AbstractNode*>(oldChild)->dispatchNodeRemoved();
			static_cast<AbstractNode*>(oldChild)->dispatchNodeRemovedFromDocument();
		}
		_pFirstChild = _pFirstChild->_pNext;
		static_cast<AbstractNode*>(oldChild)->_pNext   = 0;
		static_cast<AbstractNode*>(oldChild)->_pParent = 0;
	}
	else
	{
		AbstractNode* pCur = _pFirstChild;
		while (pCur && pCur->_pNext != oldChild) pCur = pCur->_pNext;
		if (pCur)
		{
			if (doEvents)
			{
				static_cast<AbstractNode*>(oldChild)->dispatchNodeRemoved();
				static_cast<AbstractNode*>(oldChild)->dispatchNodeRemovedFromDocument();
			}
			pCur->_pNext = pCur->_pNext->_pNext;
			static_cast<AbstractNode*>(oldChild)->_pNext   = 0;
			static_cast<AbstractNode*>(oldChild)->_pParent = 0;
		}
		else throw DOMException(DOMException::NOT_FOUND_ERR);
	}
	oldChild->autoRelease();
	if (doEvents) dispatchSubtreeModified();
	return oldChild;
}
Example #23
0
int icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, const std::string::value_type* ptr)
{
	poco_check_ptr (ptr);
	std::string::size_type sz = str.size();
	if (pos > sz) pos = sz;
	if (pos + n > sz) n = sz - pos;
	std::string::const_iterator it  = str.begin() + pos; 
	std::string::const_iterator end = str.begin() + pos + n;
	while (it != end && *ptr)
	{
	std::string::value_type c1 = Ascii::toLower(*it);
	std::string::value_type c2 = Ascii::toLower(*ptr);
	if (c1 < c2)
		return -1;
	else if (c1 > c2)
		return 1;
	++it; ++ptr;
	}

	if (it == end)
		return *ptr == 0 ? 0 : -1;
	else
	return 1;
}
Example #24
0
File: Element.cpp Project: 119/vdc
Attr* Element::removeAttributeNode(Attr* oldAttr)
{
	poco_check_ptr (oldAttr);

	if (_pOwner->events()) 
		dispatchAttrModified(oldAttr, MutationEvent::REMOVAL, oldAttr->getValue(), EMPTY_STRING);

	if (oldAttr != _pFirstAttr)
	{
		Attr* pCur = _pFirstAttr;
		while (pCur->_pNext != oldAttr) pCur = static_cast<Attr*>(pCur->_pNext);
		if (pCur)
		{
			pCur->_pNext = static_cast<Attr*>(pCur->_pNext->_pNext);
		}
		else throw DOMException(DOMException::NOT_FOUND_ERR);
	}
	else _pFirstAttr = static_cast<Attr*>(_pFirstAttr->_pNext);
	oldAttr->_pNext   = 0;
	oldAttr->_pParent = 0;
	oldAttr->autoRelease();

	return oldAttr;
}
Example #25
0
HostEntry::HostEntry(struct hostent* entry)
{
	poco_check_ptr (entry);
	
	_name = entry->h_name;	
	char** alias = entry->h_aliases;
	if (alias)
	{
		while (*alias)
		{
			_aliases.push_back(std::string(*alias));
			++alias;
		}
	}
	char** address = entry->h_addr_list;
	if (address)
	{
		while (*address)
		{
			_addresses.push_back(IPAddress(*address, entry->h_length));
			++address;
		}
	}
}
Example #26
0
HostEntry::HostEntry(struct addrinfo* ainfo)
{
	poco_check_ptr (ainfo);
	
	for (struct addrinfo* ai = ainfo; ai; ai = ai->ai_next)
	{
		if (ai->ai_canonname)
		{
			_name.assign(ai->ai_canonname);
		}
		if (ai->ai_addrlen && ai->ai_addr)
		{
			switch (ai->ai_addr->sa_family)
			{
			case AF_INET:
				_addresses.push_back(IPAddress(&reinterpret_cast<struct sockaddr_in*>(ai->ai_addr)->sin_addr, sizeof(in_addr)));
				break;
			case AF_INET6:
				_addresses.push_back(IPAddress(&reinterpret_cast<struct sockaddr_in6*>(ai->ai_addr)->sin6_addr, sizeof(in6_addr), reinterpret_cast<struct sockaddr_in6*>(ai->ai_addr)->sin6_scope_id));
				break;
			}
		}
	}
}
int UTF8::icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, const std::string::value_type* ptr)
{
	poco_check_ptr (ptr);
	std::string::size_type sz = str.size();
	if (pos > sz) pos = sz;
	if (pos + n > sz) n = sz - pos;
	TextIterator uit(str.begin() + pos, str.begin() + pos + n, utf8); 
	TextIterator uend(str.begin() + pos + n);
	while (uit != uend && *ptr)
	{
		int c1 = Unicode::toLower(*uit);
		int c2 = Unicode::toLower(*ptr);
		if (c1 < c2)
			return -1;
		else if (c1 > c2)
			return 1;
		++uit; ++ptr;
	}
	
	if (uit == uend)
		return *ptr == 0 ? 0 : -1;
	else
		return 1;
}
Example #28
0
int TextIterator::operator * () const
{
    poco_check_ptr (_pEncoding);
    poco_assert (_it != _end);
    std::string::const_iterator it = _it;

    unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
    unsigned char* p = buffer;

    if (it != _end)
        *p++ = *it++;
    else
        *p++ = 0;

    int read = 1;
    int n = _pEncoding->queryConvert(buffer, 1);

    while (-1 > n && (_end - it) >= -n - read)
    {
        while (read < -n && it != _end)
        {
            *p++ = *it++;
            read++;
        }
        n = _pEncoding->queryConvert(buffer, read);
    }

    if (-1 > n)
    {
        return -1;
    }
    else
    {
        return n;
    }
}
Example #29
0
void ActiveDispatcher::start(ActiveRunnableBase::Ptr pRunnable)
{
	poco_check_ptr (pRunnable);

	_queue.enqueueNotification(new MethodNotification(pRunnable));
}
Example #30
0
ProcessHandle::ProcessHandle(ProcessHandleImpl* pImpl):
	_pImpl(pImpl)
{
	poco_check_ptr (_pImpl);
}