// --------------------------------------------------------------------------
//! calculate the needed place to write the element in a buffer
// --------------------------------------------------------------------------
int RequestTreeElement::calculateSizeForWritting()
{
mSizeForWritting = 0;
RequestTreeElement * elt = getFirstChildElement();
while(elt)
{
mSizeForWritting += elt->calculateSizeForWritting();
elt = elt->getNextElement();
}
mSizeForWritting += mBufferSize;
// return the size used to the element to be writen into a buffer
// including the element header ('OP' + identifiant + size)
return mSizeForWritting + SIZESEPARATOR + sizeof(short) + sizeof(int);
}
ElementPtr Node::findFirstChildElement(String elementName) const
{
bool caseSensative = true;
DocumentPtr document = getDocument();
if (document)
caseSensative = document->isElementNameIsCaseSensative();
ElementPtr element = getFirstChildElement();
while (element)
{
if (caseSensative)
{
if (elementName == element->getValue())
return element;
}
else
{
if (0 == elementName.compareNoCase(element->getValue()))
return element;
}
element = element->getNextSiblingElement();
}
return ElementPtr();
}
int main(int argc, char* argv[])
{
if (argc != 3)
{
std::cerr << "usage: PListMerger"
<< " <first-plist-content>"
<< " <second-plist-content>" << std::endl;
return 1;
}
const std::vector<std::string> args{argv, argv + argc};
const juce::ScopedPointer<juce::XmlElement> firstPlistElement =
juce::XmlDocument::parse(args.at(1));
if (!firstPlistElement || !firstPlistElement->hasTagName("plist"))
{
std::cerr << "Invalid first plist content, expected <plist> element" << std::endl;
return 1;
}
const auto firstDictElement = firstPlistElement->getChildByName("dict");
if (!firstDictElement)
{
std::cerr << "Invalid first plist content, expected <dict> element" << std::endl;
return 1;
}
std::vector<std::string> keysInFirstPlist;
for (auto childElement = firstDictElement->getFirstChildElement();
childElement != nullptr; childElement = childElement->getNextElement())
{
if (childElement->getTagName() != "key" || childElement->getNumChildElements() != 1
|| !childElement->getFirstChildElement()->isTextElement())
{
std::cerr << "Invalid first plist content, expected <key> element with only one "
"text child element"
<< std::endl;
return 1;
}
const auto key = childElement->getFirstChildElement()->getText().toStdString();
if (std::find(keysInFirstPlist.begin(), keysInFirstPlist.end(), key)
!= keysInFirstPlist.end())
{
std::cerr << "Invalid first plist content, duplicated key \"" << key << "\""
<< std::endl;
return 1;
}
keysInFirstPlist.push_back(key);
childElement = childElement->getNextElement();
if (childElement == nullptr)
{
std::cerr << "Invalid first plist content, missing value associated with key \""
<< key << "\"" << std::endl;
return 1;
}
}
const juce::ScopedPointer<juce::XmlElement> secondPlistElement =
juce::XmlDocument::parse(args.at(2));
if (!secondPlistElement || !secondPlistElement->hasTagName("plist"))
{
std::cerr << "Invalid second plist content, expected <plist> element" << std::endl;
return 1;
}
const auto secondDictElement = secondPlistElement->getChildByName("dict");
if (!secondDictElement)
{
std::cerr << "Invalid second plist content, expected <dict> element" << std::endl;
return 1;
}
for (auto childElement = secondDictElement->getFirstChildElement();
childElement != nullptr; childElement = childElement->getNextElement())
{
if (childElement->getTagName() != "key" || childElement->getNumChildElements() != 1
|| !childElement->getFirstChildElement()->isTextElement())
{
std::cerr << "Invalid second plist content, expected <key> element with only one "
"text child element"
<< std::endl;
return 1;
}
const auto key = childElement->getFirstChildElement()->getText().toStdString();
const auto isKeyAlreadyInFirstPlist =
std::find(keysInFirstPlist.begin(), keysInFirstPlist.end(), key)
!= keysInFirstPlist.end();
if (!isKeyAlreadyInFirstPlist)
{
firstDictElement->addChildElement(new juce::XmlElement(*childElement));
}
childElement = childElement->getNextElement();
if (childElement == nullptr)
{
std::cerr << "Invalid second plist content, missing value associated with key \""
<< key << "\"" << std::endl;
return 1;
}
if (!isKeyAlreadyInFirstPlist)
{
firstDictElement->addChildElement(new juce::XmlElement(*childElement));
}
}
std::cout << firstPlistElement->createDocument(juce::String{}, false, false)
<< std::flush;
return 0;
}
ElementPtr Node::getFirstChildElementChecked() const throw(Exceptions::CheckFailed)
{
ElementPtr result = getFirstChildElement();
ZS_THROW_CUSTOM_IF(Exceptions::CheckFailed, !result)
return result;
}
bool FgXmlProtocol::parseDOM(QString& err_msg) {
QDomElement dom_elem_base = m_xml_dom.documentElement();
if (dom_elem_base.nodeName()!=ProtXmlDef::NodePropertyList) {
err_msg="Protocol file not valid " + ProtXmlDef::NodePropertyList;
return false;
}
QDomElement dom_elem_prot = dom_elem_base.firstChildElement(ProtXmlDef::NodeProtocolType).firstChildElement(ProtXmlDef::NodeProtocolOut);
if (dom_elem_prot.isNull()) {
err_msg="invalid FG generic protocol file";
return false;
}
QDomElement current_elem;
//FIXME: all of simgear/props/props.cxx SGPropertyNode::getBoolValue () could be construed as
//setting binary mode. Considered silly either ways, pulling in simgear dependency
//for this case, or to reimplement and track the checks for all possibilities just to deny
//them.
if (getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeBinary, err_msg, "")) {
err_msg="Not implemented yet: PITA of deciding if " + ProtXmlDef::NodeBinary
+ " is used. It isn't implemented here anyways. Please remove <"
+ ProtXmlDef::NodeBinary + "> tag.";
return false;
}
err_msg.clear(); //it's not an error here
if (!getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeLineSep,
err_msg, "No needed <" + ProtXmlDef::NodeLineSep +"> set")) return false;
m_line_separator=setSep(current_elem.text());
if (m_line_separator.pattern().isEmpty()) {
err_msg="Empty <" + ProtXmlDef::NodeLineSep +"> value not allowed";
return false;
}
if (!getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeVarSep,
err_msg, "No needed <" + ProtXmlDef::NodeVarSep +"> set")) return false;
m_var_separator=setSep(current_elem.text());
if (m_var_separator.pattern().isEmpty()) {
err_msg="Empty <" + ProtXmlDef::NodeVarSep +"> value not allowed";
return false;
}
if (!getFirstChildElement(current_elem, dom_elem_prot, ProtXmlDef::NodeChunk,
err_msg, "No protocol chunk defined")) return false;
QDomElement info_elem;
while (!current_elem.isNull()) {
if (getFirstChildElement(info_elem, current_elem, ProtXmlDef::NodeName, err_msg)) {
if (!insertChunkName(info_elem.text())) {
current_elem=current_elem.nextSiblingElement(ProtXmlDef::NodeChunk);
break; //that chunk is not known, discard
}
}
if (getFirstChildElement(info_elem, current_elem, ProtXmlDef::NodeType, err_msg)) {
if (info_elem.text()=="bool")
insertChunkType(FG_BOOL);
else if (info_elem.text()=="float")
insertChunkType(FG_DOUBLE);
else if (info_elem.text()=="string")
insertChunkType(FG_STRING);
else if (info_elem.text()=="double")
insertChunkType(FG_INT);
//really! actually it just falls through to default, which happens to be
//FG_INT (set it explicitly here to avoid confusion, been there, done that...)
else
insertChunkType(FG_INT);
}
if (getFirstChildElement(info_elem, current_elem, ProtXmlDef::NodeCount, err_msg)) {
insertChunkCount(info_elem.text().toInt());
}
//tmpDesc.index=QModelIndex(tmpIndex);
//m_protinfo.append(tmpDesc);
if (!nextChunk()) break; //target data does not like another chunk
current_elem=current_elem.nextSiblingElement(ProtXmlDef::NodeChunk);
};
return true;
};
