Lines Matching refs:root
86 inline std::string nameOf(NodeType *root) {
87 return root->Name() == NULL ? "" : root->Name();
90 inline std::string getText(NodeType *root) {
91 return root->GetText() == NULL ? "" : root->GetText();
112 inline bool getAttr(NodeType *root, const std::string &attrName, std::string *s) {
113 const char *c = root->Attribute(attrName.c_str());
154 NodeType *root = createNode(this->elementName(), d);
155 this->mutateNode(o, root, d, flags);
156 return root;
165 inline bool deserialize(Object* object, NodeType* root) {
166 bool ret = deserialize(object, root, &mLastError);
173 inline bool deserialize(Object* object, NodeType* root, std::string* error) const {
174 if (nameOf(root) != this->elementName()) {
177 return this->buildObject(object, root, error);
247 inline bool parseOptionalAttr(NodeType* root, const std::string& attrName, T&& defaultValue,
250 bool success = getAttr(root, attrName, &attrText) &&
259 inline bool parseAttr(NodeType* root, const std::string& attrName, T* attr,
262 bool ret = getAttr(root, attrName, &attrText) && ::android::vintf::parse(attrText, attr);
270 inline bool parseAttr(NodeType* root, const std::string& attrName, std::string* attr,
272 bool ret = getAttr(root, attrName, attr);
280 inline bool parseTextElement(NodeType* root, const std::string& elementName, std::string* s,
282 NodeType *child = getChild(root, elementName);
292 inline bool parseOptionalTextElement(NodeType* root, const std::string& elementName,
295 NodeType* child = getChild(root, elementName);
300 inline bool parseTextElements(NodeType* root, const std::string& elementName,
302 auto nodes = getChildren(root, elementName);
311 inline bool parseChild(NodeType* root, const XmlNodeConverter<T>& conv, T* t,
313 NodeType *child = getChild(root, conv.elementName());
323 inline bool parseOptionalChild(NodeType* root, const XmlNodeConverter<T>& conv,
325 NodeType *child = getChild(root, conv.elementName());
334 inline bool parseChildren(NodeType* root, const XmlNodeConverter<T>& conv, std::vector<T>* v,
336 auto nodes = getChildren(root, conv.elementName());
349 inline bool parseChildren(NodeType* root, const XmlNodeConverter<T>& conv, std::set<T>* s,
352 if (!parseChildren(root, conv, &vec, error)) {
390 virtual void mutateNode(const Object &object, NodeType *root, DocType *d) const override {
391 appendText(root, ::android::vintf::to_string(object), d);
393 virtual bool buildObject(Object* object, NodeType* root, std::string* error) const override {
394 return this->parseText(root, object, error);
411 void mutateNode(const TransportArch &object, NodeType *root, DocType *d) const override {
413 appendAttr(root, "arch", object.arch);
415 appendText(root, ::android::vintf::to_string(object.transport), d);
417 bool buildObject(TransportArch* object, NodeType* root, std::string* error) const override {
418 if (!parseOptionalAttr(root, "arch", Arch::ARCH_EMPTY, &object->arch, error) ||
419 !parseText(root, &object->transport, error)) {
436 void mutateNode(const KernelConfigTypedValue &object, NodeType *root, DocType *d) const override {
437 appendAttr(root, "type", object.mType);
438 appendText(root, ::android::vintf::to_string(object), d);
440 bool buildObject(KernelConfigTypedValue* object, NodeType* root,
443 if (!parseAttr(root, "type", &object->mType, error) ||
444 !parseText(root, &stringValue, error)) {
459 void mutateNode(const KernelConfig &object, NodeType *root, DocType *d) const override {
460 appendChild(root, kernelConfigKeyConverter(object.first, d));
461 appendChild(root, kernelConfigTypedValueConverter(object.second, d));
463 bool buildObject(KernelConfig* object, NodeType* root, std::string* error) const override {
464 if (!parseChild(root, kernelConfigKeyConverter, &object->first, error) ||
465 !parseChild(root, kernelConfigTypedValueConverter, &object->second, error)) {
476 void mutateNode(const HalInterface &intf, NodeType *root, DocType *d) const override {
477 appendTextElement(root, "name", intf.name(), d);
478 appendTextElements(root, "instance", intf.mInstances, d);
479 appendTextElements(root, "regex-instance", intf.mRegexes, d);
481 bool buildObject(HalInterface* intf, NodeType* root, std::string* error) const override {
484 if (!parseTextElement(root, "name", &intf->mName, error) ||
485 !parseTextElements(root, "instance", &instances, error) ||
486 !parseTextElements(root, "regex-instance", ®exes, error)) {
518 void mutateNode(const MatrixHal &hal, NodeType *root, DocType *d) const override {
519 appendAttr(root, "format", hal.format);
520 appendAttr(root, "optional", hal.optional);
521 appendTextElement(root, "name", hal.name, d);
522 appendChildren(root, versionRangeConverter, hal.versionRanges, d);
523 appendChildren(root, halInterfaceConverter, iterateValues(hal.interfaces), d);
525 bool buildObject(MatrixHal* object, NodeType* root, std::string* error) const override {
527 if (!parseOptionalAttr(root, "format", HalFormat::HIDL, &object->format, error) ||
528 !parseOptionalAttr(root, "optional", false /* defaultValue */, &object->optional,
530 !parseTextElement(root, "name", &object->name, error) ||
531 !parseChildren(root, versionRangeConverter, &object->versionRanges, error) ||
532 !parseChildren(root, halInterfaceConverter, &interfaces, error)) {
589 void mutateNode(const std::vector<KernelConfig>& conds, NodeType* root,
591 appendChildren(root, kernelConfigConverter, conds, d);
593 bool buildObject(std::vector<KernelConfig>* object, NodeType* root,
595 return parseChildren(root, kernelConfigConverter, object, error);
603 void mutateNode(const MatrixKernel &kernel, NodeType *root, DocType *d) const override {
604 appendAttr(root, "version", kernel.mMinLts);
606 appendChild(root, matrixKernelConditionsConverter(kernel.mConditions, d));
608 appendChildren(root, kernelConfigConverter, kernel.mConfigs, d);
610 bool buildObject(MatrixKernel* object, NodeType* root, std::string* error) const override {
611 if (!parseAttr(root, "version", &object->mMinLts, error) ||
612 !parseOptionalChild(root, matrixKernelConditionsConverter, {}, &object->mConditions,
614 !parseChildren(root, kernelConfigConverter, &object->mConfigs, error)) {
627 void mutateNode(const ManifestHal& m, NodeType* root, DocType* d) const override {
628 mutateNode(m, root, d, SerializeFlag::EVERYTHING);
630 void mutateNode(const ManifestHal& hal, NodeType* root, DocType* d,
632 appendAttr(root, "format", hal.format);
633 appendTextElement(root, "name", hal.name, d);
634 appendChild(root, transportArchConverter(hal.transportArch, d));
635 appendChildren(root, versionConverter, hal.versions, d);
636 appendChildren(root, halInterfaceConverter, iterateValues(hal.interfaces), d);
638 appendAttr(root, "override", hal.isOverride());
647 appendChildren(root, fqInstanceConverter, fqInstances, d);
650 bool buildObject(ManifestHal* object, NodeType* root, std::string* error) const override {
652 if (!parseOptionalAttr(root, "format", HalFormat::HIDL, &object->format, error) ||
653 !parseOptionalAttr(root, "override", false, &object->mIsOverride, error) ||
654 !parseTextElement(root, "name", &object->name, error) ||
655 !parseOptionalChild(root, transportArchConverter, {}, &object->transportArch, error) ||
656 !parseChildren(root, versionConverter, &object->versions, error) ||
657 !parseChildren(root, halInterfaceConverter, &interfaces, error)) {
705 if (!parseChildren(root, fqInstanceConverter, &fqInstances, error)) {
743 void mutateNode(const Sepolicy &object, NodeType *root, DocType *d) const override {
744 appendChild(root, kernelSepolicyVersionConverter(object.kernelSepolicyVersion(), d));
745 appendChildren(root, sepolicyVersionConverter, object.sepolicyVersions(), d);
747 bool buildObject(Sepolicy* object, NodeType* root, std::string* error) const override {
748 if (!parseChild(root, kernelSepolicyVersionConverter, &object->mKernelSepolicyVersion,
750 !parseChildren(root, sepolicyVersionConverter, &object->mSepolicyVersionRanges,
766 void mutateNode(const Vndk &object, NodeType *root, DocType *d) const override {
767 appendChild(root, vndkVersionRangeConverter(object.mVersionRange, d));
768 appendChildren(root, vndkLibraryConverter, object.mLibraries, d);
770 bool buildObject(Vndk* object, NodeType* root, std::string* error) const override {
771 if (!parseChild(root, vndkVersionRangeConverter, &object->mVersionRange, error) ||
772 !parseChildren(root, vndkLibraryConverter, &object->mLibraries, error)) {
783 void mutateNode(const VendorNdk& object, NodeType* root, DocType* d) const override {
784 appendChild(root, vndkVersionConverter(object.mVersion, d));
785 appendChildren(root, vndkLibraryConverter, object.mLibraries, d);
787 bool buildObject(VendorNdk* object, NodeType* root, std::string* error) const override {
788 if (!parseChild(root, vndkVersionConverter, &object->mVersion, error) ||
789 !parseChildren(root, vndkLibraryConverter, &object->mLibraries, error)) {
802 void mutateNode(const SystemSdk& object, NodeType* root, DocType* d) const override {
803 appendChildren(root, systemSdkVersionConverter, object.versions(), d);
805 bool buildObject(SystemSdk* object, NodeType* root, std::string* error) const override {
806 return parseChildren(root, systemSdkVersionConverter, &object->mVersions, error);
814 void mutateNode(const Version &m, NodeType *root, DocType *d) const override {
815 appendChild(root, versionConverter(m, d));
817 bool buildObject(Version* object, NodeType* root, std::string* error) const override {
818 return parseChild(root, versionConverter, object, error);
825 void mutateNode(const ManifestXmlFile& f, NodeType* root, DocType* d) const override {
826 appendTextElement(root, "name", f.name(), d);
827 appendChild(root, versionConverter(f.version(), d));
829 appendTextElement(root, "path", f.overriddenPath(), d);
832 bool buildObject(ManifestXmlFile* object, NodeType* root, std::string* error) const override {
833 if (!parseTextElement(root, "name", &object->mName, error) ||
834 !parseChild(root, versionConverter, &object->mVersion, error) ||
835 !parseOptionalTextElement(root, "path", {}, &object->mOverriddenPath, error)) {
845 void mutateNode(const HalManifest &m, NodeType *root, DocType *d) const override {
846 mutateNode(m, root, d, SerializeFlag::EVERYTHING);
848 void mutateNode(const HalManifest& m, NodeType* root, DocType* d,
850 appendAttr(root, "version", m.getMetaVersion());
851 appendAttr(root, "type", m.mType);
854 appendChildren(root, manifestHalConverter, m.getHals(), d, flags);
858 appendChild(root, halManifestSepolicyConverter(m.device.mSepolicyVersion, d));
861 this->appendAttr(root, "target-level", m.mLevel);
867 appendChildren(root, vndkConverter, m.framework.mVndks, d);
870 appendChildren(root, vendorNdkConverter, m.framework.mVendorNdks, d);
874 appendChild(root, systemSdkConverter(m.framework.mSystemSdk, d));
880 appendChildren(root, manifestXmlFileConverter, m.getXmlFiles(), d);
883 bool buildObject(HalManifest* object, NodeType* root, std::string* error) const override {
885 if (!parseAttr(root, "version", &object->mMetaVersion, error) ||
886 !parseAttr(root, "type", &object->mType, error) ||
887 !parseChildren(root, manifestHalConverter, &hals, error)) {
899 if (!parseOptionalChild(root, halManifestSepolicyConverter, {},
904 if (!parseOptionalAttr(root, "target-level", Level::UNSPECIFIED, &object->mLevel,
911 if (!parseChildren(root, vndkConverter, &object->framework.mVndks, error)) {
923 if (!parseChildren(root, vendorNdkConverter, &object->framework.mVendorNdks, error)) {
936 if (!parseOptionalChild(root, systemSdkConverter, {}, &object->framework.mSystemSdk,
950 if (!parseChildren(root, manifestXmlFileConverter, &xmlFiles, error)) {
971 void mutateNode(const Version &m, NodeType *root, DocType *d) const override {
972 appendChild(root, avbVersionConverter(m, d));
974 bool buildObject(Version* object, NodeType* root, std::string* error) const override {
975 return parseChild(root, avbVersionConverter, object, error);
982 void mutateNode(const MatrixXmlFile& f, NodeType* root, DocType* d) const override {
983 appendTextElement(root, "name", f.name(), d);
984 appendAttr(root, "format", f.format());
985 appendAttr(root, "optional", f.optional());
986 appendChild(root, versionRangeConverter(f.versionRange(), d));
988 appendTextElement(root, "path", f.overriddenPath(), d);
991 bool buildObject(MatrixXmlFile* object, NodeType* root, std::string* error) const override {
992 if (!parseTextElement(root, "name", &object->mName, error) ||
993 !parseAttr(root, "format", &object->mFormat, error) ||
994 !parseOptionalAttr(root, "optional", false, &object->mOptional, error) ||
995 !parseChild(root, versionRangeConverter, &object->mVersionRange, error) ||
996 !parseOptionalTextElement(root, "path", {}, &object->mOverriddenPath, error)) {
1006 void mutateNode(const CompatibilityMatrix &m, NodeType *root, DocType *d) const override {
1007 mutateNode(m, root, d, SerializeFlag::EVERYTHING);
1009 void mutateNode(const CompatibilityMatrix& m, NodeType* root, DocType* d,
1011 appendAttr(root, "version", m.getMinimumMetaVersion());
1012 appendAttr(root, "type", m.mType);
1015 appendChildren(root, matrixHalConverter, iterateValues(m.mHals), d);
1019 appendChildren(root, matrixKernelConverter, m.framework.mKernels, d);
1023 appendChild(root, sepolicyConverter(m.framework.mSepolicy, d));
1028 appendChild(root, avbConverter(m.framework.mAvbMetaVersion, d));
1032 this->appendAttr(root, "level", m.mLevel);
1039 appendChild(root, vndkConverter(m.device.mVndk, d));
1044 appendChild(root, vendorNdkConverter(m.device.mVendorNdk, d));
1050 appendChild(root, systemSdkConverter(m.device.mSystemSdk, d));
1056 appendChildren(root, matrixXmlFileConverter, m.getXmlFiles(), d);
1059 bool buildObject(CompatibilityMatrix* object, NodeType* root,
1063 if (!parseAttr(root, "version", &version, error) ||
1064 !parseAttr(root, "type", &object->mType, error) ||
1065 !parseChildren(root, matrixHalConverter, &hals, error)) {
1072 if (!parseChildren(root, matrixKernelConverter, &object->framework.mKernels, error) ||
1073 !parseOptionalChild(root, sepolicyConverter, {}, &object->framework.mSepolicy,
1075 !parseOptionalChild(root, avbConverter, {}, &object->framework.mAvbMetaVersion,
1094 if (!parseOptionalAttr(root, "level", Level::UNSPECIFIED, &object->mLevel, error)) {
1103 if (!parseOptionalChild(root, vndkConverter, {}, &object->device.mVndk, error)) {
1108 if (!parseOptionalChild(root, vendorNdkConverter, {}, &object->device.mVendorNdk,
1113 if (!parseOptionalChild(root, systemSdkConverter, {}, &object->device.mSystemSdk,
1132 if (!parseChildren(root, matrixXmlFileConverter, &xmlFiles, error)) {