Updated the code with Kamil's code proposal

Signed-off-by: saksarav <sakthivadivu.saravanaraj@nokia.com>

Author: saksarav-nokia

meta/SaiSerialize.cpp

@@ -821,31 +821,47 @@ std::string sai_serialize_number(
     return std::to_string(number);
 }
 
-std::string sai_serialize_enum(
-        _In_ const int32_t value,
+// internal
+static std::string sai_serialize_flags(
+        _In_ int32_t value,
         _In_ const sai_enum_metadata_t* meta)
 {
     SWSS_LOG_ENTER();
 
-    if (meta == NULL)
-    {
-        return sai_serialize_number(value);
-    }
+    if (value == 0)
+        return meta->values[0] ? "0x0" : meta->valuesnames[0];
+
+    std::string s;
+
+    s.reserve(1024);
 
     for (size_t i = 0; i < meta->valuescount; ++i)
     {
-        if (meta->values[i] == value)
+        if (value & meta->values[i])
         {
-            return meta->valuesnames[i];
+            if (s.size())
+                s.append("|");
+
+            s += meta->valuesnames[i];
+
+            value &= ~meta->values[i];
         }
     }
 
-    SWSS_LOG_WARN("enum value %d not found in enum %s", value, meta->name);
+    if (value)
+    {
+        SWSS_LOG_WARN("unrecognized flags: 0x%x in enum %s", value, meta->name);
 
-    return sai_serialize_number(value);
+        if (s.size())
+            s.append("|");
+
+        s += sai_serialize_number<uint32_t>(value, true);
+    }
+
+    return s;
 }
 
-std::string sai_serialize_flags(
+std::string sai_serialize_enum(
         _In_ const int32_t value,
         _In_ const sai_enum_metadata_t* meta)
 {
@@ -856,68 +872,22 @@ std::string sai_serialize_flags(
         return sai_serialize_number(value);
     }
 
-    if (!meta->containsflags || meta->flagstype != SAI_ENUM_FLAGS_TYPE_STRICT)
-    {
-        return sai_serialize_enum(value, meta);
-    }
-
-    uint32_t flags = static_cast<uint32_t>(value);
-    std::string s;
-    const size_t n = meta->valuescount;
-    if (n != 0)
-    {
-        // The current strict flags longer enum is 50 characters, so setting to 64
-        s.reserve(std::min(n * size_t(64), size_t(2048)));
-
-        if ( !value)
-        {
-           s += meta->valuesnames[0];
-           return s;
-        }
-    }
-
-    bool first = true;
-    for (size_t i = 0; i < n; ++i)
+    if (meta->flagstype == SAI_ENUM_FLAGS_TYPE_STRICT)
     {
-        const int32_t v = meta->values[i];
-        if (v == 0)
-        {
-            continue;
-        }
-
-        const uint32_t bit = static_cast<uint32_t>(v);
-        if ((flags & bit) != 0)
-        {
-            if (!first)
-            {
-                s.push_back('|');
-            }
-            first = false;
-            s += meta->valuesnames[i];
-            flags &= ~bit;
-        }
+        return sai_serialize_flags(value, meta);
     }
 
-    if (flags != 0)
+    for (size_t i = 0; i < meta->valuescount; ++i)
     {
-        SWSS_LOG_WARN("enum %s strict flags value 0x%x has unknown bits 0x%x",
-                meta->name,
-                static_cast<unsigned int>(static_cast<uint32_t>(value)),
-                flags);
-        if (!first)
+        if (meta->values[i] == value)
         {
-            s.push_back('|');
+            return meta->valuesnames[i];
         }
-        s += sai_serialize_number(flags, true);
-        return s;
     }
 
-    if (first)
-    {
-        return sai_serialize_number(value);
-    }
+    SWSS_LOG_WARN("enum value %d not found in enum %s", value, meta->name);
 
-    return s;
+    return sai_serialize_number(value);
 }
 
 std::string sai_serialize_number(
@@ -2627,7 +2597,7 @@ std::string sai_serialize_port_error_status(
 {
     SWSS_LOG_ENTER();
 
-    return sai_serialize_flags(status, &sai_metadata_enum_sai_port_error_status_t);
+    return sai_serialize_enum(status, &sai_metadata_enum_sai_port_error_status_t);
 }
 
 std::string sai_serialize_port_host_tx_ready(
@@ -3741,6 +3711,46 @@ void sai_deserialize_number(
     sai_deserialize_number<uint32_t>(s, number, hex);
 }
 
+
+// internal
+static void sai_deserialize_flags(
+        _In_ const std::string& s,
+        _In_ const sai_enum_metadata_t *meta,
+        _Out_ int32_t& value)
+{
+    SWSS_LOG_ENTER();
+
+    value = 0;
+
+    const auto tokens = swss::tokenize(s, '|');
+
+    for (auto& v: tokens)
+    {
+        if (v[0] == '0')
+        {
+            uint32_t val;
+            sai_deserialize_number(v, val, true);
+
+            value |= val;
+            continue;
+        }
+
+        for (size_t i = 0; i < meta->valuescount; ++i)
+        {
+            if (v == meta->valuesnames[i])
+            {
+                value |= meta->values[i];
+                break;
+            }
+        }
+        if (i == meta->valuescount)
+        {
+            // v is empty or doesn't match any enum
+            SWSS_LOG_WARN("%s in %s has invalid enum for %s", v.c_str(), s.c_str(), meta->name);
+        }
+    }
+}
+
 void sai_deserialize_enum(
         _In_ const std::string& s,
         _In_ const sai_enum_metadata_t *meta,
@@ -3753,6 +3763,11 @@ void sai_deserialize_enum(
         return sai_deserialize_number(s, value);
     }
 
+    if (meta->flagstype == SAI_ENUM_FLAGS_TYPE_STRICT)
+    {
+        return sai_deserialize_flags(s, meta, value);
+    }
+
     for (size_t i = 0; i < meta->valuescount; ++i)
     {
         if (strcmp(s.c_str(), meta->valuesnames[i]) == 0)
@@ -3784,60 +3799,6 @@ void sai_deserialize_enum(
     sai_deserialize_number(s, value);
 }
 
-void sai_deserialize_flags(
-        _In_ const std::string& s,
-        _In_ const sai_enum_metadata_t* meta,
-        _Out_ int32_t& value)
-{
-    SWSS_LOG_ENTER();
-
-    if (meta == NULL)
-    {
-        sai_deserialize_number(s, value);
-        return;
-    }
-
-    if (!meta->containsflags || meta->flagstype != SAI_ENUM_FLAGS_TYPE_STRICT)
-    {
-        sai_deserialize_enum(s, meta, value);
-        return;
-    }
-
-    if (s.empty())
-    {
-        SWSS_LOG_THROW("empty strict flags string");
-    }
-
-    const auto tokens = swss::tokenize(s, '|');
-    uint32_t acc = 0;
-
-    for (const auto& tok : tokens)
-    {
-        if (tok.empty())
-        {
-            SWSS_LOG_THROW("empty strict flags token in %s", s.c_str());
-        }
-
-        /*This matches how sai_serialize_flags appends raw leftover bits
-          when some bitmask bits are not represented by any known enum name
-        */
-        if (tok.size() >= 2 && tok[0] == '0' && (tok[1] == 'x' || tok[1] == 'X'))
-        {
-            uint32_t bits = 0;
-            sai_deserialize_number(tok, bits, true);
-            acc |= bits;
-        }
-        else
-        {
-            int32_t v = 0;
-            sai_deserialize_enum(tok, meta, v);
-            acc |= static_cast<uint32_t>(v);
-        }
-    }
-
-    value = static_cast<int32_t>(acc);
-}
-
 void sai_deserialize_mac(
         _In_ const std::string& s,
         _Out_ sai_mac_t& mac)
@@ -5210,7 +5171,7 @@ void sai_deserialize_port_error_status(
 {
     SWSS_LOG_ENTER();
 
-    sai_deserialize_flags(s, &sai_metadata_enum_sai_port_error_status_t, (int32_t&)status);
+    sai_deserialize_enum(s, &sai_metadata_enum_sai_port_error_status_t, (int32_t&)status);
 }
 
 void sai_deserialize_port_host_tx_ready_status(

meta/sai_serialize.h

@@ -256,15 +256,6 @@ std::string sai_serialize_enum(
         _In_ const int32_t value,
         _In_ const sai_enum_metadata_t* meta);
 
-/**
- * Serialize a bitmask for enums marked @flags strict.
- * Produces "FLAG_A|FLAG_B" for composite values; unknown bits are appended as a hex literal.
- * If metadata is not strict-flags, falls back to sai_serialize_enum.
- */
-std::string sai_serialize_flags(
-        _In_ const int32_t value,
-        _In_ const sai_enum_metadata_t* meta);
-
 std::string sai_serialize_enum_list(
         _In_ const sai_s32_list_t& list,
         _In_ const sai_enum_metadata_t* meta,
@@ -431,15 +422,6 @@ void sai_deserialize_enum(
         _In_ const sai_enum_metadata_t * meta,
         _Out_ int32_t& value);
 
-/**
- * Deserialize strict flags produced by sai_serialize_flags.
- * Accepts "0", "NAME|NAME|...", and hex tokens (0x..) for raw bits.
- */
-void sai_deserialize_flags(
-        _In_ const std::string& s,
-        _In_ const sai_enum_metadata_t* meta,
-        _Out_ int32_t& value);
-
 void sai_deserialize_number(
         _In_ const std::string& s,
         _Out_ uint32_t& number,