Replace std::string with string

examples/ObjectCatalog/main.cpp

@@ -13,7 +13,7 @@
  */
 
 
-#include <string>
+
 #include <iostream>
 
 #include "common/Logger.hpp"

src/coreComponents/codingUtilities/StringUtilities.cpp

@@ -29,7 +29,7 @@ namespace stringutilities
 /**
  * String tokenizing function
  **/
-string_array Tokenize( const std::string & str, const std::string & delimiters )
+string_array Tokenize( const string & str, const string & delimiters )
 {
   string_array tokens;
 
@@ -41,7 +41,7 @@ string_array Tokenize( const std::string & str, const std::string & delimiters )
   {
 
     bool usesNonWhitespaceDelimiters = false;
-    std::string::size_type i =0;
+    string::size_type i =0;
     while( delimiters[i] && !usesNonWhitespaceDelimiters )
     {
       usesNonWhitespaceDelimiters |= !isspace( int(delimiters[i]) );
@@ -54,7 +54,7 @@ string_array Tokenize( const std::string & str, const std::string & delimiters )
       size_t lastPos = 0;
 
       size_t newPos = lastPos;
-      while( (newPos=str.find_first_of( delimiters, lastPos )) != std::string::npos )
+      while( (newPos=str.find_first_of( delimiters, lastPos )) != string::npos )
       {
         tokens.emplace_back( str.substr( lastPos, newPos-lastPos ));
         lastPos = newPos + 1;
@@ -66,15 +66,15 @@ string_array Tokenize( const std::string & str, const std::string & delimiters )
       // whitespace delimiters
       // skip multiple adjacent delimiters
       size_t lastPos = str.find_first_not_of( delimiters, 0 );
-      lastPos = (lastPos == std::string::npos) ? 0 : lastPos;
+      lastPos = (lastPos == string::npos) ? 0 : lastPos;
 
       size_t newPos = lastPos;
-      while( (newPos=str.find_first_of( delimiters, lastPos )) != std::string::npos )
+      while( (newPos=str.find_first_of( delimiters, lastPos )) != string::npos )
       {
         tokens.emplace_back( str.substr( lastPos, newPos-lastPos ));
         lastPos = str.find_first_not_of( delimiters, newPos );
       }
-      if( lastPos!= std::string::npos )
+      if( lastPos!= string::npos )
         tokens.emplace_back( str.substr( lastPos, str.length()-lastPos ));
 
     }

src/coreComponents/codingUtilities/StringUtilities.hpp

@@ -38,29 +38,29 @@ namespace stringutilities
 
 /// Overloaded function to check equality between strings and char arrays
 /// Mainly used to avoid char*==char* mistakes
-inline bool streq( std::string const & strA, std::string const & strB )
+inline bool streq( string const & strA, string const & strB )
 { return strA == strB; }
 
-inline bool streq( std::string const & strA, char const * const strB )
+inline bool streq( string const & strA, char const * const strB )
 { return strA == strB; }
 
-inline bool streq( char const * const strA, std::string const & strB )
+inline bool streq( char const * const strA, string const & strB )
 { return strA == strB; }
 
 inline bool streq( char const * const strA, char const * const strB )
 { return !strcmp( strA, strB ); }
 
 /**
  * @brief Join strings or other printable objects with a delimiter.
- * @tparam S    type of delimiter, usually char, char const * or std::string
+ * @tparam S    type of delimiter, usually char, char const * or string
  * @tparam IT   type of iterator into the range of objects to join
  * @param delim delimiter used to glue together strings
  * @param first iterator to start of the range
  * @param last  iterator past-the-end of the range
  * @return a new string containing input strings concatenated with a delimiter
  */
 template< typename IT, typename S = char >
-std::string strjoin( IT first, IT last, S const & delim = S() )
+string strjoin( IT first, IT last, S const & delim = S() )
 {
   std::ostringstream oss;
   if( first != last )
@@ -75,7 +75,7 @@ std::string strjoin( IT first, IT last, S const & delim = S() )
 }
 
 /// Subdivide string by delimiters
-string_array Tokenize( std::string const & str, std::string const & delimiters );
+string_array Tokenize( string const & str, string const & delimiters );
 
 /**
  * @brief Retuns a string containing a padded value

src/coreComponents/codingUtilities/tests/testGeosxTraits.cpp

@@ -27,7 +27,7 @@ IS_VALID_EXPRESSION( HasOperatorPlusEquals, T, std::declval< T & >() += T() );
 TEST( testGeosxTraits, HasOperatorPlusEquals )
 {
   static_assert( HasOperatorPlusEquals< int >, "Should be true." );
-  static_assert( HasOperatorPlusEquals< std::string >, "Should be true." );
+  static_assert( HasOperatorPlusEquals< string >, "Should be true." );
 
   static_assert( !HasOperatorPlusEquals< int const >, "Should be false." );
   static_assert( !HasOperatorPlusEquals< std::vector< int > >, "Should be false." );
@@ -38,24 +38,24 @@ TEST( testGeosxTraits, HasOperatorPlusEquals2 )
 {
   static_assert( HasOperatorPlusEquals2< double, int >, "Should be true." );
   static_assert( HasOperatorPlusEquals2< double, int const >, "Should be true." );
-  static_assert( HasOperatorPlusEquals2< std::string, std::string >, "Should be true." );
+  static_assert( HasOperatorPlusEquals2< string, string >, "Should be true." );
 
   static_assert( !HasOperatorPlusEquals2< double const, int >, "Should be false." );
-  static_assert( !HasOperatorPlusEquals2< R1Tensor, std::string >, "Should be false." );
+  static_assert( !HasOperatorPlusEquals2< R1Tensor, string >, "Should be false." );
   static_assert( !HasOperatorPlusEquals2< std::vector< int >, int >, "Should be false." );
 }
 
 HAS_MEMBER_FUNCTION_NO_RTYPE( at, 55 );
 TEST( testGeosxTraits, HasMemberFunction_at )
 {
-  static_assert( HasMemberFunction_at< std::string >, "Should be true." );
+  static_assert( HasMemberFunction_at< string >, "Should be true." );
   static_assert( HasMemberFunction_at< std::vector< int > >, "Should be true." );
   static_assert( HasMemberFunction_at< std::vector< double > >, "Should be true." );
-  static_assert( HasMemberFunction_at< std::map< int, std::string > >, "Should be true." );
-  static_assert( HasMemberFunction_at< std::unordered_map< int, std::string > >, "Should be true." );
+  static_assert( HasMemberFunction_at< std::map< int, string > >, "Should be true." );
+  static_assert( HasMemberFunction_at< std::unordered_map< int, string > >, "Should be true." );
 
   static_assert( !HasMemberFunction_at< int >, "Should be false." );
-  static_assert( !HasMemberFunction_at< std::map< std::string, std::string > >, "Should be false." );
+  static_assert( !HasMemberFunction_at< std::map< string, string > >, "Should be false." );
   static_assert( !HasMemberFunction_at< array1d< localIndex > >, "Should be false." );
 }
 
@@ -65,7 +65,7 @@ HAS_MEMBER_FUNCTION_NO_RTYPE( insert,
 TEST( testGeosxTraits, HasMemberFunction_insert )
 {
   static_assert( HasMemberFunction_insert< std::vector< int > >, "Should be true." );
-  static_assert( HasMemberFunction_insert< std::map< std::string, int > >, "Should be true." );
+  static_assert( HasMemberFunction_insert< std::map< string, int > >, "Should be true." );
   static_assert( HasMemberFunction_insert< std::list< std::vector< int > > >, "Should be true." );
 
   static_assert( !HasMemberFunction_insert< int >, "Should be false." );
@@ -90,15 +90,15 @@ TEST( testGeosxTraits, Pointer )
   static_assert( std::is_same< Pointer< int >, int * >::value, "Should be true." );
   static_assert( std::is_same< Pointer< R1Tensor >, R1Tensor * >::value, "Should be true." );
   static_assert( std::is_same< Pointer< std::vector< double > >, double * >::value, "Should be true." );
-  static_assert( std::is_same< Pointer< std::string >, char const * >::value, "Should be true." );
-  static_assert( std::is_same< Pointer< array3d< std::string > >, std::string * >::value, "Should be true." );
+  static_assert( std::is_same< Pointer< string >, char const * >::value, "Should be true." );
+  static_assert( std::is_same< Pointer< array3d< string > >, string * >::value, "Should be true." );
   static_assert( std::is_same< Pointer< SortedArray< float > >, float const * >::value, "Should be true." );
 
   static_assert( std::is_same< ConstPointer< int >, int const * >::value, "Should be true." );
   static_assert( std::is_same< ConstPointer< R1Tensor >, R1Tensor const * >::value, "Should be true." );
   static_assert( std::is_same< ConstPointer< std::vector< double > >, double const * >::value, "Should be true." );
-  static_assert( std::is_same< ConstPointer< std::string >, char const * >::value, "Should be true." );
-  static_assert( std::is_same< ConstPointer< array3d< std::string > >, std::string const * >::value, "Should be true." );
+  static_assert( std::is_same< ConstPointer< string >, char const * >::value, "Should be true." );
+  static_assert( std::is_same< ConstPointer< array3d< string > >, string const * >::value, "Should be true." );
   static_assert( std::is_same< ConstPointer< SortedArray< float > >, float const * >::value, "Should be true." );
 }
 
@@ -145,7 +145,7 @@ TEST( testGeosxTraits, CanStreamInto )
 {
   static_assert( CanStreamInto< std::istringstream, int >, "Should be true." );
   static_assert( CanStreamInto< std::istringstream, double >, "Should be true." );
-  static_assert( CanStreamInto< std::istringstream, std::string >, "Should be true." );
+  static_assert( CanStreamInto< std::istringstream, string >, "Should be true." );
 
   static_assert( !CanStreamInto< std::istringstream, array1d< double > >, "Should be false." );
   static_assert( !CanStreamInto< std::istringstream, std::vector< int > >, "Should be false." );

src/coreComponents/codingUtilities/traits.hpp

@@ -51,10 +51,10 @@ static constexpr bool HasMemberFunction_move = LvArray::bufferManipulation::HasM
 
 /**
  * @brief Defines a static constexpr bool HasMemberFunction_setName< @p CLASS >
- *        that is true iff the method @p CLASS ::setName( std::string ) exists.
+ *        that is true iff the method @p CLASS ::setName( string ) exists.
  * @tparam CLASS The type to test.
  */
-HAS_MEMBER_FUNCTION_NO_RTYPE( setName, std::string() );
+HAS_MEMBER_FUNCTION_NO_RTYPE( setName, string() );
 
 /**
  * @brief Defines a static constexpr bool HasMemberFunction_size< @p CLASS >
@@ -142,9 +142,9 @@ using ViewType = LvArray::typeManipulation::ViewType< T >;
 template< typename T >
 using ViewTypeConst = LvArray::typeManipulation::ViewTypeConst< T >;
 
-/// True if T is or inherits from std::string.
+/// True if T is or inherits from string.
 template< typename T >
-constexpr bool is_string = std::is_base_of< std::string, T >::value;
+constexpr bool is_string = std::is_base_of< string, T >::value;
 
 /// True if T is an instantiation of LvArray::Array.
 template< typename T >

src/coreComponents/common/DataTypes.hpp

@@ -498,9 +498,9 @@ class rtTypes
    * @param key the std::type_index of the type
    * @return a hard coded string that is related to the std::type_index
    */
-  static std::string typeNames( std::type_index const key )
+  static string typeNames( std::type_index const key )
   {
-    const std::unordered_map< std::type_index, std::string > type_names =
+    const std::unordered_map< std::type_index, string > type_names =
     {
       {std::type_index( typeid(integer)), "integer"},
       {std::type_index( typeid(real32)), "real32"},
@@ -650,7 +650,7 @@ class rtTypes
 public:
 
     /// The type of map used to store the map of type parsing regular expressions
-    using regexMapType = std::map< std::string, std::string >;
+    using regexMapType = std::map< string, string >;
 
     /**
      * @brief Get an iterator to the beginning of regex map.
@@ -689,14 +689,14 @@ class rtTypes
      *       axes are given as a comma-separated list enclosed in a curly brace.
      *       For example, a 2D string array would look like: {{"a", "b"}, {"c", "d"}}
      */
-    std::string constructArrayRegex( std::string subPattern, integer dimension )
+    string constructArrayRegex( string subPattern, integer dimension )
     {
       if( dimension > 1 )
       {
         subPattern = constructArrayRegex( subPattern, dimension-1 );
       }
 
-      std::string arrayPattern;
+      string arrayPattern;
       if( dimension == 1 )
       {
         // Allow the bottom-level to be empty
@@ -712,10 +712,10 @@ class rtTypes
 
     // Define the component regexes:
     // Regex to match an unsigned int (123, etc.)
-    std::string ru = "[\\d]+";
+    string ru = "[\\d]+";
 
     // Regex to match an signed int (-123, 455, +789, etc.)
-    std::string ri = "[+-]?[\\d]+";
+    string ri = "[+-]?[\\d]+";
 
     // Regex to match a float (1, +2.3, -.4, 5.6e7, 8E-9, etc.)
     // Explanation of parts:
@@ -724,13 +724,13 @@ class rtTypes
     // [\\d]*  matches any number of numbers following the decimal
     // ([eE][-+]?[\\d]+|\\s*)  matches an optional scientific notation number
     // Note: the xsd regex implementation does not allow an empty branch, so use allow whitespace at the end
-    std::string rr = "[+-]?[\\d]*([\\d]\\.?|\\.[\\d])[\\d]*([eE][-+]?[\\d]+|\\s*)";
+    string rr = "[+-]?[\\d]*([\\d]\\.?|\\.[\\d])[\\d]*([eE][-+]?[\\d]+|\\s*)";
 
     // Regex to match a string that does not contain the characters  ,{}
-    std::string rs = "[^,\\{\\}]*";
+    string rs = "[^,\\{\\}]*";
 
     // Regex to match a R1Tensor
-    std::string r1 = "\\s*(" + rr + ",\\s*){2}" + rr;
+    string r1 = "\\s*(" + rr + ",\\s*){2}" + rr;
 
     // Build master list of regexes
     regexMapType regexMap =

src/coreComponents/common/EnumStrings.hpp

@@ -170,7 +170,7 @@ struct TypeRegex< ENUM, std::enable_if_t< internal::HasEnumStrings< ENUM > > >
   /**
    * @brief @return Regex for validating enumeration inputs for @p ENUM type.
    */
-  static std::string get()
+  static string get()
   {
     return EnumStrings< ENUM >::concat( "|" );
   }

src/coreComponents/common/unitTests/testDataTypes.cpp

@@ -15,7 +15,7 @@
 #include <gtest/gtest.h>
 
 #include "common/DataTypes.hpp"
-#include <string>
+
 #include <typeindex>
 
 using namespace geosx;

src/coreComponents/constitutive/ConstitutiveBase.cpp

@@ -43,7 +43,7 @@ using namespace dataRepository;
 namespace constitutive
 {
 
-ConstitutiveBase::ConstitutiveBase( std::string const & name,
+ConstitutiveBase::ConstitutiveBase( string const & name,
                                     Group * const parent ):
   Group( name, parent ),
   m_numQuadraturePoints( 1 ),

src/coreComponents/constitutive/ConstitutiveBase.hpp

@@ -76,7 +76,7 @@ class ConstitutiveBase : public dataRepository::Group
   ///@{
 
   /// @typedef An alias for the ConstitutiveBase catalog
-  using CatalogInterface = dataRepository::CatalogInterface< ConstitutiveBase, std::string const &, Group * const >;
+  using CatalogInterface = dataRepository::CatalogInterface< ConstitutiveBase, string const &, Group * const >;
 
   /**
    * @brief Singleton accessor for catalog

src/coreComponents/constitutive/NullModel.cpp

@@ -27,7 +27,7 @@ NullModel::NullModel( string const & name,
 NullModel::~NullModel()
 {}
 
-REGISTER_CATALOG_ENTRY( ConstitutiveBase, NullModel, std::string const &, dataRepository::Group * const )
+REGISTER_CATALOG_ENTRY( ConstitutiveBase, NullModel, string const &, dataRepository::Group * const )
 
 } // constitutive
 } /* namespace geosx */

src/coreComponents/constitutive/NullModel.hpp

@@ -42,7 +42,7 @@ class NullModel : public constitutive::ConstitutiveBase
   /**
    * @return A string that is used to register/lookup this class in the registry
    */
-  static std::string catalogName() { return m_catalogNameString; }
+  static string catalogName() { return m_catalogNameString; }
 
   virtual string getCatalogName() const override { return catalogName(); }
 

src/coreComponents/constitutive/capillaryPressure/BrooksCoreyCapillaryPressure.cpp

@@ -29,7 +29,7 @@ namespace constitutive
 {
 
 
-BrooksCoreyCapillaryPressure::BrooksCoreyCapillaryPressure( std::string const & name,
+BrooksCoreyCapillaryPressure::BrooksCoreyCapillaryPressure( string const & name,
                                                             Group * const parent )
   : CapillaryPressureBase( name, parent )
 {
@@ -121,7 +121,7 @@ BrooksCoreyCapillaryPressure::KernelWrapper BrooksCoreyCapillaryPressure::create
                         m_dPhaseCapPressure_dPhaseVolFrac );
 }
 
-REGISTER_CATALOG_ENTRY( ConstitutiveBase, BrooksCoreyCapillaryPressure, std::string const &, Group * const )
+REGISTER_CATALOG_ENTRY( ConstitutiveBase, BrooksCoreyCapillaryPressure, string const &, Group * const )
 } // namespace constitutive
 
 } // namespace geosx

src/coreComponents/constitutive/capillaryPressure/BrooksCoreyCapillaryPressure.hpp

@@ -105,12 +105,12 @@ class BrooksCoreyCapillaryPressure : public CapillaryPressureBase
 {
 public:
 
-  BrooksCoreyCapillaryPressure( std::string const & name,
+  BrooksCoreyCapillaryPressure( string const & name,
                                 dataRepository::Group * const parent );
 
   virtual ~BrooksCoreyCapillaryPressure() override;
 
-  static std::string catalogName() { return "BrooksCoreyCapillaryPressure"; }
+  static string catalogName() { return "BrooksCoreyCapillaryPressure"; }
 
   virtual string getCatalogName() const override { return catalogName(); }
 

src/coreComponents/constitutive/capillaryPressure/CapillaryPressureBase.cpp

@@ -42,7 +42,7 @@ std::unordered_map< string, integer > const phaseDict =
 
 }
 
-CapillaryPressureBase::CapillaryPressureBase( std::string const & name,
+CapillaryPressureBase::CapillaryPressureBase( string const & name,
                                               Group * const parent )
   : ConstitutiveBase( name, parent )
 {

src/coreComponents/constitutive/capillaryPressure/CapillaryPressureBase.hpp

@@ -111,7 +111,7 @@ class CapillaryPressureBase : public ConstitutiveBase
   // choose the reference pressure to be the oil pressure for all models
   static constexpr integer REFERENCE_PHASE = PhaseType::OIL;
 
-  CapillaryPressureBase( std::string const & name,
+  CapillaryPressureBase( string const & name,
                          dataRepository::Group * const parent );
 
   virtual ~CapillaryPressureBase() override;

src/coreComponents/constitutive/capillaryPressure/VanGenuchtenCapillaryPressure.cpp

@@ -28,7 +28,7 @@ using namespace dataRepository;
 namespace constitutive
 {
 
-VanGenuchtenCapillaryPressure::VanGenuchtenCapillaryPressure( std::string const & name,
+VanGenuchtenCapillaryPressure::VanGenuchtenCapillaryPressure( string const & name,
                                                               Group * const parent )
   : CapillaryPressureBase( name, parent )
 {
@@ -120,7 +120,7 @@ VanGenuchtenCapillaryPressure::KernelWrapper VanGenuchtenCapillaryPressure::crea
                         m_dPhaseCapPressure_dPhaseVolFrac );
 }
 
-REGISTER_CATALOG_ENTRY( ConstitutiveBase, VanGenuchtenCapillaryPressure, std::string const &, Group * const )
+REGISTER_CATALOG_ENTRY( ConstitutiveBase, VanGenuchtenCapillaryPressure, string const &, Group * const )
 } // namespace constitutive
 
 } // namespace geosx