{

std::size_t periodIndex = _fileName.rfind('.');

if (periodIndex != std::string::npos)

{

const std::string ext = _fileName.substr(periodIndex);

return ext == ".sdf" || ext == ".world";

}

return false;

{

auto xmlDoc = makeSdfDoc();

if (tinyxml2::XML_SUCCESS != xmlDoc.LoadFile(_filename.c_str()))

{

sdferr << "Unable to load file["

<< _filename << "]: " << xmlDoc.ErrorStr() << "\n";

return false;

}

return initDoc(&xmlDoc, _sdf);

{

std::string xmldata = SDF::EmbeddedSpec("root.sdf", false);

auto xmlDoc = makeSdfDoc();

xmlDoc.Parse(xmldata.c_str());

return initDoc(&xmlDoc, _sdf);

const std::string &_filename, const ParserConfig &_config, SDFPtr _sdf)

{

std::string xmldata = SDF::EmbeddedSpec(_filename, true);

if (!xmldata.empty())

{

auto xmlDoc = makeSdfDoc();

xmlDoc.Parse(xmldata.c_str());

return initDoc(&xmlDoc, _sdf);

}

return _initFile(sdf::findFile(_filename, true, false, _config), _sdf);

const std::string &_filename, const ParserConfig &_config, ElementPtr _sdf)

{

std::string xmldata = SDF::EmbeddedSpec(_filename, true);

if (!xmldata.empty())

{

auto xmlDoc = makeSdfDoc();

xmlDoc.Parse(xmldata.c_str());

return initDoc(&xmlDoc, _sdf);

}

return _initFile(sdf::findFile(_filename, true, false, _config), _sdf);

const std::string &_xmlString, const ParserConfig &, SDFPtr _sdf)

{

auto xmlDoc = makeSdfDoc();

if (xmlDoc.Parse(_xmlString.c_str()))

{

sdferr << "Failed to parse string as XML: " << xmlDoc.ErrorStr() << '\n';

return false;

}

return initDoc(&xmlDoc, _sdf);

{

auto element = _initDocGetElement(_xmlDoc);

if (!element)

{

return false;

}

return initXml(element, _sdf->Root());

{

auto element = _initDocGetElement(_xmlDoc);

if (!element)

{

return false;

}

return initXml(element, _sdf);

{

const char *refString = _xml->Attribute("ref");

if (refString)

{

_sdf->SetReferenceSDF(std::string(refString));

}

const char *nameString = _xml->Attribute("name");

if (!nameString)

{

sdferr << "Element is missing the name attribute\n";

return false;

}

_sdf->SetName(std::string(nameString));

const char *requiredString = _xml->Attribute("required");

if (!requiredString)

{

sdferr << "Element is missing the required attributed\n";

return false;

}

_sdf->SetRequired(requiredString);

const char *elemTypeString = _xml->Attribute("type");

if (elemTypeString)

{

bool required = std::string(requiredString) == "1" ? true : false;

const char *elemDefaultValue = _xml->Attribute("default");

std::string description;

tinyxml2::XMLElement *descChild = _xml->FirstChildElement("description");

if (descChild && descChild->GetText())

{

description = descChild->GetText();

}

std::string minValue;

const char *elemMinValue = _xml->Attribute("min");

if (nullptr != elemMinValue)

{

minValue = elemMinValue;

}

std::string maxValue;

const char *elemMaxValue = _xml->Attribute("max");

if (nullptr != elemMaxValue)

{

maxValue = elemMaxValue;

}

_sdf->AddValue(elemTypeString, elemDefaultValue, required, minValue,

maxValue, description);

}

// Get all attributes

for (tinyxml2::XMLElement *child = _xml->FirstChildElement("attribute");

child; child = child->NextSiblingElement("attribute"))

{

auto *descriptionChild = child->FirstChildElement("description");

const char *name = child->Attribute("name");

const char *type = child->Attribute("type");

const char *defaultValue = child->Attribute("default");

requiredString = child->Attribute("required");

if (!name)

{

sdferr << "Attribute is missing a name\n";

return false;

}

if (!type)

{

sdferr << "Attribute is missing a type\n";

return false;

}

if (!defaultValue)

{

sdferr << "Attribute[" << name << "] is missing a default\n";

return false;

}

if (!requiredString)

{

sdferr << "Attribute is missing a required string\n";

return false;

}

std::string requiredStr = sdf::trim(requiredString);

bool required = requiredStr == "1" ? true : false;

std::string description;

if (descriptionChild && descriptionChild->GetText())

{

description = descriptionChild->GetText();

}

_sdf->AddAttribute(name, type, defaultValue, required, description);

}

// Read the element description

tinyxml2::XMLElement *descChild = _xml->FirstChildElement("description");

if (descChild && descChild->GetText())

{

_sdf->SetDescription(descChild->GetText());

}

// Get all child elements

for (tinyxml2::XMLElement *child = _xml->FirstChildElement("element");

child; child = child->NextSiblingElement("element"))

{

const char *copyDataString = child->Attribute("copy_data");

if (copyDataString &&

(std::string(copyDataString) == "true" ||

std::string(copyDataString) == "1"))

{

_sdf->SetCopyChildren(true);

}

else

{

ElementPtr element(new Element);

initXml(child, element);

_sdf->AddElementDescription(element);

}

}

// Get all include elements

for (tinyxml2::XMLElement *child = _xml->FirstChildElement("include");

child; child = child->NextSiblingElement("include"))

{

std::string filename = child->Attribute("filename");

ElementPtr element(new Element);

initFile(filename, element);

// override description for include elements

tinyxml2::XMLElement *description = child->FirstChildElement("description");

if (description)

{

element->SetDescription(description->GetText());

}

_sdf->AddElementDescription(element);

}

return true;

const std::string &_filename, const ParserConfig &_config, Errors &_errors)

{

// Create and initialize the data structure that will hold the parsed SDF data

sdf::SDFPtr sdfParsed(new sdf::SDF());

sdf::init(sdfParsed);

// Read an SDF file, and store the result in sdfParsed.

if (!sdf::readFile(_filename, _config, sdfParsed, _errors))

{

return SDFPtr();

}

return sdfParsed;

{

Errors errors;

SDFPtr result = readFile(_filename, errors);

// Output errors

for (auto const &e : errors)

std::cerr << e << std::endl;

return result;

{

Errors errors;

bool result = readFile(_filename, _sdf, errors);

// Output errors

for (auto const &e : errors)

std::cerr << e << std::endl;

return result;

SDFPtr _sdf, Errors &_errors)

{

return readFileInternal(_filename, true, _config, _sdf, _errors);

const std::string &_filename, SDFPtr _sdf, Errors &_errors)

{

return readFileWithoutConversion(

_filename, ParserConfig::GlobalConfig(), _sdf, _errors);

const ParserConfig &_config, SDFPtr _sdf, Errors &_errors)

{

return readFileInternal(_filename, false, _config, _sdf, _errors);

const ParserConfig &_config, SDFPtr _sdf, Errors &_errors)

{

auto xmlDoc = makeSdfDoc();

std::string filename = sdf::findFile(_filename, true, true, _config);

if (filename.empty())

{

sdferr << "Error finding file [" << _filename << "].\n";

return false;

}

if (filesystem::is_directory(filename))

{

filename = getModelFilePath(filename);

}

if (!filesystem::exists(filename))

{

sdferr << "File [" << filename << "] doesn't exist.\n";

return false;

}

auto error_code = xmlDoc.LoadFile(filename.c_str());

if (error_code)

{

sdferr << "Error parsing XML in file [" << filename << "]: "

<< xmlDoc.ErrorStr() << '\n';

return false;

}

// Suppress deprecation for sdf::URDF2SDF

if (readDoc(&xmlDoc, _sdf, filename, _convert, _config, _errors))

{

return true;

}

else if (URDF2SDF::IsURDF(filename))

{

URDF2SDF u2g;

auto doc = makeSdfDoc();

u2g.InitModelFile(filename, _config, &doc);

if (sdf::readDoc(&doc, _sdf, "urdf file", _convert, _config, _errors))

{

sdfdbg << "parse from urdf file [" << _filename << "].\n";

return true;

}

else

{

sdferr << "parse as old deprecated model file failed.\n";

return false;

}

}

return false;

{

Errors errors;

bool result = readString(_xmlString, _sdf, errors);

// Output errors

for (auto const &e : errors)

std::cerr << e << std::endl;

return result;

SDFPtr _sdf, Errors &_errors)

{

return readStringInternal(_xmlString, true, _config, _sdf, _errors);

const std::string &_filename, SDFPtr _sdf, Errors &_errors)

{

return readStringWithoutConversion(

_filename, ParserConfig::GlobalConfig(), _sdf, _errors);

const ParserConfig &_config, SDFPtr _sdf, Errors &_errors)

{

return readStringInternal(_filename, false, _config, _sdf, _errors);

const ParserConfig &_config, SDFPtr _sdf, Errors &_errors)

{

auto xmlDoc = makeSdfDoc();

xmlDoc.Parse(_xmlString.c_str());

if (xmlDoc.Error())

{

sdferr << "Error parsing XML from string: " << xmlDoc.ErrorStr() << '\n';

return false;

}

if (readDoc(&xmlDoc, _sdf, std::string(kSdfStringSource), _convert, _config,

_errors))

{

return true;

}

else

{

URDF2SDF u2g;

auto doc = makeSdfDoc();

u2g.InitModelString(_xmlString, _config, &doc);

if (sdf::readDoc(&doc, _sdf, std::string(kUrdfStringSource), _convert,

_config, _errors))

{

sdfdbg << "Parsing from urdf.\n";

return true;

}

else

{

sdferr << "parse as old deprecated model file failed.\n";

return false;

}

}

return false;

{

Errors errors;

bool result = readString(_xmlString, _sdf, errors);

// Output errors

for (auto const &e : errors)

std::cerr << e << std::endl;

return result;

ElementPtr _sdf, Errors &_errors)

{

auto xmlDoc = makeSdfDoc();

xmlDoc.Parse(_xmlString.c_str());

if (xmlDoc.Error())

{

sdferr << "Error parsing XML from string: " << xmlDoc.ErrorStr() << '\n';

return false;

}

if (readDoc(&xmlDoc, _sdf, std::string(kSdfStringSource), true, _config,

_errors))

{

return true;

}

else

{

sdferr << "parse as sdf version " << SDF::Version() << " failed, "

<< "should try to parse as old deprecated format\n";

return false;

}

const std::string &_source, bool _convert, const ParserConfig &_config,

Errors &_errors)

{

if (!_xmlDoc)

{

sdfwarn << "Could not parse the xml from source[" << _source << "]\n";

return false;

}

// check sdf version

tinyxml2::XMLElement *sdfNode = _xmlDoc->FirstChildElement("sdf");

if (!sdfNode)

{

sdfdbg << "No <sdf> element in file[" << _source << "]\n";

return false;

}

if (nullptr == _sdf || nullptr == _sdf->Root())

{

sdferr << "SDF pointer or its Root is null.\n";

return false;

}

if (_source != std::string(kSdfStringSource))

{

_sdf->SetFilePath(_source);

}

if (sdfNode->Attribute("version"))

{

if (_sdf->OriginalVersion().empty())

{

_sdf->SetOriginalVersion(sdfNode->Attribute("version"));

}

if (_sdf->Root()->OriginalVersion().empty())

{

_sdf->Root()->SetOriginalVersion(sdfNode->Attribute("version"));

}

if (!_sdf->Root()->LineNumber().has_value())

{

_sdf->Root()->SetLineNumber(sdfNode->GetLineNum());

}

if (_sdf->Root()->XmlPath().empty())

{

_sdf->Root()->SetXmlPath("/sdf");

}

if (_convert

&& strcmp(sdfNode->Attribute("version"), SDF::Version().c_str()) != 0)

{

sdfdbg << "Converting a deprecated source[" << _source << "].\n";

Converter::Convert(_xmlDoc, SDF::Version());

}

auto *elemXml = _xmlDoc->FirstChildElement(_sdf->Root()->GetName().c_str());

// Perform all the pre-checks necessary for the XML elements before reading

if (!checkXmlFromRoot(elemXml, _source, _errors))

{

_errors.push_back({ErrorCode::ELEMENT_INVALID,

"Errors were found when checking the XML of element<"

+ _sdf->Root()->GetName() + ">."});

return false;

}

// parse new sdf xml

if (!readXml(elemXml, _sdf->Root(), _config, _source, _errors))

{

_errors.push_back({ErrorCode::ELEMENT_INVALID,

"Error reading element <" + _sdf->Root()->GetName() + ">"});

return false;

}

// delimiter '::' in element names not allowed in SDFormat >= 1.8

ignition::math::SemanticVersion sdfVersion(_sdf->Root()->OriginalVersion());

if (sdfVersion >= ignition::math::SemanticVersion(1, 8)

&& !recursiveSiblingNoDoubleColonInNames(_sdf->Root()))

{

_errors.push_back({ErrorCode::RESERVED_NAME,

"Delimiter '::' found in attribute names of element <"

+ _sdf->Root()->GetName() +

">, which is not allowed in SDFormat >= 1.8"});

return false;

}

}

else

{

sdfdbg << "SDF <sdf> element has no version in file["

<< _source << "]\n";

return false;

}

return true;

const std::string &_source, bool _convert, const ParserConfig &_config,

Errors &_errors)

{

if (!_xmlDoc)

{

sdfwarn << "Could not parse the xml\n";

return false;

}

// check sdf version

tinyxml2::XMLElement *sdfNode = _xmlDoc->FirstChildElement("sdf");

if (!sdfNode)

{

sdfdbg << "SDF has no <sdf> element\n";

return false;

}

if (_source != std::string(kSdfStringSource))

{

_sdf->SetFilePath(_source);

}

if (sdfNode->Attribute("version"))

{

if (_sdf->OriginalVersion().empty())

{

_sdf->SetOriginalVersion(sdfNode->Attribute("version"));

}

if (!_sdf->LineNumber().has_value())

{

_sdf->SetLineNumber(sdfNode->GetLineNum());

}

if (_sdf->XmlPath().empty())

{

_sdf->SetXmlPath("/sdf");

}

if (_convert

&& strcmp(sdfNode->Attribute("version"), SDF::Version().c_str()) != 0)

{

sdfdbg << "Converting a deprecated SDF source[" << _source << "].\n";

Converter::Convert(_xmlDoc, SDF::Version());

}

tinyxml2::XMLElement *elemXml = sdfNode;

if (sdfNode->Value() != _sdf->GetName() &&

sdfNode->FirstChildElement(_sdf->GetName().c_str()))

{

elemXml = sdfNode->FirstChildElement(_sdf->GetName().c_str());

}

// Perform all the pre-checks necessary for the XML elements before reading

if (!checkXmlFromRoot(elemXml, _source, _errors))

{

_errors.push_back({ErrorCode::ELEMENT_INVALID,

"Errors were found when checking the XML of element["

+ _sdf->GetName() + "]."});

return false;

}

// parse new sdf xml

if (!readXml(elemXml, _sdf, _config, _source, _errors))

{

_errors.push_back({ErrorCode::ELEMENT_INVALID,

"Unable to parse sdf element["+ _sdf->GetName() + "]"});

return false;

}

// delimiter '::' in element names not allowed in SDFormat >= 1.8

ignition::math::SemanticVersion sdfVersion(_sdf->OriginalVersion());

if (sdfVersion >= ignition::math::SemanticVersion(1, 8)

&& !recursiveSiblingNoDoubleColonInNames(_sdf))

{

_errors.push_back({ErrorCode::RESERVED_NAME,

"Delimiter '::' found in attribute names of element <"

+ _sdf->GetName() +

">, which is not allowed in SDFormat >= 1.8"});

return false;

}

}

else

{

sdfdbg << "<sdf> element has no version\n";

return false;

}

return true;

const std::string &_source, Errors &_errors)

{

// A null XML Root element is still valid as it might not be a mandatory

// element. Further errors will be deciphered by calling readXml with its

// SDF ptr.

if (!_xmlRoot)

return true;

std::string errorSourcePath = _source;

if (_source == kSdfStringSource || _source == kUrdfStringSource)

errorSourcePath = "<" + _source + ">";

// Top level models must have an empty relative_to frame on the top level

// pose.

{

if (tinyxml2::XMLElement *topLevelElem =

_xmlRoot->FirstChildElement("model"))

{

if (tinyxml2::XMLElement *topLevelPose =

topLevelElem->FirstChildElement("pose"))

{

if (const char *relativeTo = topLevelPose->Attribute("relative_to"))

{

const std::string relativeToStr(relativeTo);

if (!relativeToStr.empty())

{

std::stringstream sstream;

sstream << "Attribute //pose[@relative_to] of top level model "

<< "must be left empty, found //pose[@relative_to='"

<< relativeToStr << "'].\n";

_errors.push_back({

ErrorCode::ATTRIBUTE_INVALID,

sstream.str(),

errorSourcePath,

topLevelPose->GetLineNum()});

return false;

}

}

}

}

}

return true;

std::string &_modelFileName)

{

tinyxml2::XMLElement *sdfXML = _modelXML->FirstChildElement("sdf");

tinyxml2::XMLElement *nameSearch = _modelXML->FirstChildElement("name");

// If a match is not found, use the latest version of the element

// that is not older than the SDF parser.

ignition::math::SemanticVersion sdfParserVersion(SDF_VERSION);

std::string bestVersionStr = "0.0";

tinyxml2::XMLElement *sdfSearch = sdfXML;

while (sdfSearch)

{

if (sdfSearch->Attribute("version"))

{

auto version = std::string(sdfSearch->Attribute("version"));

ignition::math::SemanticVersion modelVersion(version);

ignition::math::SemanticVersion bestVersion(bestVersionStr);

if (modelVersion > bestVersion)

{

// this model is better than the previous one

if (modelVersion <= sdfParserVersion)

{

// the parser can read it

sdfXML = sdfSearch;

bestVersionStr = version;

}

else

{

sdfwarn << "Ignoring version " << version

<< " for model " << nameSearch->GetText()

<< " because is newer than this sdf parser"

<< " (version " << SDF_VERSION << ")\n";

}

}

}

sdfSearch = sdfSearch->NextSiblingElement("sdf");

}

if (!sdfXML || !sdfXML->GetText())

{

sdferr << "Failure to detect an sdf tag in the model config file"

<< " for model: " << nameSearch->GetText() << "\n";

_modelFileName = "";

return "";

}

if (!sdfXML->Attribute("version"))

{

sdfwarn << "Can not find the XML attribute 'version'"

<< " in sdf XML tag for model: " << nameSearch->GetText() << "."

<< " Please specify the SDF protocol supported in the model"

<< " configuration file. The first sdf tag in the config file"

<< " will be used \n";

}

_modelFileName = sdfXML->GetText();

return bestVersionStr;

{

std::string configFilePath;

/// \todo This hardcoded bit is very Gazebo centric. It should

/// be abstracted away, possibly through a plugin to SDF.

configFilePath = sdf::filesystem::append(_modelDirPath, "model.config");

if (!sdf::filesystem::exists(configFilePath))

{

// We didn't find model.config, look for manifest.xml instead

configFilePath = sdf::filesystem::append(_modelDirPath, "manifest.xml");

if (!sdf::filesystem::exists(configFilePath))

{

// We didn't find manifest.xml either, output an error and get out.

sdferr << "Could not find model.config or manifest.xml in ["

<< _modelDirPath << "]\n";

return std::string();

}

else

{

// We found manifest.xml, but since it is deprecated print a warning.

sdfwarn << "The manifest.xml for a model is deprecated. "

<< "Please rename manifest.xml to "

<< "model.config" << ".\n";

}

}

auto configFileDoc = makeSdfDoc();

if (tinyxml2::XML_SUCCESS != configFileDoc.LoadFile(configFilePath.c_str()))

{

sdferr << "Error parsing XML in file ["

<< configFilePath << "]: "

<< configFileDoc.ErrorStr() << '\n';

return std::string();

}

tinyxml2::XMLElement *modelXML = configFileDoc.FirstChildElement("model");

if (!modelXML)

{

sdferr << "No <model> element in configFile[" << configFilePath << "]\n";

return std::string();

}

std::string modelFileName;

if (getBestSupportedModelVersion(modelXML, modelFileName).empty())

{