SerializeFlags is a namespace.

The SerializeFlags becomes a namespace that contains
the original class definition under type SerializeFlags::Type
and static constants.

Consequently, all SeralizeFlags methods can
now be constexpr.

Also added static tests.

Test: libvintf_test
Test: vintf_object_test
Bug: 110711640
Change-Id: I786a1f77e19defc2ab2d025de3ed7cfe48f4fbce

7 files changed, 69 insertions, 133 deletions

diff --git a/Android.bp b/Android.bp
index 1a441fc..4689832 100644
--- a/Android.bp
+++ b/Android.bp
@@ -53,7 +53,6 @@ cc_library {
         "MatrixKernel.cpp",
         "PropertyFetcher.cpp",
         "Regex.cpp",
-        "SerializeFlags.cpp",
         "SystemSdk.cpp",
         "TransportArch.cpp",
         "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 {
     Istream mCheckFile;
     bool mOutputMatrix = false;
     bool mHasSetHalsOnlyFlag = false;
-    SerializeFlags mSerializeFlags = SerializeFlags::EVERYTHING;
+    SerializeFlags::Type mSerializeFlags = SerializeFlags::EVERYTHING;
     std::map<KernelVersion, std::vector<NamedIstream>> mKernels;
     std::map<std::string, std::string> mFakeEnv;
 };
diff --git a/SerializeFlags.cpp b/SerializeFlags.cpp
deleted file mode 100644
index 457d257..0000000
--- a/SerializeFlags.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <vintf/SerializeFlags.h>
-
-namespace android {
-namespace vintf {
-
-SerializeFlags::SerializeFlags(uint32_t value) : mValue(value) {}
-SerializeFlags::SerializeFlags(const SerializeFlags& other) : mValue(other.mValue) {}
-
-#define VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(name, bit)      \
-    SerializeFlags SerializeFlags::enable##name() const {  \
-        SerializeFlags ret(*this);                         \
-        ret.mValue |= 1 << bit;                            \
-        return ret;                                        \
-    }                                                      \
-    SerializeFlags SerializeFlags::disable##name() const { \
-        SerializeFlags ret(*this);                         \
-        ret.mValue &= ~(1 << bit);                         \
-        return ret;                                        \
-    }                                                      \
-    bool SerializeFlags::is##name##Enabled() const { return mValue & (1 << bit); }
-
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Hals, 0)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Avb, 1)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Sepolicy, 2)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Vndk, 3)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Kernel, 4)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(XmlFiles, 5)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Ssdk, 6)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(Fqname, 7)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(KernelConfigs, 8)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(KernelMinorRevision, 9)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(MetaVersion, 10)
-VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(SchemaType, 11)
-
-const SerializeFlags SerializeFlags::EVERYTHING = SerializeFlags(~0);
-const SerializeFlags SerializeFlags::NO_HALS = EVERYTHING.disableHals();
-const SerializeFlags SerializeFlags::NO_AVB = EVERYTHING.disableAvb();
-const SerializeFlags SerializeFlags::NO_SEPOLICY = EVERYTHING.disableSepolicy();
-const SerializeFlags SerializeFlags::NO_VNDK = EVERYTHING.disableVndk();
-const SerializeFlags SerializeFlags::NO_KERNEL = EVERYTHING.disableKernel();
-const SerializeFlags SerializeFlags::NO_XMLFILES = EVERYTHING.disableXmlFiles();
-const SerializeFlags SerializeFlags::NO_SSDK = EVERYTHING.disableSsdk();
-const SerializeFlags SerializeFlags::NO_FQNAME = EVERYTHING.disableFqname();
-const SerializeFlags SerializeFlags::NO_KERNEL_CONFIGS = EVERYTHING.disableKernelConfigs();
-const SerializeFlags SerializeFlags::NO_KERNEL_MINOR_REVISION =
-    EVERYTHING.disableKernelMinorRevision();
-
-const SerializeFlags SerializeFlags::NO_TAGS =
-    SerializeFlags(0).enableMetaVersion().enableSchemaType();
-const SerializeFlags SerializeFlags::HALS_ONLY =
-    NO_TAGS.enableHals().enableFqname();  // <hal> with <fqname>
-const SerializeFlags SerializeFlags::XMLFILES_ONLY = NO_TAGS.enableXmlFiles();
-const SerializeFlags SerializeFlags::SEPOLICY_ONLY = NO_TAGS.enableSepolicy();
-const SerializeFlags SerializeFlags::VNDK_ONLY = NO_TAGS.enableVndk();
-const SerializeFlags SerializeFlags::HALS_NO_FQNAME =
-    NO_TAGS.enableHals();  // <hal> without <fqname>
-const SerializeFlags SerializeFlags::SSDK_ONLY = NO_TAGS.enableSsdk();
-
-}  // namespace vintf
-}  // 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 @@
 namespace android {
 namespace vintf {
 
-class SerializeFlags {
-   public:
-    SerializeFlags(const SerializeFlags& other);
-
-#define VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(name) \
-    SerializeFlags enable##name() const;          \
-    SerializeFlags disable##name() const;         \
-    bool is##name##Enabled() const;
+namespace SerializeFlags {
 
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Hals)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Avb)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Sepolicy)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Vndk)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Kernel)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(XmlFiles)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Ssdk)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(Fqname)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(KernelConfigs)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(KernelMinorRevision)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(MetaVersion)
-    VINTF_SERIALIZE_FLAGS_FIELD_DECLARE(SchemaType)
+class Type {
+   public:
+    explicit constexpr Type(uint32_t value) : mValue(value) {}
 
-#undef VINTF_SERIALIZE_FLAGS_FIELD_DECLARE
+#define VINTF_SERIALIZE_FLAGS_FIELD(name, bit)                                  \
+    constexpr Type enable##name() const { return Type(mValue | (1 << bit)); }   \
+    constexpr Type disable##name() const { return Type(mValue & ~(1 << bit)); } \
+    constexpr bool is##name##Enabled() const { return mValue & (1 << bit); }
 
-    static const SerializeFlags NO_HALS;
-    static const SerializeFlags NO_AVB;
-    static const SerializeFlags NO_SEPOLICY;
-    static const SerializeFlags NO_VNDK;
-    static const SerializeFlags NO_KERNEL;
-    static const SerializeFlags NO_XMLFILES;
-    static const SerializeFlags NO_SSDK;
-    static const SerializeFlags NO_FQNAME;
-    static const SerializeFlags NO_KERNEL_CONFIGS;
-    static const SerializeFlags NO_KERNEL_MINOR_REVISION;
+    VINTF_SERIALIZE_FLAGS_FIELD(Hals, 0)
+    VINTF_SERIALIZE_FLAGS_FIELD(Avb, 1)
+    VINTF_SERIALIZE_FLAGS_FIELD(Sepolicy, 2)
+    VINTF_SERIALIZE_FLAGS_FIELD(Vndk, 3)
+    VINTF_SERIALIZE_FLAGS_FIELD(Kernel, 4)
+    VINTF_SERIALIZE_FLAGS_FIELD(XmlFiles, 5)
+    VINTF_SERIALIZE_FLAGS_FIELD(Ssdk, 6)
+    VINTF_SERIALIZE_FLAGS_FIELD(Fqname, 7)
+    VINTF_SERIALIZE_FLAGS_FIELD(KernelConfigs, 8)
+    VINTF_SERIALIZE_FLAGS_FIELD(KernelMinorRevision, 9)
+    VINTF_SERIALIZE_FLAGS_FIELD(MetaVersion, 10)
+    VINTF_SERIALIZE_FLAGS_FIELD(SchemaType, 11)
 
-    static const SerializeFlags EVERYTHING;
-    static const SerializeFlags NO_TAGS;
-    static const SerializeFlags HALS_ONLY;
-    static const SerializeFlags XMLFILES_ONLY;
-    static const SerializeFlags SEPOLICY_ONLY;
-    static const SerializeFlags VNDK_ONLY;
-    static const SerializeFlags HALS_NO_FQNAME;
-    static const SerializeFlags SSDK_ONLY;
+#undef VINTF_SERIALIZE_FLAGS_FIELD
 
    private:
     uint32_t mValue;
-
-    SerializeFlags(uint32_t value);
 };
 
+constexpr Type EVERYTHING = Type(~0);
+constexpr Type NO_HALS = EVERYTHING.disableHals();
+constexpr Type NO_AVB = EVERYTHING.disableAvb();
+constexpr Type NO_SEPOLICY = EVERYTHING.disableSepolicy();
+constexpr Type NO_VNDK = EVERYTHING.disableVndk();
+constexpr Type NO_KERNEL = EVERYTHING.disableKernel();
+constexpr Type NO_XMLFILES = EVERYTHING.disableXmlFiles();
+constexpr Type NO_SSDK = EVERYTHING.disableSsdk();
+constexpr Type NO_FQNAME = EVERYTHING.disableFqname();
+constexpr Type NO_KERNEL_CONFIGS = EVERYTHING.disableKernelConfigs();
+constexpr Type NO_KERNEL_MINOR_REVISION = EVERYTHING.disableKernelMinorRevision();
+
+constexpr Type NO_TAGS = Type(0).enableMetaVersion().enableSchemaType();
+constexpr Type HALS_ONLY = NO_TAGS.enableHals().enableFqname();  // <hal> with <fqname>
+constexpr Type XMLFILES_ONLY = NO_TAGS.enableXmlFiles();
+constexpr Type SEPOLICY_ONLY = NO_TAGS.enableSepolicy();
+constexpr Type VNDK_ONLY = NO_TAGS.enableVndk();
+constexpr Type HALS_NO_FQNAME = NO_TAGS.enableHals();  // <hal> without <fqname>
+constexpr Type SSDK_ONLY = NO_TAGS.enableSsdk();
+
+// tests
+static_assert(EVERYTHING.isHalsEnabled(), "");
+static_assert(EVERYTHING.isMetaVersionEnabled(), "");
+static_assert(!NO_HALS.isHalsEnabled(), "");
+static_assert(NO_HALS.isAvbEnabled(), "");
+static_assert(NO_HALS.isMetaVersionEnabled(), "");
+static_assert(!NO_TAGS.isHalsEnabled(), "");
+static_assert(NO_TAGS.isMetaVersionEnabled(), "");
+static_assert(HALS_ONLY.isHalsEnabled(), "");
+static_assert(!HALS_ONLY.isAvbEnabled(), "");
+static_assert(HALS_ONLY.isMetaVersionEnabled(), "");
+
+}  // namespace SerializeFlags
 }  // namespace vintf
 }  // namespace android
 
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 {
     virtual const std::string &lastError() const = 0;
 
     // deprecated. Use operator() instead.
-    virtual std::string serialize(const Object& o,
-                                  SerializeFlags flags = SerializeFlags::EVERYTHING) const = 0;
+    virtual std::string serialize(
+        const Object& o, SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const = 0;
 
     // Serialize an object to XML.
-    virtual std::string operator()(const Object& o,
-                                   SerializeFlags flags = SerializeFlags::EVERYTHING) const = 0;
+    virtual std::string operator()(
+        const Object& o, SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const = 0;
 
     // deprecated. Use operator() instead. These APIs sets lastError(). Kept for testing.
     virtual bool deserialize(Object* o, const std::string& xml) = 0;
diff --git a/main.cpp b/main.cpp
index f766358..baac511 100644
--- a/main.cpp
+++ b/main.cpp
@@ -266,7 +266,7 @@ int main(int argc, char** argv) {
         std::cout << std::endl;
     }
 
-    SerializeFlags flags = SerializeFlags::EVERYTHING;
+    SerializeFlags::Type flags = SerializeFlags::EVERYTHING;
     if (!options.verbose) {
         flags = flags.disableHals().disableKernel();
     }
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> {
 
     // sub-types should implement these.
     virtual void mutateNode(const Object &o, NodeType *n, DocType *d) const = 0;
-    virtual void mutateNode(const Object& o, NodeType* n, DocType* d, SerializeFlags) const {
+    virtual void mutateNode(const Object& o, NodeType* n, DocType* d, SerializeFlags::Type) const {
         mutateNode(o, n, d);
     }
     virtual bool buildObject(Object* o, NodeType* n, std::string* error) const = 0;
@@ -150,12 +150,12 @@ struct XmlNodeConverter : public XmlConverter<Object> {
     // convenience methods for user
     inline const std::string& lastError() const override { return mLastError; }
     inline NodeType* serialize(const Object& o, DocType* d,
-                               SerializeFlags flags = SerializeFlags::EVERYTHING) const {
+                               SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const {
         NodeType *root = createNode(this->elementName(), d);
         this->mutateNode(o, root, d, flags);
         return root;
     }
-    inline std::string serialize(const Object& o, SerializeFlags flags) const override {
+    inline std::string serialize(const Object& o, SerializeFlags::Type flags) const override {
         DocType *doc = createDocument();
         appendChild(doc, serialize(o, doc, flags));
         std::string s = printDocument(doc);
@@ -192,7 +192,7 @@ struct XmlNodeConverter : public XmlConverter<Object> {
     inline NodeType *operator()(const Object &o, DocType *d) const {
         return serialize(o, d);
     }
-    inline std::string operator()(const Object& o, SerializeFlags flags) const override {
+    inline std::string operator()(const Object& o, SerializeFlags::Type flags) const override {
         return serialize(o, flags);
     }
     inline bool operator()(Object* o, NodeType* node) { return deserialize(o, node); }
@@ -234,7 +234,7 @@ struct XmlNodeConverter : public XmlConverter<Object> {
     template <typename T, typename Array>
     inline void appendChildren(NodeType* parent, const XmlNodeConverter<T>& conv,
                                const Array& array, DocType* d,
-                               SerializeFlags flags = SerializeFlags::EVERYTHING) const {
+                               SerializeFlags::Type flags = SerializeFlags::EVERYTHING) const {
         for (const T &t : array) {
             appendChild(parent, conv.serialize(t, d, flags));
         }
@@ -605,7 +605,7 @@ struct MatrixKernelConverter : public XmlNodeConverter<MatrixKernel> {
         mutateNode(kernel, root, d, SerializeFlags::EVERYTHING);
     }
     void mutateNode(const MatrixKernel& kernel, NodeType* root, DocType* d,
-                    SerializeFlags flags) const override {
+                    SerializeFlags::Type flags) const override {
         KernelVersion kv = kernel.mMinLts;
         if (!flags.isKernelMinorRevisionEnabled()) {
             kv.minorRev = 0u;
@@ -640,7 +640,7 @@ struct ManifestHalConverter : public XmlNodeConverter<ManifestHal> {
         mutateNode(m, root, d, SerializeFlags::EVERYTHING);
     }
     void mutateNode(const ManifestHal& hal, NodeType* root, DocType* d,
-                    SerializeFlags flags) const override {
+                    SerializeFlags::Type flags) const override {
         appendAttr(root, "format", hal.format);
         appendTextElement(root, "name", hal.name, d);
         appendChild(root, transportArchConverter(hal.transportArch, d));
@@ -864,7 +864,7 @@ struct HalManifestConverter : public XmlNodeConverter<HalManifest> {
         mutateNode(m, root, d, SerializeFlags::EVERYTHING);
     }
     void mutateNode(const HalManifest& m, NodeType* root, DocType* d,
-                    SerializeFlags flags) const override {
+                    SerializeFlags::Type flags) const override {
         if (flags.isMetaVersionEnabled()) {
             appendAttr(root, "version", m.getMetaVersion());
         }
@@ -1031,7 +1031,7 @@ struct CompatibilityMatrixConverter : public XmlNodeConverter<CompatibilityMatri
         mutateNode(m, root, d, SerializeFlags::EVERYTHING);
     }
     void mutateNode(const CompatibilityMatrix& m, NodeType* root, DocType* d,
-                    SerializeFlags flags) const override {
+                    SerializeFlags::Type flags) const override {
         if (flags.isMetaVersionEnabled()) {
             appendAttr(root, "version", m.getMinimumMetaVersion());
         }