/// This method creates an XML-snippet of a property section.
std::string makeProperties(std::size_t const ind,
std::vector<std::string> const& properties)
{
std::vector<std::string> temp;
for (std::size_t p = 0; p < properties.size(); ++p)
{
std::string property = makeProperty(ind + 2, p, properties[p]);
if ((!property.empty()) && (p != static_cast<std::size_t>(MPL::name)))
{
temp.push_back(property);
}
// If a property is not given, a default takes its place. Note also that
// 'name' is an exceptional property, since it determines specific
// components (thus it is defined outside of the properties- tag).
}
if (temp.empty())
{
return "";
}
std::stringstream sProperties;
sProperties << indent(ind) << "<properties>\n";
for (auto const& str : temp)
{
sProperties << str;
}
sProperties << indent(ind) << "</properties>\n";
return sProperties.str();
}
/**
* @brief SignatureMaker::SignatureMaker
* @param model
* @param project
* @param scope
* @param type
*/
SignatureMaker::SignatureMaker(const DB::SharedDatabase &globalDb,
const DB::SharedProjectDatabase &projectDb,
const Entity::SharedScope &scope, const Entity::SharedType &type)
: m_Type(type)
, m_Scope(scope)
, m_GlobalDatabase(globalDb)
, m_ProjectDatabase(projectDb)
{
m_MakersMap[Entity::Field::staticHashType()] =
[&](const Common::SharedBasicEntity &component) {
return makeField(std::static_pointer_cast<Entity::Field>(component));
};
m_MakersMap[Entity::ClassMethod::staticHashType()] =
[&](const Common::SharedBasicEntity &component) {
return makeMethod(std::static_pointer_cast<Entity::ClassMethod>(component));
};
m_MakersMap[Entity::Property::staticHashType()] =
[&](const Common::SharedBasicEntity &component) {
return makeProperty(std::static_pointer_cast<Entity::Property>(component));
};
}
HX_RESULT
RTSPMediaDesc::fromExternalRep(char* pData)
{
XMLParser parser;
XMLTag* pTag = 0;
CByteQueue* pQueue = new CByteQueue((UINT16)strlen(pData));
HXBOOL inMediaHeader = FALSE;
HXBOOL inMediaStream = FALSE;
HX_RESULT hresult = HXR_OK;
RTSPPropertyList* pMediaHeader = 0;
RTSPPropertyList* pMediaStream = 0;
pQueue->EnQueue(pData, (UINT16)strlen(pData));
for(;;)
{
UINT32 bytesUsed;
UINT32 bytesAvail = pQueue->GetQueuedItemCount();
if(bytesAvail <= 0)
{
break;
}
BYTE* pBuf = new BYTE[bytesAvail];
BYTE* p = pBuf;
HX_ASSERT(bytesAvail == (UINT16)bytesAvail);
pQueue->DeQueue(pBuf, (UINT16)bytesAvail);
bytesUsed = bytesAvail;
if(pTag)
{
delete pTag;
pTag = 0;
}
XMLParseResult rc = parser.Parse((const char*&)p, bytesAvail, pTag);
HX_ASSERT(bytesAvail == (UINT16)bytesAvail);
pQueue->EnQueue(p, (UINT16)(bytesAvail - (p - pBuf)));
switch(rc)
{
case XMLPTag:
{
switch(pTag->m_type)
{
case XMLPlainTag:
{
if(strcasecmp(pTag->m_name, "MediaHeader") == 0)
{
if(inMediaHeader)
{
//XXXBAB parse error
}
if(pMediaHeader)
{
delete pMediaHeader;
}
pMediaHeader = new RTSPPropertyList;
inMediaHeader = TRUE;
inMediaStream = FALSE;
}
else if(strcasecmp(pTag->m_name, "MediaStream") == 0)
{
if(inMediaStream)
{
//XXXBAB parse error
}
pMediaStream = new RTSPPropertyList;
inMediaHeader = FALSE;
inMediaStream = TRUE;
}
else
{
RTSPProperty* pProp = makeProperty(pTag);
if(pProp)
{
if(inMediaHeader)
{
pMediaHeader->addProperty(pProp);
}
else if(inMediaStream)
{
pMediaStream->addProperty(pProp);
}
}
}
}
break;
case XMLEndTag:
{
if(strcasecmp(pTag->m_name, "MediaHeader") == 0)
{
if(inMediaHeader)
{
m_pFileHeader = pMediaHeader;
}
else
{
// error
}
inMediaHeader = FALSE;
}
else if(strcasecmp(pTag->m_name, "MediaStream") == 0)
{
if(inMediaStream)
{
m_streams->AddTail(pMediaStream);
}
else
{
// error
}
inMediaStream = FALSE;
}
}
break;
default:
{
// unexpected
}
break;
}
}
break;
case XMLPPlainText:
{
// unexpected
}
break;
case XMLPComment:
{
// oh, yeah?
}
break;
default:
{
// unexpected
}
break;
}
delete[] pBuf;
}
if(pTag)
{
delete pTag;
}
delete pQueue;
return hresult;
}
