Change typedef declarations to modern using aliases

src/sst/core/clock.h

@@ -102,8 +102,8 @@ class Clock : public Action
     std::string toString() const override;
 
 private:
-    /*     typedef std::list<Clock::HandlerBase*> HandlerMap_t; */
-    typedef std::vector<Clock::HandlerBase*> StaticHandlerMap_t;
+    /* using HandlerMap_t = std::list<Clock::HandlerBase*>; */
+    using StaticHandlerMap_t = std::vector<Clock::HandlerBase*>;
 
     Clock() {}
 

src/sst/core/componentInfo.h

@@ -42,7 +42,7 @@ class ComponentInfo
 {
 
 public:
-    typedef std::vector<ConfigStatistic> statEnableList_t; /*!< List of Enabled Statistics */
+    using statEnableList_t = std::vector<ConfigStatistic>; /*!< List of Enabled Statistics */
 
     // Share Flags for SubComponent loading
     static const uint64_t SHARE_PORTS  = 0x1;
@@ -285,8 +285,8 @@ class ComponentInfoMap
     std::unordered_set<ComponentInfo*, ComponentInfo::HashID, ComponentInfo::EqualsID> dataByID;
 
 public:
-    typedef std::unordered_set<ComponentInfo*, ComponentInfo::HashID, ComponentInfo::EqualsID>::const_iterator
-        const_iterator;
+    using const_iterator =
+        std::unordered_set<ComponentInfo*, ComponentInfo::HashID, ComponentInfo::EqualsID>::const_iterator;
 
     const_iterator begin() const { return dataByID.begin(); }
 

src/sst/core/configGraph.h

@@ -38,8 +38,8 @@ class Config;
 class TimeLord;
 class ConfigGraph;
 
-typedef SparseVectorMap<ComponentId_t> ComponentIdMap_t;
-typedef std::vector<LinkId_t>          LinkIdMap_t;
+using ComponentIdMap_t = SparseVectorMap<ComponentId_t>;
+using LinkIdMap_t      = std::vector<LinkId_t>;
 
 /** Represents the configuration of a generic Link */
 class ConfigLink : public SST::Core::Serialization::serializable
@@ -213,7 +213,7 @@ class ConfigStatOutput : public SST::Core::Serialization::serializable
     ImplementSerializable(SST::ConfigStatOutput)
 };
 
-typedef SparseVectorMap<LinkId_t, ConfigLink*> ConfigLinkMap_t;
+using ConfigLinkMap_t = SparseVectorMap<LinkId_t, ConfigLink*>;
 
 /**
    Class that represents a PortModule in ConfigGraph
@@ -396,16 +396,16 @@ class ConfigComponent : public SST::Core::Serialization::serializable
 };
 
 /** Map names to Links */
-// typedef std::map<std::string,ConfigLink> ConfigLinkMap_t;
-// typedef SparseVectorMap<std::string,ConfigLink> ConfigLinkMap_t;
+// using ConfigLinkMap_t = std::map<std::string,ConfigLink>;
+// using ConfigLinkMap_t = SparseVectorMap<std::string,ConfigLink>;
 /** Map IDs to Components */
-typedef SparseVectorMap<ComponentId_t, ConfigComponent*> ConfigComponentMap_t;
+using ConfigComponentMap_t     = SparseVectorMap<ComponentId_t, ConfigComponent*>;
 /** Map names to Components */
-typedef std::map<std::string, ComponentId_t>             ConfigComponentNameMap_t;
+using ConfigComponentNameMap_t = std::map<std::string, ComponentId_t>;
 /** Map names to Parameter Sets: XML only */
-typedef std::map<std::string, Params*>                   ParamsMap_t;
+using ParamsMap_t              = std::map<std::string, Params*>;
 /** Map names to variable values:  XML only */
-typedef std::map<std::string, std::string>               VariableMap_t;
+using VariableMap_t            = std::map<std::string, std::string>;
 
 class PartitionGraph;
 
@@ -645,8 +645,8 @@ class PartitionLink
     }
 };
 
-typedef SparseVectorMap<ComponentId_t, PartitionComponent*> PartitionComponentMap_t;
-typedef SparseVectorMap<LinkId_t, PartitionLink>            PartitionLinkMap_t;
+using PartitionComponentMap_t = SparseVectorMap<ComponentId_t, PartitionComponent*>;
+using PartitionLinkMap_t      = SparseVectorMap<LinkId_t, PartitionLink>;
 
 class PartitionGraph
 {

src/sst/core/eli/elementbuilder.h

@@ -21,7 +21,7 @@ namespace SST::ELI {
 template <class Base, class... Args>
 struct Builder
 {
-    typedef Base* (*createFxn)(Args...);
+    using createFxn = Base* (*)(Args...);
 
     virtual Base* create(Args... ctorArgs) = 0;
 

src/sst/core/eli/simpleInfo.h

@@ -38,10 +38,10 @@ class checkForELI_getSimpleInfoFunction
     template <typename F, F>
     struct check;
 
-    typedef char Match;
-    typedef long NotMatch;
+    using Match    = char;
+    using NotMatch = long;
 
-    typedef const InfoType& (*functionsig)(SimpleInfoPlaceHolder<index, InfoType>);
+    using functionsig = const InfoType& (*)(SimpleInfoPlaceHolder<index, InfoType>);
 
     template <typename F>
     static Match HasFunction(check<functionsig, &F::ELI_getSimpleInfo>*);

src/sst/core/event.h

@@ -67,9 +67,9 @@ class Event : public Activity
     using Handler2 = SSTHandler2<void, Event*, classT, dataT, funcT>;
 
     /** Type definition of unique identifiers */
-    typedef std::pair<uint64_t, int> id_type;
+    using id_type = std::pair<uint64_t, int>;
     /** Constant, default value for id_types */
-    static const id_type             NO_ID;
+    static const id_type NO_ID;
 
     Event() : Activity(), delivery_info(0)
     {

src/sst/core/impl/timevortex/timeVortexBinnedMap.h

@@ -150,7 +150,7 @@ class TimeVortexBinnedMapBase : public TimeVortex
     // for concurrent access.
     TimeUnit* current_time_unit;
 
-    typedef std::map<SimTime_t, TimeUnit*> mapType_t;
+    using mapType_t = std::map<SimTime_t, TimeUnit*>;
 
     // Accessed by multiple threads, must be locked when accessing
     mapType_t                                               map;

src/sst/core/impl/timevortex/timeVortexPQ.h

@@ -59,7 +59,7 @@ class TimeVortexPQBase : public TimeVortex
     virtual void fixup_handlers() override;
 
 private:
-    typedef std::priority_queue<Activity*, std::vector<Activity*>, Activity::greater<true, true, true>> dataType_t;
+    using dataType_t = std::priority_queue<Activity*, std::vector<Activity*>, Activity::greater<true, true, true>>;
 
     template <class T, class S, class C>
     S& getContainer(std::priority_queue<T, S, C>& q)

src/sst/core/interfaces/simpleNetwork.h

@@ -38,10 +38,10 @@ namespace SST::Interfaces {
 class SimpleNetwork : public SubComponent
 {
 public:
-    SST_ELI_REGISTER_SUBCOMPONENT_API(SST::Interfaces::SimpleNetwork,int)
+    SST_ELI_REGISTER_SUBCOMPONENT_API(SST::Interfaces::SimpleNetwork, int)
 
     /** All Addresses can be 64-bit */
-    typedef int64_t nid_t;
+    using nid_t = int64_t;
 #define PRI_NID PRIi64
 
     static const nid_t INIT_BROADCAST_ADDR;
@@ -96,11 +96,11 @@ class SimpleNetwork : public SubComponent
         /**
          * Trace types
          */
-        typedef enum {
+        enum TraceType {
             NONE,  /*!< No tracing enabled */
             ROUTE, /*!< Trace route information only */
             FULL   /*!< Trace all movements of packets through network */
-        } TraceType;
+        };
 
         /** Constructor */
         Request() :

src/sst/core/interfaces/stdMem.h

@@ -103,7 +103,7 @@ class StandardMem : public SubComponent
     SST_ELI_REGISTER_SUBCOMPONENT_API(SST::Interfaces::StandardMem,TimeConverter*,HandlerBase*)
 
     /** All Addresses can be 64-bit */
-    typedef uint64_t Addr;
+    using Addr = uint64_t;
 #define PRI_ADDR PRIx64
 
     /**
@@ -112,8 +112,8 @@ class StandardMem : public SubComponent
     class Request
     {
     public:
-        typedef uint64_t id_t;
-        typedef uint32_t flags_t;
+        using id_t    = uint64_t;
+        using flags_t = uint32_t;
 
         /** Flags that modify requests.
          * Each bit in a 32-bit field (flags_t) defines a seperate flag.

src/sst/core/interprocess/ipctunnel.h

@@ -39,7 +39,7 @@ template <typename ShareDataType, typename MsgType>
 class IPCTunnel
 {
 
-    typedef SST::Core::Interprocess::CircularBuffer<MsgType> CircBuff_t;
+    using CircBuff_t = SST::Core::Interprocess::CircularBuffer<MsgType>;
 
     struct InternalSharedData
     {

src/sst/core/interprocess/mmapparent.cc

@@ -17,5 +17,5 @@
 
 #include "sst/core/interprocess/tunneldef.h"
 
-typedef SST::Core::Interprocess::TunnelDef<int, int> testtunnel;
+using testtunnel = SST::Core::Interprocess::TunnelDef<int, int>;
 template class SST::Core::Interprocess::MMAPParent<testtunnel>;

src/sst/core/interprocess/shmparent.cc

@@ -18,7 +18,7 @@
 #include "sst/core/interprocess/shmchild.h"
 #include "sst/core/interprocess/tunneldef.h"
 
-typedef SST::Core::Interprocess::TunnelDef<int, int> testtunnel;
+using testtunnel = SST::Core::Interprocess::TunnelDef<int, int>;
 
 template class SST::Core::Interprocess::SHMParent<testtunnel>;
 template class SST::Core::Interprocess::SHMChild<testtunnel>;

src/sst/core/interprocess/tunneldef.h

@@ -54,7 +54,7 @@ template <typename ShareDataType, typename MsgType>
 class TunnelDef
 {
 
-    typedef SST::Core::Interprocess::CircularBuffer<MsgType> CircBuff_t;
+    using CircBuff_t = SST::Core::Interprocess::CircularBuffer<MsgType>;
 
 public:
     /** Create a new tunnel

src/sst/core/model/element_python.h

@@ -19,7 +19,7 @@
 
 namespace SST {
 
-typedef void* (*genPythonModuleFunction)(void);
+using genPythonModuleFunction = void* (*)(void);
 
 /** Class to represent the code that needs to be added to create the
  * python module struture for the library.

src/sst/core/oneshot.h

@@ -81,13 +81,13 @@ class OneShot : public Action
     NotSerializable(SST::OneShot)
 
 private:
-    typedef std::vector<OneShot::HandlerBase*> HandlerList_t;
+    using HandlerList_t = std::vector<OneShot::HandlerBase*>;
 
     // Since this only gets fixed latency events, the times will fire
     // in order of arrival.  No need to use a full map, a double ended
     // queue will work just as well
-    // typedef std::map<SimTime_t, HandlerList_t*> HandlerVectorMap_t;
-    typedef std::deque<std::pair<SimTime_t, HandlerList_t*>> HandlerVectorMap_t;
+    // using HandlerVectorMap_t = std::map<SimTime_t, HandlerList_t*>;
+    using HandlerVectorMap_t = std::deque<std::pair<SimTime_t, HandlerList_t*>>;
 
     // Generic constructor for serialization
     OneShot() {}

src/sst/core/params.h

@@ -193,7 +193,7 @@ class Params : public SST::Core::Serialization::serializable
         }
     }
 
-    typedef std::map<uint32_t, std::string>::const_iterator const_iterator; /*!< Const Iterator type */
+    using const_iterator = std::map<uint32_t, std::string>::const_iterator; /*!< Const Iterator type */
 
     const std::string& getString(const std::string& name, bool& found) const;
 
@@ -229,8 +229,8 @@ class Params : public SST::Core::Serialization::serializable
     void getDelimitedTokens(const std::string& value, char delim, std::vector<std::string>& tokens) const;
 
 public:
-    typedef std::string                    key_type; /*!< Type of key (string) */
-    typedef std::set<key_type, KeyCompare> KeySet_t; /*!< Type of a set of keys */
+    using key_type = std::string;                    /*!< Type of key (string) */
+    using KeySet_t = std::set<key_type, KeyCompare>; /*!< Type of a set of keys */
 
     /**
      * Enable or disable parameter verification on an instance

src/sst/core/profile.h

@@ -26,7 +26,7 @@ namespace SST::Core::Profile {
 #define CLOCK std::chrono::steady_clock
 #endif
 
-typedef CLOCK::time_point ProfData_t;
+using ProfData_t = CLOCK::time_point;
 
 inline ProfData_t
 now()
@@ -48,7 +48,7 @@ getElapsed(const ProfData_t& since)
 }
 
 #else
-typedef double ProfData_t;
+using ProfData_t = double;
 
 inline ProfData_t
 now()

src/sst/core/serialization/impl/serialize_atomic.h

@@ -26,7 +26,7 @@ namespace SST::Core::Serialization {
 template <class T>
 class serialize_impl<std::atomic<T>>
 {
-    typedef std::atomic<T> Value;
+    using Value = std::atomic<T>;
 
 public:
     void operator()(Value& v, serializer& ser)

src/sst/core/serialization/impl/serialize_deque.h

@@ -26,7 +26,7 @@ namespace SST::Core::Serialization {
 template <class T>
 class serialize_impl<std::deque<T>>
 {
-    typedef std::deque<T> Deque;
+    using Deque = std::deque<T>;
 
 public:
     void operator()(Deque& v, serializer& ser)

src/sst/core/serialization/impl/serialize_list.h

@@ -26,12 +26,12 @@ namespace SST::Core::Serialization {
 template <class T>
 class serialize_impl<std::list<T>>
 {
-    typedef std::list<T> List;
+    using List = std::list<T>;
 
 public:
     void operator()(List& v, serializer& ser)
     {
-        typedef typename List::iterator iterator;
+        using iterator = typename List::iterator;
         switch ( ser.mode() ) {
         case serializer::SIZER:
         {

src/sst/core/serialization/impl/serialize_map.h

@@ -32,12 +32,12 @@ namespace SST::Core::Serialization {
 template <class Key, class Value>
 class serialize_impl<std::map<Key, Value>>
 {
-    typedef std::map<Key, Value> Map;
+    using Map = std::map<Key, Value>;
 
 public:
     void operator()(Map& m, serializer& ser)
     {
-        typedef typename std::map<Key, Value>::iterator iterator;
+        using iterator = typename std::map<Key, Value>::iterator;
         switch ( ser.mode() ) {
 
         case serializer::SIZER:
@@ -91,12 +91,12 @@ class serialize_impl<std::map<Key, Value>>
 template <class Key, class Value>
 class serialize<std::unordered_map<Key, Value>>
 {
-    typedef std::unordered_map<Key, Value> Map;
+    using Map = std::unordered_map<Key, Value>;
 
 public:
     void operator()(Map& m, serializer& ser)
     {
-        typedef typename std::unordered_map<Key, Value>::iterator iterator;
+        using iterator = typename std::unordered_map<Key, Value>::iterator;
         switch ( ser.mode() ) {
 
         case serializer::SIZER:

src/sst/core/serialization/impl/serialize_multiset.h

@@ -27,12 +27,12 @@ namespace SST::Core::Serialization {
 template <class T, class C>
 class serialize<std::multiset<T, C>>
 {
-    typedef std::multiset<T, C> MultiSet;
+    using MultiSet = std::multiset<T, C>;
 
 public:
     void operator()(MultiSet& v, serializer& ser)
     {
-        typedef typename std::multiset<T>::iterator iterator;
+        using iterator = typename std::multiset<T>::iterator;
         switch ( ser.mode() ) {
         case serializer::SIZER:
         {
@@ -82,12 +82,12 @@ class serialize<std::multiset<T, C>>
 template <class T>
 class serialize<std::unordered_multiset<T>>
 {
-    typedef std::unordered_multiset<T> MultiSet;
+    using MultiSet = std::unordered_multiset<T>;
 
 public:
     void operator()(MultiSet& v, serializer& ser)
     {
-        typedef typename std::unordered_multiset<T>::iterator iterator;
+        using iterator = typename std::unordered_multiset<T>::iterator;
         switch ( ser.mode() ) {
         case serializer::SIZER:
         {

src/sst/core/serialization/impl/serialize_priority_queue.h

@@ -26,7 +26,7 @@ namespace SST::Core::Serialization {
 template <class T, class S, class C>
 class serialize<std::priority_queue<T, S, C>>
 {
-    typedef std::priority_queue<T, S, C> Pqueue;
+    using Pqueue = std::priority_queue<T, S, C>;
 
 public:
     S& getContainer(std::priority_queue<T, S, C>& q)