Document* DOMParser::parseString(const std::string& xml)
{
return parseMemory(xml.data(), xml.size());
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Create a data handler and connect it to the buffer
// (raw or normal)
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
ptr<handlers::dataHandler> buffer::getDataHandler(bool bWrite, bool bRaw, imbxUint32 size)
{
PUNTOEXE_FUNCTION_START(L"buffer::getDataHandler");
// Lock the object
///////////////////////////////////////////////////////////
lockObject lockAccess(this);
ptr<memory> localMemory(m_memory);
// If the object must be loaded from the original stream,
// then load it...
///////////////////////////////////////////////////////////
if(m_originalStream != 0 && (localMemory == 0 || localMemory->empty()) )
{
localMemory = ptr<memory>(memoryPool::getMemoryPool()->getMemory(m_originalBufferLength));
if(m_originalBufferLength != 0)
{
ptr<streamReader> reader(new streamReader(m_originalStream, m_originalBufferPosition, m_originalBufferLength));
std::vector<imbxUint8> localBuffer;
localBuffer.resize(m_originalBufferLength);
reader->read(&localBuffer[0], m_originalBufferLength);
if(m_originalWordLength != 0)
{
reader->adjustEndian(&localBuffer[0], m_originalWordLength, m_originalEndianType, m_originalBufferLength/m_originalWordLength);
}
localMemory->assign(&localBuffer[0], m_originalBufferLength);
}
}
// Reset the pointer to the data handler
///////////////////////////////////////////////////////////
ptr<handlers::dataHandler> handler;
// Allocate a raw data handler if bRaw==true
///////////////////////////////////////////////////////////
if(bRaw)
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerRaw);
handler = tempHandler;
}
else
{
// Retrieve an Application entity handler
///////////////////////////////////////////////////////////
if(m_bufferType=="AE")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringAE);
handler = tempHandler;
}
// Retrieve an Age string data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="AS")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringAS);
handler = tempHandler;
}
// Retrieve a Code string data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="CS")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringCS);
handler = tempHandler;
}
// Retrieve a Decimal string data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="DS")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringDS);
handler = tempHandler;
}
// Retrieve an Integer string data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="IS")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringIS);
handler = tempHandler;
}
// Retrieve a Long string data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="LO")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringLO);
handler = tempHandler;
}
// Retrieve a Long text data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="LT")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringLT);
handler = tempHandler;
}
// Retrieve a Person Name data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="PN")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringPN);
handler = tempHandler;
}
// Retrieve a Short string data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="SH")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringSH);
handler = tempHandler;
}
// Retrieve a Short text data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="ST")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringST);
handler = tempHandler;
}
// Retrieve an Unique Identifier data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="UI")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringUI);
handler = tempHandler;
}
// Retrieve an Unlimited text data handler
///////////////////////////////////////////////////////////
if(m_bufferType=="UT")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerStringUT);
handler = tempHandler;
}
// Retrieve an object handler
///////////////////////////////////////////////////////////
if(m_bufferType=="OB")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxUint8>);
handler = tempHandler;
}
// Retrieve a signed-byte object handler.
// Non standard: used by the images handler.
///////////////////////////////////////////////////////////
if(m_bufferType=="SB")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxInt8>);
handler = tempHandler;
}
// Retrieve an unknown object handler
///////////////////////////////////////////////////////////
if(m_bufferType=="UN")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxUint8>);
handler = tempHandler;
}
// Retrieve a WORD handler
///////////////////////////////////////////////////////////
if(m_bufferType=="OW")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxUint16>);
handler = tempHandler;
}
// Retrieve a WORD handler (AT)
///////////////////////////////////////////////////////////
if(m_bufferType=="AT")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxUint16>);
handler = tempHandler;
}
// Retrieve a float handler
///////////////////////////////////////////////////////////
if(m_bufferType=="FL")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<float>);
handler = tempHandler;
}
// Retrieve a double float handler
///////////////////////////////////////////////////////////
if(m_bufferType=="FD")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<double>);
handler = tempHandler;
}
// Retrieve a signed long handler
///////////////////////////////////////////////////////////
if(m_bufferType=="SL")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxInt32>);
handler = tempHandler;
}
// Retrieve a signed short handler
///////////////////////////////////////////////////////////
if(m_bufferType=="SS")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxInt16>);
handler = tempHandler;
}
// Retrieve an unsigned long handler
///////////////////////////////////////////////////////////
if(m_bufferType=="UL")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxUint32>);
handler = tempHandler;
}
// Retrieve an unsigned short handler
///////////////////////////////////////////////////////////
if(m_bufferType=="US")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerNumeric<imbxUint16>);
handler = tempHandler;
}
// Retrieve date
///////////////////////////////////////////////////////////
if(m_bufferType=="DA")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerDate);
handler = tempHandler;
}
// Retrieve date-time
///////////////////////////////////////////////////////////
if(m_bufferType=="DT")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerDateTime);
handler = tempHandler;
}
// Retrieve time
///////////////////////////////////////////////////////////
if(m_bufferType=="TM")
{
ptr<handlers::dataHandler> tempHandler(new handlers::dataHandlerTime);
handler = tempHandler;
}
} // check bRaw
// If an error occurred during the data handler creation,
// then throw an exception
///////////////////////////////////////////////////////////
if(handler == 0)
{
PUNTOEXE_THROW(bufferExceptionUnknownType, "Unknown data type requested");
}
// Connect the handler to this buffer
///////////////////////////////////////////////////////////
if(localMemory == 0)
{
localMemory = ptr<memory>(new memory);
}
ptr<memory> parseMemory(localMemory);
// Set the handler's attributes
///////////////////////////////////////////////////////////
if(bWrite)
{
ptr<buffer> tempBuffer(this);
handler->m_buffer = tempBuffer;
imbxUint32 actualMemorySize = localMemory->size();
imbxUint32 newMemorySize = actualMemorySize;
if(newMemorySize == 0)
{
newMemorySize = size * handler->getUnitSize();
}
ptr<memory> newMemoryBuffer(memoryPool::getMemoryPool()->getMemory(newMemorySize));
if(actualMemorySize != 0)
{
newMemoryBuffer->copyFrom(localMemory);
}
parseMemory = newMemoryBuffer;
// Add writing handlers to the current transaction
///////////////////////////////////////////////////////////
transactionsManager::addHandlerToTransaction(handler);
}
handler->m_bufferType = m_bufferType;
handler->setCharsetsList(&m_charsetsList);
handler->parseBuffer(parseMemory);
// Rewind the data pointer
///////////////////////////////////////////////////////////
if(handler->getSize() != 0)
{
handler->setPointer(0);
}
// Return the allocated handler
///////////////////////////////////////////////////////////
return handler;
PUNTOEXE_FUNCTION_END();
}
