diff options
-rw-r--r-- | Android.bp | 1 | ||||
-rw-r--r-- | AssembleVintf.cpp | 2 | ||||
-rw-r--r-- | SerializeFlags.cpp | 76 | ||||
-rw-r--r-- | include/vintf/SerializeFlags.h | 95 | ||||
-rw-r--r-- | include/vintf/parse_xml.h | 8 | ||||
-rw-r--r-- | main.cpp | 2 | ||||
-rw-r--r-- | parse_xml.cpp | 18 |
7 files changed, 69 insertions, 133 deletions
@@ -53,7 +53,6 @@ cc_library { | |||
53 | "MatrixKernel.cpp", | 53 | "MatrixKernel.cpp", |
54 | "PropertyFetcher.cpp", | 54 | "PropertyFetcher.cpp", |
55 | "Regex.cpp", | 55 | "Regex.cpp", |
56 | "SerializeFlags.cpp", | ||
57 | "SystemSdk.cpp", | 56 | "SystemSdk.cpp", |
58 | "TransportArch.cpp", | 57 | "TransportArch.cpp", |
59 | "VintfObject.cpp", | 58 | "VintfObject.cpp", |
diff --git a/AssembleVintf.cpp b/AssembleVintf.cpp index 050059b..faab3e1 100644 --- a/AssembleVintf.cpp +++ b/AssembleVintf.cpp | |||
@@ -702,7 +702,7 @@ class AssembleVintfImpl : public AssembleVintf { | |||
702 | Istream mCheckFile; | 702 | Istream mCheckFile; |
703 | bool mOutputMatrix = false; | 703 | bool mOutputMatrix = false; |
704 | bool mHasSetHalsOnlyFlag = false; | 704 | bool mHasSetHalsOnlyFlag = false; |
705 | SerializeFlags mSerializeFlags = SerializeFlags::EVERYTHING; | 705 | SerializeFlags::Type mSerializeFlags = SerializeFlags::EVERYTHING; |
706 | std::map<KernelVersion, std::vector<NamedIstream>> mKernels; | 706 | std::map<KernelVersion, std::vector<NamedIstream>> mKernels; |
707 | std::map<std::string, std::string> mFakeEnv; | 707 | std::map<std::string, std::string> mFakeEnv; |
708 | }; | 708 | }; |
diff --git a/SerializeFlags.cpp b/SerializeFlags.cpp deleted file mode 100644 index 457d257..0000000 --- a/SerializeFlags.cpp +++ /dev/null | |||
@@ -1,76 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2018 The Android Open Source Project | ||
3 | * | ||
4 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
5 | * you may not use this file except in compliance with the License. | ||
6 | * You may obtain a copy of the License at | ||
7 | * | ||
8 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
9 | * | ||
10 | * Unless required by applicable law or agreed to in writing, software | ||
11 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
13 | * See the License for the specific language governing permissions and | ||
14 | * limitations under the License. | ||
15 | */ | ||
16 | |||
17 | #include <vintf/SerializeFlags.h> | ||
18 | |||
19 | namespace android { | ||
20 | namespace vintf { | ||
21 | |||
22 | SerializeFlags::SerializeFlags(uint32_t value) : mValue(value) {} | ||
23 | SerializeFlags::SerializeFlags(const SerializeFlags& other) : mValue(other.mValue) {} | ||
24 | |||
25 | #define VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(name, bit) \ | ||
26 | SerializeFlags SerializeFlags::enable##name() const { \ | ||
27 | SerializeFlags ret(*this); \ | ||
28 | ret.mValue |= 1 << bit; \ | ||
29 | return ret; \ | ||
30 | } \ | ||
31 | SerializeFlags SerializeFlags::disable##name() const { \ | ||
32 | SerializeFlags ret(*this); \ | ||
33 | ret.mValue &= ~(1 << bit); \ | ||
34 | return ret; \ | ||
35 | } \ | ||
36 | bool SerializeFlags::is##name##Enabled() const { return mValue & (1 << bit); } | ||
37 | |||
38 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Hals, 0) | ||
39 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Avb, 1) | ||
40 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Sepolicy, 2) | ||
41 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Vndk, 3) | ||
42 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Kernel, 4) | ||
43 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(XmlFiles, 5) | ||
44 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Ssdk, 6) | ||
45 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Fqname, 7) | ||
46 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(KernelConfigs, 8) | ||
47 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(KernelMinorRevision, 9) | ||
48 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(MetaVersion, 10) | ||
49 | VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(SchemaType, 11) | ||
50 | |||
51 | const SerializeFlags SerializeFlags::EVERYTHING = SerializeFlags(~0); | ||
52 | const SerializeFlags SerializeFlags::NO_HALS = EVERYTHING.disableHals(); | ||
53 | const SerializeFlags SerializeFlags::NO_AVB = EVERYTHING.disableAvb(); | ||
54 | const SerializeFlags SerializeFlags::NO_SEPOLICY = EVERYTHING.disableSepolicy(); | ||
55 | const SerializeFlags SerializeFlags::NO_VNDK = EVERYTHING.disableVndk(); | ||
56 | const SerializeFlags SerializeFlags::NO_KERNEL = EVERYTHING.disableKernel(); | ||
57 | const SerializeFlags SerializeFlags::NO_XMLFILES = EVERYTHING.disableXmlFiles(); | ||
58 | const SerializeFlags SerializeFlags::NO_SSDK = EVERYTHING.disableSsdk(); | ||
59 | const SerializeFlags SerializeFlags::NO_FQNAME = EVERYTHING.disableFqname(); | ||
60 | const SerializeFlags SerializeFlags::NO_KERNEL_CONFIGS = EVERYTHING.disableKernelConfigs(); | ||
61 | const SerializeFlags SerializeFlags::NO_KERNEL_MINOR_REVISION = | ||
62 | EVERYTHING.disableKernelMinorRevision(); | ||
63 | |||
64 | const SerializeFlags SerializeFlags::NO_TAGS = | ||
65 | SerializeFlags(0).enableMetaVersion().enableSchemaType(); | ||
66 | const SerializeFlags SerializeFlags::HALS_ONLY = | ||
67 | NO_TAGS.enableHals().enableFqname(); // <hal> with <fqname> | ||
68 | const SerializeFlags SerializeFlags::XMLFILES_ONLY = NO_TAGS.enableXmlFiles(); | ||
69 | const SerializeFlags SerializeFlags::SEPOLICY_ONLY = NO_TAGS.enableSepolicy(); | ||
70 | const SerializeFlags SerializeFlags::VNDK_ONLY = NO_TAGS.enableVndk(); | ||
71 | const SerializeFlags SerializeFlags::HALS_NO_FQNAME = | ||
72 | NO_TAGS.enableHals(); // <hal> without <fqname> | ||
73 | const SerializeFlags SerializeFlags::SSDK_ONLY = NO_TAGS.enableSsdk(); | ||
74 | |||
75 | } // namespace vintf | ||
76 | } // namespace android | ||
diff --git a/include/vintf/SerializeFlags.h b/include/vintf/SerializeFlags.h index b377541..909a331 100644 --- a/include/vintf/SerializeFlags.h +++ b/include/vintf/SerializeFlags.h | |||
@@ -22,56 +22,69 @@ | |||
22 | namespace android { | 22 | namespace android { |
23 | namespace vintf { | 23 | namespace vintf { |
24 | 24 | ||
25 | class SerializeFlags { | 25 | namespace SerializeFlags { |
26 | public: | ||
27 | SerializeFlags(const SerializeFlags& other); | ||
28 | |||
29 | #define VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(name) \ | ||
30 | SerializeFlags enable##name() const; \ | ||
31 | SerializeFlags disable##name() const; \ | ||
32 | bool is##name##Enabled() const; | ||
33 | 26 | ||
34 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Hals) | 27 | class Type { |
35 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Avb) | 28 | public: |
36 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Sepolicy) | 29 | explicit constexpr Type(uint32_t value) : mValue(value) {} |
37 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Vndk) | ||
38 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Kernel) | ||
39 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(XmlFiles) | ||
40 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Ssdk) | ||
41 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Fqname) | ||
42 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(KernelConfigs) | ||
43 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(KernelMinorRevision) | ||
44 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(MetaVersion) | ||
45 | VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(SchemaType) | ||
46 | 30 | ||
47 | #undef VINTF_SERIALIZE_FLAGS_FIELD_DECLARE | 31 | #define VINTF_SERIALIZE_FLAGS_FIELD(name, bit) \ |
32 | constexpr Type enable##name() const { return Type(mValue | (1 << bit)); } \ | ||
33 | constexpr Type disable##name() const { return Type(mValue & ~(1 << bit)); } \ | ||
34 | constexpr bool is##name##Enabled() const { return mValue & (1 << bit); } | ||
48 | 35 | ||
49 | static const SerializeFlags NO_HALS; | 36 | VINTF_SERIALIZE_FLAGS_FIELD(Hals, 0) |
50 | static const SerializeFlags NO_AVB; | 37 | VINTF_SERIALIZE_FLAGS_FIELD(Avb, 1) |
51 | static const SerializeFlags NO_SEPOLICY; | 38 | VINTF_SERIALIZE_FLAGS_FIELD(Sepolicy, 2) |
52 | static const SerializeFlags NO_VNDK; | 39 | VINTF_SERIALIZE_FLAGS_FIELD(Vndk, 3) |
53 | static const SerializeFlags NO_KERNEL; | 40 | VINTF_SERIALIZE_FLAGS_FIELD(Kernel, 4) |
54 | static const SerializeFlags NO_XMLFILES; | 41 | VINTF_SERIALIZE_FLAGS_FIELD(XmlFiles, 5) |
55 | static const SerializeFlags NO_SSDK; | 42 | VINTF_SERIALIZE_FLAGS_FIELD(Ssdk, 6) |
56 | static const SerializeFlags NO_FQNAME; | 43 | VINTF_SERIALIZE_FLAGS_FIELD(Fqname, 7) |
57 | static const SerializeFlags NO_KERNEL_CONFIGS; | 44 | VINTF_SERIALIZE_FLAGS_FIELD(KernelConfigs, 8) |
58 | static const SerializeFlags NO_KERNEL_MINOR_REVISION; | 45 | VINTF_SERIALIZE_FLAGS_FIELD(KernelMinorRevision, 9) |
46 | VINTF_SERIALIZE_FLAGS_FIELD(MetaVersion, 10) | ||
47 | VINTF_SERIALIZE_FLAGS_FIELD(SchemaType, 11) | ||
59 | 48 | ||
60 | static const SerializeFlags EVERYTHING; | 49 | #undef VINTF_SERIALIZE_FLAGS_FIELD |
61 | static const SerializeFlags NO_TAGS; | ||
62 | static const SerializeFlags HALS_ONLY; | ||
63 | static const SerializeFlags XMLFILES_ONLY; | ||
64 | static const SerializeFlags SEPOLICY_ONLY; | ||
65 | static const SerializeFlags VNDK_ONLY; | ||
66 | static const SerializeFlags HALS_NO_FQNAME; | ||
67 | static const SerializeFlags SSDK_ONLY; | ||
68 | 50 | ||
69 | private: | 51 | private: |
70 | uint32_t mValue; | 52 | uint32_t mValue; |
71 | |||
72 | SerializeFlags(uint32_t value); | ||
73 | }; | 53 | }; |
74 | 54 | ||
55 | constexpr Type EVERYTHING = Type(~0); | ||
56 | constexpr Type NO_HALS = EVERYTHING.disableHals(); | ||
57 | constexpr Type NO_AVB = EVERYTHING.disableAvb(); | ||
58 | constexpr Type NO_SEPOLICY = EVERYTHING.disableSepolicy(); | ||
59 | constexpr Type NO_VNDK = EVERYTHING.disableVndk(); | ||
60 | constexpr Type NO_KERNEL = EVERYTHING.disableKernel(); | ||
61 | constexpr Type NO_XMLFILES = EVERYTHING.disableXmlFiles(); | ||
62 | constexpr Type NO_SSDK = EVERYTHING.disableSsdk(); | ||
63 | constexpr Type NO_FQNAME = EVERYTHING.disableFqname(); | ||
64 | constexpr Type NO_KERNEL_CONFIGS = EVERYTHING.disableKernelConfigs(); | ||
65 | constexpr Type NO_KERNEL_MINOR_REVISION = EVERYTHING.disableKernelMinorRevision(); | ||
66 | |||
67 | constexpr Type NO_TAGS = Type(0).enableMetaVersion().enableSchemaType(); | ||
68 | constexpr Type HALS_ONLY = NO_TAGS.enableHals().enableFqname(); // <hal> with <fqname> | ||
69 | constexpr Type XMLFILES_ONLY = NO_TAGS.enableXmlFiles(); | ||
70 | constexpr Type SEPOLICY_ONLY = NO_TAGS.enableSepolicy(); | ||
71 | constexpr Type VNDK_ONLY = NO_TAGS.enableVndk(); | ||
72 | constexpr Type HALS_NO_FQNAME = NO_TAGS.enableHals(); // <hal> without <fqname> | ||
73 | constexpr Type SSDK_ONLY = NO_TAGS.enableSsdk(); | ||
74 | |||
75 | // tests | ||
76 | static_assert(EVERYTHING.isHalsEnabled(), ""); | ||
77 | static_assert(EVERYTHING.isMetaVersionEnabled(), ""); | ||
78 | static_assert(!NO_HALS.isHalsEnabled(), ""); | ||
79 | static_assert(NO_HALS.isAvbEnabled(), ""); | ||
80 | static_assert(NO_HALS.isMetaVersionEnabled(), ""); | ||
81 | static_assert(!NO_TAGS.isHalsEnabled(), ""); | ||
82 | static_assert(NO_TAGS.isMetaVersionEnabled(), ""); | ||
83 | static_assert(HALS_ONLY.isHalsEnabled(), ""); | ||
84 | static_assert(!HALS_ONLY.isAvbEnabled(), ""); | ||
85 | static_assert(HALS_ONLY.isMetaVersionEnabled(), ""); | ||
86 | |||
87 | } // namespace SerializeFlags | ||
75 | } // namespace vintf | 88 | } // namespace vintf |
76 | } // namespace android | 89 | } // namespace android |
77 | 90 | ||
diff --git a/include/vintf/parse_xml.h b/include/vintf/parse_xml.h index b24c3b2..4fe1626 100644 --- a/include/vintf/parse_xml.h +++ b/include/vintf/parse_xml.h | |||
@@ -32,12 +32,12 @@ struct XmlConverter { | |||
32 | virtual const std::string &lastError() const = 0; | 32 | virtual const std::string &lastError() const = 0; |
33 | 33 | ||
34 | // deprecated. Use operator() instead. | 34 | // deprecated. Use operator() instead. |
35 | virtual std::string serialize(const Object& o, | 35 | virtual std::string serialize( |
36 | SerializeFlags flags = SerializeFlags::EVERYTHING) const = 0; | 36 | const Object& o, SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const = 0; |
37 | 37 | ||
38 | // Serialize an object to XML. | 38 | // Serialize an object to XML. |
39 | virtual std::string operator()(const Object& o, | 39 | virtual std::string operator()( |
40 | SerializeFlags flags = SerializeFlags::EVERYTHING) const = 0; | 40 | const Object& o, SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const = 0; |
41 | 41 | ||
42 | // deprecated. Use operator() instead. These APIs sets lastError(). Kept for testing. | 42 | // deprecated. Use operator() instead. These APIs sets lastError(). Kept for testing. |
43 | virtual bool deserialize(Object* o, const std::string& xml) = 0; | 43 | virtual bool deserialize(Object* o, const std::string& xml) = 0; |
@@ -266,7 +266,7 @@ int main(int argc, char** argv) { | |||
266 | std::cout << std::endl; | 266 | std::cout << std::endl; |
267 | } | 267 | } |
268 | 268 | ||
269 | SerializeFlags flags = SerializeFlags::EVERYTHING; | 269 | SerializeFlags::Type flags = SerializeFlags::EVERYTHING; |
270 | if (!options.verbose) { | 270 | if (!options.verbose) { |
271 | flags = flags.disableHals().disableKernel(); | 271 | flags = flags.disableHals().disableKernel(); |
272 | } | 272 | } |
diff --git a/parse_xml.cpp b/parse_xml.cpp index ff6ecc2..0cc514d 100644 --- a/parse_xml.cpp +++ b/parse_xml.cpp | |||
@@ -141,7 +141,7 @@ struct XmlNodeConverter : public XmlConverter<Object> { | |||
141 | 141 | ||
142 | // sub-types should implement these. | 142 | // sub-types should implement these. |
143 | virtual void mutateNode(const Object &o, NodeType *n, DocType *d) const = 0; | 143 | virtual void mutateNode(const Object &o, NodeType *n, DocType *d) const = 0; |
144 | virtual void mutateNode(const Object& o, NodeType* n, DocType* d, SerializeFlags) const { | 144 | virtual void mutateNode(const Object& o, NodeType* n, DocType* d, SerializeFlags::Type) const { |
145 | mutateNode(o, n, d); | 145 | mutateNode(o, n, d); |
146 | } | 146 | } |
147 | virtual bool buildObject(Object* o, NodeType* n, std::string* error) const = 0; | 147 | virtual bool buildObject(Object* o, NodeType* n, std::string* error) const = 0; |
@@ -150,12 +150,12 @@ struct XmlNodeConverter : public XmlConverter<Object> { | |||
150 | // convenience methods for user | 150 | // convenience methods for user |
151 | inline const std::string& lastError() const override { return mLastError; } | 151 | inline const std::string& lastError() const override { return mLastError; } |
152 | inline NodeType* serialize(const Object& o, DocType* d, | 152 | inline NodeType* serialize(const Object& o, DocType* d, |
153 | SerializeFlags flags = SerializeFlags::EVERYTHING) const { | 153 | SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const { |
154 | NodeType *root = createNode(this->elementName(), d); | 154 | NodeType *root = createNode(this->elementName(), d); |
155 | this->mutateNode(o, root, d, flags); | 155 | this->mutateNode(o, root, d, flags); |
156 | return root; | 156 | return root; |
157 | } | 157 | } |
158 | inline std::string serialize(const Object& o, SerializeFlags flags) const override { | 158 | inline std::string serialize(const Object& o, SerializeFlags::Type flags) const override { |
159 | DocType *doc = createDocument(); | 159 | DocType *doc = createDocument(); |
160 | appendChild(doc, serialize(o, doc, flags)); | 160 | appendChild(doc, serialize(o, doc, flags)); |
161 | std::string s = printDocument(doc); | 161 | std::string s = printDocument(doc); |
@@ -192,7 +192,7 @@ struct XmlNodeConverter : public XmlConverter<Object> { | |||
192 | inline NodeType *operator()(const Object &o, DocType *d) const { | 192 | inline NodeType *operator()(const Object &o, DocType *d) const { |
193 | return serialize(o, d); | 193 | return serialize(o, d); |
194 | } | 194 | } |
195 | inline std::string operator()(const Object& o, SerializeFlags flags) const override { | 195 | inline std::string operator()(const Object& o, SerializeFlags::Type flags) const override { |
196 | return serialize(o, flags); | 196 | return serialize(o, flags); |
197 | } | 197 | } |
198 | inline bool operator()(Object* o, NodeType* node) { return deserialize(o, node); } | 198 | inline bool operator()(Object* o, NodeType* node) { return deserialize(o, node); } |
@@ -234,7 +234,7 @@ struct XmlNodeConverter : public XmlConverter<Object> { | |||
234 | template <typename T, typename Array> | 234 | template <typename T, typename Array> |
235 | inline void appendChildren(NodeType* parent, const XmlNodeConverter<T>& conv, | 235 | inline void appendChildren(NodeType* parent, const XmlNodeConverter<T>& conv, |
236 | const Array& array, DocType* d, | 236 | const Array& array, DocType* d, |
237 | SerializeFlags flags = SerializeFlags::EVERYTHING) const { | 237 | SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const { |
238 | for (const T &t : array) { | 238 | for (const T &t : array) { |
239 | appendChild(parent, conv.serialize(t, d, flags)); | 239 | appendChild(parent, conv.serialize(t, d, flags)); |
240 | } | 240 | } |
@@ -605,7 +605,7 @@ struct MatrixKernelConverter : public XmlNodeConverter<MatrixKernel> { | |||
605 | mutateNode(kernel, root, d, SerializeFlags::EVERYTHING); | 605 | mutateNode(kernel, root, d, SerializeFlags::EVERYTHING); |
606 | } | 606 | } |
607 | void mutateNode(const MatrixKernel& kernel, NodeType* root, DocType* d, | 607 | void mutateNode(const MatrixKernel& kernel, NodeType* root, DocType* d, |
608 | SerializeFlags flags) const override { | 608 | SerializeFlags::Type flags) const override { |
609 | KernelVersion kv = kernel.mMinLts; | 609 | KernelVersion kv = kernel.mMinLts; |
610 | if (!flags.isKernelMinorRevisionEnabled()) { | 610 | if (!flags.isKernelMinorRevisionEnabled()) { |
611 | kv.minorRev = 0u; | 611 | kv.minorRev = 0u; |
@@ -640,7 +640,7 @@ struct ManifestHalConverter : public XmlNodeConverter<ManifestHal> { | |||
640 | mutateNode(m, root, d, SerializeFlags::EVERYTHING); | 640 | mutateNode(m, root, d, SerializeFlags::EVERYTHING); |
641 | } | 641 | } |
642 | void mutateNode(const ManifestHal& hal, NodeType* root, DocType* d, | 642 | void mutateNode(const ManifestHal& hal, NodeType* root, DocType* d, |
643 | SerializeFlags flags) const override { | 643 | SerializeFlags::Type flags) const override { |
644 | appendAttr(root, "format", hal.format); | 644 | appendAttr(root, "format", hal.format); |
645 | appendTextElement(root, "name", hal.name, d); | 645 | appendTextElement(root, "name", hal.name, d); |
646 | appendChild(root, transportArchConverter(hal.transportArch, d)); | 646 | appendChild(root, transportArchConverter(hal.transportArch, d)); |
@@ -864,7 +864,7 @@ struct HalManifestConverter : public XmlNodeConverter<HalManifest> { | |||
864 | mutateNode(m, root, d, SerializeFlags::EVERYTHING); | 864 | mutateNode(m, root, d, SerializeFlags::EVERYTHING); |
865 | } | 865 | } |
866 | void mutateNode(const HalManifest& m, NodeType* root, DocType* d, | 866 | void mutateNode(const HalManifest& m, NodeType* root, DocType* d, |
867 | SerializeFlags flags) const override { | 867 | SerializeFlags::Type flags) const override { |
868 | if (flags.isMetaVersionEnabled()) { | 868 | if (flags.isMetaVersionEnabled()) { |
869 | appendAttr(root, "version", m.getMetaVersion()); | 869 | appendAttr(root, "version", m.getMetaVersion()); |
870 | } | 870 | } |
@@ -1031,7 +1031,7 @@ struct CompatibilityMatrixConverter : public XmlNodeConverter<CompatibilityMatri | |||
1031 | mutateNode(m, root, d, SerializeFlags::EVERYTHING); | 1031 | mutateNode(m, root, d, SerializeFlags::EVERYTHING); |
1032 | } | 1032 | } |
1033 | void mutateNode(const CompatibilityMatrix& m, NodeType* root, DocType* d, | 1033 | void mutateNode(const CompatibilityMatrix& m, NodeType* root, DocType* d, |
1034 | SerializeFlags flags) const override { | 1034 | SerializeFlags::Type flags) const override { |
1035 | if (flags.isMetaVersionEnabled()) { | 1035 | if (flags.isMetaVersionEnabled()) { |
1036 | appendAttr(root, "version", m.getMinimumMetaVersion()); | 1036 | appendAttr(root, "version", m.getMinimumMetaVersion()); |
1037 | } | 1037 | } |