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); }
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(); } }
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(); } }
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; }
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); }
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(); }
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); }
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(); }
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()); }
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; }
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()); }
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()); }
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; }
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); } }
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; } }
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; } }
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; }
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; } }
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 } }
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; }
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; }
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; }
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; } } }
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; }
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; } }
void ActiveDispatcher::start(ActiveRunnableBase::Ptr pRunnable) { poco_check_ptr (pRunnable); _queue.enqueueNotification(new MethodNotification(pRunnable)); }
ProcessHandle::ProcessHandle(ProcessHandleImpl* pImpl): _pImpl(pImpl) { poco_check_ptr (_pImpl); }