[lldb-mi] Simplify MICmnMIOutOfBandRecord implementation.

[brucem]

Summary

• Remove extraneous members that were just storing temporary values.
• OutOfBand_e parameters don't need to be const as they are scalars.
• Switch from a map with CMIUtilString values to using a mapping function. This uses a switch statement which will generate a warning if a new result class is added.
• Make BuildAsyncRecord a static function rather than a private member function so that we can construct the result text correctly and avoid having extra stuff in the header.

[ki.stfu]

I'd prefer to declare all static functions as private static methods.

tools/lldb-mi/MICmnMIOutOfBandRecord.cpp

16

CMICmnMIOutOfBandRecord::MapOutOfBandToText

56

CMICmnMIOutOfBandRecord::MapOutOfBandToToken

102

And please follow to the style:

static CMIUtilString
BuildAsyncRecord(CMICmnMIOutOfBandRecord::OutOfBand_e veType)

102

CMICmnMIOutOfBandRecord::BuildAsyncRecord

[brucem]

Update for formatting fix.

[brucem]

tools/lldb-mi/MICmnMIOutOfBandRecord.cpp

16

The style in LLDB itself appears to be to using static file-scope functions when appropriate.

I did the same thing in my previous patch which simplified CMICmnMIResultRecord.

Making this a static function might lead to people prefixing the invocation with the class name, which would be needlessly verbose. Making it a private member function might also lead to, as it has done to date, to people using member variables for strange reasons rather than passing parameters.

Hopefully, there's no need for the internal implementation details of this class to bleed out into the header file.

56

As above.

102

As above.

tools/lldb-mi/MICmnMIOutOfBandRecord.h

 //===-- MICmnMIOutOfBandRecord.h --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #pragma once
 
-// Third party headers:
-#include <map>
-
 // In-house headers:
 #include "MICmnBase.h"
 #include "MIUtilString.h"
 #include "MICmnMIValueConst.h"
 #include "MICmnMIValueResult.h"
 
 //++ ============================================================================
 // Details: MI common code MI Out-of-band (Async) Record class. A class that encapsulates
enum OutOfBand_e
         eOutOfBand_ThreadGroupExited,
         eOutOfBand_ThreadGroupRemoved,
         eOutOfBand_ThreadGroupStarted,
         eOutOfBand_ThreadCreated,
         eOutOfBand_ThreadExited,
         eOutOfBand_ThreadSelected,
         eOutOfBand_TargetModuleLoaded,
         eOutOfBand_TargetModuleUnloaded,
-        eOutOfBand_TargetStreamOutput,
-        eOutOfBand_count // Always the last one
+        eOutOfBand_TargetStreamOutput
     };
 
-    // Typedefs:
-  public:
-    typedef std::map<OutOfBand_e, CMIUtilString> MapOutOfBandToOutOfBandText_t;
-    typedef std::map<OutOfBand_e, CMIUtilString> MapOutOfBandToToken_t;
-
     // Methods:
   public:
     /* ctor */ CMICmnMIOutOfBandRecord();
-    /* ctor */ CMICmnMIOutOfBandRecord(const OutOfBand_e veType);
-    /* ctor */ CMICmnMIOutOfBandRecord(const OutOfBand_e veType, const CMICmnMIValueConst &vConst);
-    /* ctor */ CMICmnMIOutOfBandRecord(const OutOfBand_e veType, const CMICmnMIValueResult &vResult);
+    /* ctor */ CMICmnMIOutOfBandRecord(OutOfBand_e veType);
+    /* ctor */ CMICmnMIOutOfBandRecord(OutOfBand_e veType, const CMICmnMIValueConst &vConst);
+    /* ctor */ CMICmnMIOutOfBandRecord(OutOfBand_e veType, const CMICmnMIValueResult &vResult);
     //
     const CMIUtilString &GetString() const;
     void Add(const CMICmnMIValueResult &vResult);
 
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ ~CMICmnMIOutOfBandRecord() override;
 
-    // Methods:
-  private:
-    void BuildAsyncRecord();
-
     // Attributes:
   private:
-    static MapOutOfBandToOutOfBandText_t ms_constMapOutOfBandToAsyncRecordText;
-    static MapOutOfBandToToken_t ms_constMapOutOfBandTextToToken;
-    //
-    OutOfBand_e m_eResultAsyncRecordClass;
     CMIUtilString m_strAsyncRecord; // Holds the text version of the result record to date
-    CMICmnMIValueResult m_partResult;
 };

tools/lldb-mi/MICmnMIOutOfBandRecord.cpp

 //===-- MICmnMIOutOfBandRecord.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // In-house headers:
 #include "MICmnMIOutOfBandRecord.h"
 #include "MICmnResources.h"
 
 // Instantiations:
-CMICmnMIOutOfBandRecord::MapOutOfBandToOutOfBandText_t ms_MapOutOfBandToOutOfBandText = {
-    {CMICmnMIOutOfBandRecord::eOutOfBand_Running, "running"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, "stopped"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointCreated, "breakpoint-created"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, "breakpoint-modified"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_Thread, ""}, // "" Meant to be empty
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupAdded, "thread-group-added"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited, "thread-group-exited"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupRemoved, "thread-group-removed"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupStarted, "thread-group-started"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated, "thread-created"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, "thread-exited"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected, "thread-selected"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleLoaded, "library-loaded"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleUnloaded, "library-unloaded"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, ""}};
-CMICmnMIOutOfBandRecord::MapOutOfBandToOutOfBandText_t ms_constMapAsyncRecordTextToToken = {
-    {CMICmnMIOutOfBandRecord::eOutOfBand_Running, "*"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, "*"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointCreated, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_Thread, "@"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupAdded, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupRemoved, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupStarted, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleLoaded, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleUnloaded, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, "@"}};
+static const char *
+MapOutOfBandToText(CMICmnMIOutOfBandRecord::OutOfBand_e veType)
+{
+    switch (veType)
+    {
+        case CMICmnMIOutOfBandRecord::eOutOfBand_Running:
+            return "running";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_Stopped:
+            return "stopped";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointCreated:
+            return "breakpoint-created";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified:
+            return "breakpoint-modified";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_Thread:
+            return ""; // "" Meant to be empty
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupAdded:
+            return "thread-group-added";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited:
+            return "thread-group-exited";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupRemoved:
+            return "thread-group-removed";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupStarted:
+            return "thread-group-started";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated:
+            return "thread-created";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited:
+            return "thread-exited";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected:
+            return "thread-selected";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleLoaded:
+            return "library-loaded";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleUnloaded:
+            return "library-unloaded";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput:
+            return "";
+    }
+    assert(false && "unknown CMICmnMIOutofBandRecord::OutOfBand_e");
+    return NULL;
+}
+
+static const char *
+MapOutOfBandToToken(CMICmnMIOutOfBandRecord::OutOfBand_e veType)
+{
+    switch (veType)
+    {
+        case CMICmnMIOutOfBandRecord::eOutOfBand_Running:
+            return "*";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_Stopped:
+            return "*";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointCreated:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_Thread:
+            return "@";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupAdded:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupRemoved:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupStarted:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleLoaded:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleUnloaded:
+            return "=";
+        case CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput:
+            return "@";
+    }
+    assert(false && "unknown CMICmnMIOutofBandRecord::OutOfBand_e");
+    return NULL;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Build the Out-of-band record's mandatory data part. The part up to the first
+//          (additional) result i.e. async-record ==>  "*" type.
+// Args:    veType      - (R) A MI Out-of-Band enumeration.
+// Return:  CMIUtilString - The async record text.
+// Throws:  None.
+//--
+static CMIUtilString BuildAsyncRecord(CMICmnMIOutOfBandRecord::OutOfBand_e veType)
+{
+    return CMIUtilString::Format("%s%s", MapOutOfBandToToken(veType), MapOutOfBandToText(veType));
+}
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnMIOutOfBandRecord constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnMIOutOfBandRecord::CMICmnMIOutOfBandRecord()
     : m_strAsyncRecord(MIRSRC(IDS_CMD_ERR_EVENT_HANDLED_BUT_NO_ACTION))
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnMIOutOfBandRecord constructor.
 // Type:    Method.
 // Args:    veType      - (R) A MI Out-of-Bound enumeration.
 // Return:  None.
 // Throws:  None.
 //--
-CMICmnMIOutOfBandRecord::CMICmnMIOutOfBandRecord(const OutOfBand_e veType)
-    : m_eResultAsyncRecordClass(veType)
-    , m_strAsyncRecord(MIRSRC(IDS_CMD_ERR_EVENT_HANDLED_BUT_NO_ACTION))
+CMICmnMIOutOfBandRecord::CMICmnMIOutOfBandRecord(OutOfBand_e veType)
+    : m_strAsyncRecord(BuildAsyncRecord(veType))
 {
-    BuildAsyncRecord();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnMIOutOfBandRecord constructor.
 // Type:    Method.
 // Args:    veType      - (R) A MI Out-of-Bound enumeration.
 //          vConst      - (R) A MI const object.
 // Return:  None.
 // Throws:  None.
 //--
-CMICmnMIOutOfBandRecord::CMICmnMIOutOfBandRecord(const OutOfBand_e veType, const CMICmnMIValueConst &vConst)
-    : m_eResultAsyncRecordClass(veType)
-    , m_strAsyncRecord(MIRSRC(IDS_CMD_ERR_EVENT_HANDLED_BUT_NO_ACTION))
+CMICmnMIOutOfBandRecord::CMICmnMIOutOfBandRecord(OutOfBand_e veType, const CMICmnMIValueConst &vConst)
+    : m_strAsyncRecord(BuildAsyncRecord(veType))
 {
-    BuildAsyncRecord();
     m_strAsyncRecord += vConst.GetString();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnMIOutOfBandRecord constructor.
 // Type:    Method.
 // Args:    veType      - (R) A MI Out-of-Bound enumeration.
 //          vResult     - (R) A MI result object.
 // Return:  None.
 // Throws:  None.
 //--
-CMICmnMIOutOfBandRecord::CMICmnMIOutOfBandRecord(const OutOfBand_e veType, const CMICmnMIValueResult &vResult)
-    : m_eResultAsyncRecordClass(veType)
-    , m_strAsyncRecord(MIRSRC(IDS_CMD_ERR_EVENT_HANDLED_BUT_NO_ACTION))
-    , m_partResult(vResult)
+CMICmnMIOutOfBandRecord::CMICmnMIOutOfBandRecord(OutOfBand_e veType, const CMICmnMIValueResult &vResult)
+    : m_strAsyncRecord(BuildAsyncRecord(veType))
 {
-    BuildAsyncRecord();
-    Add(m_partResult);
+    Add(vResult);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnMIOutOfBandRecord destructor.
 // Type:    Overrideable.
 // Args:    None.
 // Return:  None.
 // Throws:  None.

 //--
 const CMIUtilString &
 CMICmnMIOutOfBandRecord::GetString() const
 {
     return m_strAsyncRecord;
 }
 
 //++ ------------------------------------------------------------------------------------
-// Details: Build the Out-of-band record's mandatory data part. The part up to the first
-//          (additional) result i.e. async-record ==>  "*" type.
-// Type:    Method.
-// Args:    None.
-// Return:  None.
-// Throws:  None.
-//--
-void
-CMICmnMIOutOfBandRecord::BuildAsyncRecord()
-{
-    const char *pFormat = "%s%s";
-    const CMIUtilString &rStrAsyncRecord(ms_MapOutOfBandToOutOfBandText[m_eResultAsyncRecordClass]);
-    const CMIUtilString &rStrToken(ms_constMapAsyncRecordTextToToken[m_eResultAsyncRecordClass]);
-    m_strAsyncRecord = CMIUtilString::Format(pFormat, rStrToken.c_str(), rStrAsyncRecord.c_str());
-}
-
-//++ ------------------------------------------------------------------------------------
 // Details: Add to *this Out-of-band record additional information.
 // Type:    Method.
 // Args:    vResult           - (R) A MI result object.
 // Return:  None.
 // Throws:  None.
 //--
 void
 CMICmnMIOutOfBandRecord::Add(const CMICmnMIValueResult &vResult)
 {
     m_strAsyncRecord += ",";
     m_strAsyncRecord += vResult.GetString();
 }