G4String.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// G4String
//
// Class description:
//
// Common string type for Geant4
//
// Provides a `std::string` compliant implementation of basic
// strings. It currently inherits from `std::string`, but this should
// not be assumed other than that it will implement the same interface
// as `std::string` as of the minimum C++ standard required by Geant4
// (currently C++17).
//
// It can be passed to any function accepting `std::string` or `std::string_view` 
// arguments. Whilst it currently implements a conversion operator to `const char*`,
// this should be considered deprecated for use outside of Geant4. Passing to
// non-Geant4 functions taking `const char*` arguments should use the
// `std::string::c_str` member function to explicitly convert.
// 
// See `std::string` for primary interfaces, `G4StrUtil` for additional query/manipulation functions
//
// Author: G.Cosmo, 11 November 1999
//---------------------------------------------------------------------
 
#ifndef G4String_hh
#define G4String_hh 1
 
#include <algorithm>
#include <cstring>
#include <iostream>
#include <stdio.h>
#include <string>
#include <string_view>
 
#include "G4Types.hh"
 
class G4String : public std::string
{
 public:
  enum caseCompare
  {
    exact,
    ignoreCase
  };
 
  enum stripType
  {
    leading,
    trailing,
    both
  };
 
  using std::string::string;
  using std::string::operator=;
 
  inline G4String() = default;
  inline G4String(const std::string&);
  inline G4String(const G4String&);
  inline G4String(std::string&&);
  inline G4String(G4String&&);
  inline G4String& operator=(const G4String&);
  inline G4String& operator=(G4String&&);
 
  inline operator const char*() const;
 
  inline reference operator[](int);
 
  inline const_reference operator[](int) const;
 
  [[deprecated("Use std::string::compare, or G4StrUtil::icompare for case-insensitive comparison")]]
  inline G4int compareTo(std::string_view, caseCompare mode = exact) const;
 
  [[deprecated("Use std::getline instead, plus G4StrUtil::lstrip if required")]]
  inline std::istream& readLine(std::istream&, G4bool skipWhite = true);
  
  [[deprecated("Use std::string::erase instead")]]
  inline G4String& remove(size_type);
 
  [[deprecated("Use G4StrUtil::contains instead")]]
  inline G4bool contains(const std::string&) const;
 
  [[deprecated("Use G4StrUtil::contains instead")]]
  inline G4bool contains(char) const;
 
  [[deprecated("Use G4StrUtil::{lstrip,rstrip,strip}_copy instead")]]
  [[nodiscard]] inline G4String strip(stripType strip_Type = trailing, char c = ' ');
 
  [[deprecated("Use G4StrUtil::to_lower/to_lower_copy instead")]]
  inline void toLower();
 
  [[deprecated("Use G4StrUtil::to_upper/to_upper_copy instead")]]
  inline void toUpper();
};
 
//
namespace G4StrUtil
{
  inline void to_lower(G4String& str);
 
  inline G4String to_lower_copy(G4String str);
 
  inline void to_upper(G4String& str);
 
  inline G4String to_upper_copy(G4String str);
 
  void lstrip(G4String& str, char c = ' ');
 
  void rstrip(G4String& str, char c = ' ');
 
  void strip(G4String& str, char c = ' ');
 
  G4String lstrip_copy(G4String str, char c = ' ');
 
  G4String rstrip_copy(G4String str, char c = ' ');
 
  G4String strip_copy(G4String str, char c = ' ');
 
  inline G4bool contains(const G4String& str, std::string_view ss);
 
  inline G4bool contains(const G4String& str, char ss);
 
  inline G4bool contains(const G4String& str, const char* ss);
 
  inline G4bool contains(const G4String& str, const G4String& ss);
 
  inline G4int icompare(std::string_view lhs, std::string_view rhs);
 
  inline bool starts_with(const G4String& str, std::string_view ss);
 
  inline bool starts_with(const G4String& str, G4String::value_type ss);
 
  inline bool starts_with(const G4String& str, const char* ss);
 
  inline bool starts_with(const G4String& str, const G4String& ss);
 
  inline bool ends_with(const G4String& str, std::string_view ss);
 
  inline bool ends_with(const G4String& str, G4String::value_type ss);
 
  inline bool ends_with(const G4String& str, const char* ss);
 
  inline bool ends_with(const G4String& str, const G4String& ss);
 
  inline void safe_erase(G4String& str, G4String::size_type index = 0,
                         G4String::size_type count = G4String::npos);
 
  inline std::istream& readline(std::istream& is, G4String& str, G4bool skipWhite = true);
}  // namespace G4StrUtil
 
#include "G4String.icc"
 
#endif