Standardise use of type aliases and rvalue references in for loops (#32)

We currently use a mixture of type aliases and typedefs in our code. Since type aliasing 
provides a strict superset of the functionality of typedefs, but is otherwise essentially 
equivalent, it seems sensible to standardise on only using type aliasing throughout. This also 
adopts the convention of not using rvalue references in for loops, except for template code, on 
grounds of readability.

Author: tveasey

bin/autoconfig/CCmdLineParser.h

@@ -36,7 +36,7 @@ namespace autoconfig
 class CCmdLineParser
 {
     public:
-        typedef std::vector<std::string> TStrVec;
+        using TStrVec = std::vector<std::string>;
 
     public:
         //! Parse the arguments and return options if appropriate.

include/api/CAnomalyJob.h

@@ -121,21 +121,22 @@ class API_EXPORT CAnomalyJob : public CDataProcessor
 
 
     public:
-        typedef std::function<void(const CModelSnapshotJsonWriter::SModelSnapshotReport &)> TPersistCompleteFunc;
-        typedef model::CAnomalyDetector::TAnomalyDetectorPtr TAnomalyDetectorPtr;
-        typedef std::vector<TAnomalyDetectorPtr> TAnomalyDetectorPtrVec;
-        typedef std::vector<TAnomalyDetectorPtr>::iterator TAnomalyDetectorPtrVecItr;
-        typedef std::vector<TAnomalyDetectorPtr>::const_iterator TAnomalyDetectorPtrVecCItr;
-        typedef std::vector<model::CSearchKey> TKeyVec;
-        typedef boost::unordered_map<model::CSearchKey::TStrKeyPr,
-                                     TAnomalyDetectorPtr,
-                                     model::CStrKeyPrHash,
-                                     model::CStrKeyPrEqual> TKeyAnomalyDetectorPtrUMap;
-        typedef std::pair<model::CSearchKey::TStrCRefKeyCRefPr, TAnomalyDetectorPtr> TKeyCRefAnomalyDetectorPtrPr;
-        typedef std::vector<TKeyCRefAnomalyDetectorPtrPr>            TKeyCRefAnomalyDetectorPtrPrVec;
-        typedef model::CAnomalyDetector::TModelPlotDataVec TModelPlotDataVec;
-        typedef TModelPlotDataVec::const_iterator TModelPlotDataVecCItr;
-        typedef model::CBucketQueue<TModelPlotDataVec> TModelPlotDataVecQueue;
+        using TPersistCompleteFunc = std::function<void(const CModelSnapshotJsonWriter::SModelSnapshotReport &)>;
+        using TAnomalyDetectorPtr = model::CAnomalyDetector::TAnomalyDetectorPtr;
+        using TAnomalyDetectorPtrVec = std::vector<TAnomalyDetectorPtr>;
+        using TAnomalyDetectorPtrVecItr = std::vector<TAnomalyDetectorPtr>::iterator;
+        using TAnomalyDetectorPtrVecCItr = std::vector<TAnomalyDetectorPtr>::const_iterator;
+        using TKeyVec = std::vector<model::CSearchKey>;
+        using TKeyAnomalyDetectorPtrUMap =
+                  boost::unordered_map<model::CSearchKey::TStrKeyPr,
+                                       TAnomalyDetectorPtr,
+                                       model::CStrKeyPrHash,
+                                       model::CStrKeyPrEqual>;
+        using TKeyCRefAnomalyDetectorPtrPr = std::pair<model::CSearchKey::TStrCRefKeyCRefPr, TAnomalyDetectorPtr>;
+        using TKeyCRefAnomalyDetectorPtrPrVec = std::vector<TKeyCRefAnomalyDetectorPtrPr>;
+        using TModelPlotDataVec = model::CAnomalyDetector::TModelPlotDataVec;
+        using TModelPlotDataVecCItr = TModelPlotDataVec::const_iterator;
+        using TModelPlotDataVecQueue = model::CBucketQueue<TModelPlotDataVec>;
 
         struct API_EXPORT SRestoredStateDetail
         {
@@ -164,7 +165,7 @@ class API_EXPORT CAnomalyJob : public CDataProcessor
             TKeyCRefAnomalyDetectorPtrPrVec s_Detectors;
         };
 
-        typedef boost::shared_ptr<SBackgroundPersistArgs> TBackgroundPersistArgsPtr;
+        using TBackgroundPersistArgsPtr = boost::shared_ptr<SBackgroundPersistArgs>;
 
     public:
         CAnomalyJob(const std::string &jobId,

include/api/CBenchMarker.h

@@ -49,20 +49,20 @@ class API_EXPORT CBenchMarker
 {
     public:
         //! A count and and example string
-        typedef std::pair<size_t, std::string>             TSizeStrPr;
+        using TSizeStrPr = std::pair<size_t, std::string>;
 
         //! Used for mapping Ml type to count and example
-        typedef std::map<int, TSizeStrPr>                  TIntSizeStrPrMap;
-        typedef TIntSizeStrPrMap::iterator                 TIntSizeStrPrMapItr;
-        typedef TIntSizeStrPrMap::const_iterator           TIntSizeStrPrMapCItr;
+        using TIntSizeStrPrMap = std::map<int, TSizeStrPr>;
+        using TIntSizeStrPrMapItr = TIntSizeStrPrMap::iterator;
+        using TIntSizeStrPrMapCItr = TIntSizeStrPrMap::const_iterator;
 
         //! A regex and its corresponding type count map
-        typedef std::pair<core::CRegex, TIntSizeStrPrMap>  TRegexIntSizeStrPrMapPr;
+        using TRegexIntSizeStrPrMapPr = std::pair<core::CRegex, TIntSizeStrPrMap>;
 
         //! Vector of regexes with corresponding type count maps
-        typedef std::vector<TRegexIntSizeStrPrMapPr>       TRegexIntSizeStrPrMapPrVec;
-        typedef TRegexIntSizeStrPrMapPrVec::iterator       TRegexIntSizeStrPrMapPrVecItr;
-        typedef TRegexIntSizeStrPrMapPrVec::const_iterator TRegexIntSizeStrPrMapPrVecCItr;
+        using TRegexIntSizeStrPrMapPrVec = std::vector<TRegexIntSizeStrPrMapPr>;
+        using TRegexIntSizeStrPrMapPrVecItr = TRegexIntSizeStrPrMapPrVec::iterator;
+        using TRegexIntSizeStrPrMapPrVecCItr = TRegexIntSizeStrPrMapPrVec::const_iterator;
 
     public:
         CBenchMarker(void);

include/api/CCategoryExamplesCollector.h

@@ -42,8 +42,8 @@ namespace api
 class API_EXPORT CCategoryExamplesCollector
 {
     public:
-        typedef std::set<std::string> TStrSet;
-        typedef TStrSet::const_iterator TStrSetCItr;
+        using TStrSet = std::set<std::string>;
+        using TStrSetCItr = TStrSet::const_iterator;
 
         //! Truncate examples to be no longer than this
         static const size_t MAX_EXAMPLE_LENGTH;

include/api/CCsvOutputWriter.h

@@ -145,9 +145,9 @@ class API_EXPORT CCsvOutputWriter : public COutputHandler
         //! an appropriate level, avoiding regular memory allocations.
         std::string         m_WorkRecord;
 
-        typedef std::pair<std::string, std::string > TStrStrPr;
-        typedef std::set<TStrStrPr>                  TStrStrPrSet;
-        typedef TStrStrPrSet::const_iterator         TStrStrPrSetCItr;
+        using TStrStrPr = std::pair<std::string, std::string>;
+        using TStrStrPrSet = std::set<TStrStrPr>;
+        using TStrStrPrSetCItr = TStrStrPrSet::const_iterator;
 
         //! Messages to be printed before the next lot of output
         TStrStrPrSet        m_Messages;

include/api/CDataProcessor.h

@@ -58,13 +58,13 @@ class API_EXPORT CDataProcessor : private core::CNonCopyable
         static const std::string CONTROL_FIELD_NAME;
 
     public:
-        typedef std::vector<std::string>                       TStrVec;
-        typedef TStrVec::iterator                              TStrVecItr;
-        typedef TStrVec::const_iterator                        TStrVecCItr;
+        using TStrVec = std::vector<std::string>;
+        using TStrVecItr = TStrVec::iterator;
+        using TStrVecCItr = TStrVec::const_iterator;
 
-        typedef boost::unordered_map<std::string, std::string> TStrStrUMap;
-        typedef TStrStrUMap::iterator                          TStrStrUMapItr;
-        typedef TStrStrUMap::const_iterator                    TStrStrUMapCItr;
+        using TStrStrUMap = boost::unordered_map<std::string, std::string>;
+        using TStrStrUMapItr = TStrStrUMap::iterator;
+        using TStrStrUMapCItr = TStrStrUMap::const_iterator;
 
     public:
         CDataProcessor(void);

include/api/CDataTyper.h

@@ -53,14 +53,14 @@ class API_EXPORT CDataTyper
 {
     public:
         //! Used for storing distinct token IDs
-        typedef boost::unordered_map<std::string, std::string>        TStrStrUMap;
-        typedef TStrStrUMap::const_iterator                           TStrStrUMapCItr;
+        using TStrStrUMap = boost::unordered_map<std::string, std::string>;
+        using TStrStrUMapCItr = TStrStrUMap::const_iterator;
 
         //! Shared pointer to an instance of this class
-        typedef boost::shared_ptr<CDataTyper>                         TDataTyperP;
+        using TDataTyperP = boost::shared_ptr<CDataTyper>;
 
         //! Shared pointer to an instance of this class
-        typedef std::function<void(core::CStatePersistInserter &)>    TPersistFunc;
+        using TPersistFunc = std::function<void(core::CStatePersistInserter &)>;
 
     public:
         CDataTyper(const std::string &fieldName);

include/api/CDetectionRulesJsonParser.h

@@ -38,8 +38,8 @@ namespace api
 class API_EXPORT CDetectionRulesJsonParser
 {
     public:
-        typedef std::vector<model::CDetectionRule> TDetectionRuleVec;
-        typedef boost::unordered_map<std::string, core::CPatternSet> TStrPatternSetUMap;
+        using TDetectionRuleVec = std::vector<model::CDetectionRule>;
+        using TStrPatternSetUMap = boost::unordered_map<std::string, core::CPatternSet>;
 
     public:
         //! Default constructor

include/api/CFieldConfig.h

@@ -351,7 +351,7 @@ class API_EXPORT CFieldConfig
         //! Uniqueness is enforced by config key and also by the combination of
         //! function, field name, by field name, over field name and
         //! partition field name.
-        typedef boost::multi_index::multi_index_container<
+        using TFieldOptionsMIndex = boost::multi_index::multi_index_container<
             CFieldOptions,
             boost::multi_index::indexed_by<
                 boost::multi_index::ordered_unique<
@@ -370,28 +370,28 @@ class API_EXPORT CFieldConfig
                     >
                 >
             >
-        > TFieldOptionsMIndex;
+        >;
 
-        typedef TFieldOptionsMIndex::iterator              TFieldOptionsMIndexItr;
-        typedef TFieldOptionsMIndex::const_iterator        TFieldOptionsMIndexCItr;
+        using TFieldOptionsMIndexItr = TFieldOptionsMIndex::iterator;
+        using TFieldOptionsMIndexCItr = TFieldOptionsMIndex::const_iterator;
 
         //! Used to maintain a list of all unique config keys
-        typedef std::set<int>                              TIntSet;
+        using TIntSet = std::set<int>;
 
         //! Used to return the superset of enabled field names
-        typedef std::set<std::string>                      TStrSet;
+        using TStrSet = std::set<std::string>;
 
         //! Used to obtain command line clause tokens
-        typedef std::vector<std::string>                   TStrVec;
-        typedef TStrVec::iterator                          TStrVecItr;
+        using TStrVec = std::vector<std::string>;
+        using TStrVecItr = TStrVec::iterator;
 
-        typedef std::vector<model::CDetectionRule> TDetectionRuleVec;
-        typedef boost::unordered_map<int, TDetectionRuleVec> TIntDetectionRuleVecUMap;
+        using TDetectionRuleVec = std::vector<model::CDetectionRule>;
+        using TIntDetectionRuleVecUMap = boost::unordered_map<int, TDetectionRuleVec>;
 
-        typedef boost::unordered_map<std::string, core::CPatternSet> TStrPatternSetUMap;
+        using TStrPatternSetUMap = boost::unordered_map<std::string, core::CPatternSet>;
 
-        typedef std::pair<std::string, model::CDetectionRule> TStrDetectionRulePr;
-        typedef std::vector<TStrDetectionRulePr> TStrDetectionRulePrVec;
+        using TStrDetectionRulePr = std::pair<std::string, model::CDetectionRule>;
+        using TStrDetectionRulePrVec = std::vector<TStrDetectionRulePr>;
 
     public:
         //! Construct empty.  This call should generally be followed by a call to

include/api/CFieldDataTyper.h

@@ -77,17 +77,17 @@ class API_EXPORT CFieldDataTyper : public CDataProcessor
     public:
         // A type of token list data typer that DOESN'T exclude fields from its
         // analysis
-        typedef CTokenListDataTyper<true,  // Warping
-                                    true,  // Underscores
-                                    true,  // Dots
-                                    true,  // Dashes
-                                    true,  // Ignore leading digit
-                                    true,  // Ignore hex
-                                    true,  // Ignore date words
-                                    false, // Ignore field names
-                                    2,     // Min dictionary word length
-                                    core::CWordDictionary::TWeightVerbs5Other2>
-                TTokenListDataTyperKeepsFields;
+        using TTokenListDataTyperKeepsFields =
+                  CTokenListDataTyper<true,  // Warping
+                                      true,  // Underscores
+                                      true,  // Dots
+                                      true,  // Dashes
+                                      true,  // Ignore leading digit
+                                      true,  // Ignore hex
+                                      true,  // Ignore date words
+                                      false, // Ignore field names
+                                      2,     // Min dictionary word length
+                                      core::CWordDictionary::TWeightVerbs5Other2>;
 
     public:
         //! Construct without persistence capability
@@ -160,7 +160,7 @@ class API_EXPORT CFieldDataTyper : public CDataProcessor
         void acknowledgeFlush(const std::string &flushId);
 
     private:
-        typedef CCategoryExamplesCollector::TStrSet TStrSet;
+        using TStrSet = CCategoryExamplesCollector::TStrSet;
 
     private:
         //! The job ID