StringUtil.hpp

#ifndef STK_UTIL_DIAG_StringUtil_h
#define STK_UTIL_DIAG_StringUtil_h
 
#include <algorithm>
#include <functional>
#include <string>
#include <cctype>
#include <limits>
 
#include <stk_util/util/FeatureTest.hpp>
#include <stk_util/diag/String.hpp>
 
namespace sierra {
 
 
int case_strcmp(const char *c1, const char *c2);
 
int case_strncmp(const char *c1, const char *c2, size_t n);
 
inline int case_strcmp(const std::string &s1, const std::string &s2) {
  return case_strcmp(s1.c_str(), s2.c_str());
}
 
inline int case_strcmp(const String &s1, const String &s2) {
  return case_strcmp(s1.c_str(), s2.c_str());
}
 
const char *case_strstr(const char *t, const char *find);
 
inline const char *case_strstr(const std::string &s1, const std::string &s2) {
  return case_strstr(s1.c_str(), s2.c_str());
}
 
inline const char *case_strstr(const String &s1, const String &s2) {
  return case_strstr(s1.c_str(), s2.c_str());
}
 
 
/*
 * @brief Member function <b>undef_if_empty</b> returns the string value
 * "<undefined>" if the string <b>s</b> is empty, otherwise it returns the string.
 *
 * @param s   a <b>String</b> reference to the string to check if empty.
 *
 * @return    a <b>String</b> value of "<undefined>" if the string
 *      <b>s</b> is empty, otherwise the string.
 */
inline String undef_if_empty(const String &s) {
  return s.empty() ? "<undefined>" : s;
}
 
inline int to_upper(int c) {
  return std::toupper(c);
}
 
inline int to_lower(int c) {
  return std::tolower(c);
}
 
inline int to_identifier_upper(int c) {
  return std::isspace(c) ? '_' : std::toupper(c);
}
 
inline int to_identifier_lower(int c) {
  return std::isspace(c) ? '_' : std::tolower(c);
}
 
template <class T>
inline T &make_upper(T &name) {
  std::transform(name.begin(), name.end(), name.begin(), to_upper);
 
  return name;
}
 
template <class T>
inline T &make_lower(T &name) {
  std::transform(name.begin(), name.end(), name.begin(), to_lower);
 
  return name;
}
 
template <class T>
inline T &make_identifier(T &name) {
  std::transform(name.begin(), name.end(), name.begin(), to_identifier_upper);
 
  return name;
}
 
template <class T>
inline T &make_lower_identifier(T &name) {
  std::transform(name.begin(), name.end(), name.begin(), to_identifier_lower);
 
  return name;
}
 
inline char *make_identifier(char *name) {
  for (char *c = name; *c != 0; ++c )
    *c = to_identifier_upper(*c);
 
  return name;
}
 
inline char *make_lower_identifier(char *name) {
  for (char *c = name; *c != 0; ++c )
    *c = to_identifier_lower(*c);
 
  return name;
}
 
template <class T>
inline T &
trim(
  T &     name)
{
  typename T::iterator it0 = name.begin();
  while (it0 != name.end() && std::isspace(*it0))
    ++it0;
 
  typename T::iterator it1 = name.end();
  while (it1 != it0 && std::isspace(*(it1 - 1)))
    --it1;
  return name = T(it0, it1);
}
 
std::string title(const std::string &s);
 
inline std::string title(const String &s) {
  return title(std::string(s.c_str()));
}
 
 
inline String lower(const String &s)
{
  String t = s;
  return make_lower(t);
}
 
std::string to_string(const double &r, int precision = 4);
 
std::string to_string(const float &r, int precision = 4);
 
template <typename T>
std::string to_string(const T &t);
 
#ifdef SIERRA_USE_PLATFORM_DEMANGLER
// Implement this is Slib_EnvPlatform.C
std::string demangle(const char *symbol);
#else
const char *demangle(const char *symbol);
#endif
 
std::string format_time(double t, const char *format = "%b %e %Y %H:%M:%S");
 
std::string word_wrap(const std::string &s, unsigned int line_length,
          const std::string &prefix, const std::string &prefix_first_line);
 
inline std::string word_wrap(const std::string &s, unsigned int line_length = 72, const std::string &prefix = "") {
  return word_wrap(s, line_length, prefix, prefix);
}
 
 
class object_phrase
{
public:
  object_phrase(int n, const char *noun, const char *singlar = "is", const char *plural = "are")
    : m_n(n),
      m_noun(noun),
      m_singular(singlar),
      m_plural(plural)
  {}
 
  std::ostream &print(std::ostream &os) const;
 
  operator std::string () const;
 
private:
  int     m_n;      
  const char *    m_noun;     
  const char *    m_singular;   
  const char *    m_plural;   
};
 
inline std::ostream &operator<<(std::ostream &os, const object_phrase &phrase) {
  return phrase.print(os);
}
 
 
std::istream &getline(std::istream &is, sierra::String &s, char eol = '\n');
 
template <class T>
struct less_nocase : public std::binary_function<T, T, bool>
{
  bool operator()(const T &lhs, const T &rhs) const {
    typename T::const_iterator lhs_it = lhs.begin();
    typename T::const_iterator rhs_it = rhs.begin();
    typename T::const_iterator lhs_it_end = lhs.end();
    typename T::const_iterator rhs_it_end = rhs.end();
 
    for (; lhs_it != lhs_it_end && rhs_it != rhs_it_end; ++lhs_it, ++rhs_it) {
      int i =  std::tolower(*lhs_it) - std::tolower(*rhs_it);
      if (i != 0)
  return i < 0;
    }
 
    if (lhs_it == lhs_it_end)
      return rhs_it != rhs_it_end;
    else
      return false;
  }
};
 
 
template <>
struct less_nocase<String> : public std::binary_function<String, String, bool>
{
  bool operator()(const String &lhs, const String &rhs) const {
    const char * lhs_it = lhs.c_str();
    const char * rhs_it = rhs.c_str();
    const char * lhs_it_end = lhs_it + lhs.length();
    const char * rhs_it_end = rhs_it + rhs.length();
 
    for (; lhs_it != lhs_it_end && rhs_it != rhs_it_end; ++lhs_it, ++rhs_it) {
      int i =  std::tolower(*lhs_it) - std::tolower(*rhs_it);
      if (i != 0)
  return i < 0;
    }
 
    if (lhs_it == lhs_it_end)
      return rhs_it != rhs_it_end;
    else
      return false;
  }
};
 
 
template <>
struct less_nocase<std::string> : public std::binary_function<std::string, std::string, bool>
{
  bool operator()(const std::string &lhs, const std::string &rhs) const {
    const char * lhs_it = lhs.c_str();
    const char * rhs_it = rhs.c_str();
    const char * lhs_it_end = lhs_it + lhs.length();
    const char * rhs_it_end = rhs_it + rhs.length();
 
    for (; lhs_it != lhs_it_end && rhs_it != rhs_it_end; ++lhs_it, ++rhs_it) {
      int i =  std::tolower(*lhs_it) - std::tolower(*rhs_it);
      if (i != 0)
  return i < 0;
    }
 
    if (lhs_it == lhs_it_end)
      return rhs_it != rhs_it_end;
    else
      return false;
  }
};
 
 
template<>
struct less_nocase<const char *> : public std::binary_function<const char *, const char *, bool>
{
  bool operator()(const char *lhs , const char *rhs) const {
    bool result ;
    if (NULL == lhs )
      result = NULL != rhs;
    else {
      for (; *lhs && *rhs && std::tolower(*lhs) == std::tolower(*rhs); ++lhs, ++rhs)
  ;
      result = std::tolower(*lhs) < std::tolower(*rhs);
    }
    return result ;
  }
};
 
 
template <class T>
struct equal_nocase : public std::binary_function<T, T, bool>
{
  bool operator()(const T &lhs, const T &rhs) const {
    typename T::const_iterator lhs_it = lhs.begin();
    typename T::const_iterator rhs_it = rhs.begin();
    typename T::const_iterator lhs_it_end = lhs.end();
    typename T::const_iterator rhs_it_end = rhs.end();
 
    for (; lhs_it != lhs_it_end && rhs_it != rhs_it_end; ++lhs_it, ++rhs_it) {
      if (std::tolower(*lhs_it) != std::tolower(*rhs_it))
  return false;
    }
 
    return lhs_it == lhs_it_end && rhs_it == rhs_it_end;
  }
};
 
template <>
struct equal_nocase<String> : public std::binary_function<String, String, bool>
{
  bool operator()(const String &lhs, const String &rhs) const {
    const char * lhs_it = lhs.c_str();
    const char * rhs_it = rhs.c_str();
    const char * lhs_it_end = lhs_it + lhs.length();
    const char * rhs_it_end = rhs_it + rhs.length();
 
    for (; lhs_it != lhs_it_end && rhs_it != rhs_it_end; ++lhs_it, ++rhs_it) {
      if (std::tolower(*lhs_it) != std::tolower(*rhs_it))
  return false;
    }
 
    return lhs_it == lhs_it_end && rhs_it == rhs_it_end;
  }
};
 
template <>
struct equal_nocase<std::string> : public std::binary_function<std::string, std::string, bool>
{
  bool operator()(const std::string &lhs, const std::string &rhs) const {
    const char * lhs_it = lhs.c_str();
    const char * rhs_it = rhs.c_str();
    const char * lhs_it_end = lhs_it + lhs.length();
    const char * rhs_it_end = rhs_it + rhs.length();
 
    for (; lhs_it != lhs_it_end && rhs_it != rhs_it_end; ++lhs_it, ++rhs_it) {
      if (std::tolower(*lhs_it) != std::tolower(*rhs_it))
  return false;
    }
 
    return lhs_it == lhs_it_end && rhs_it == rhs_it_end;
  }
};
 
template <>
struct equal_nocase<const char *> : public std::binary_function<const char *, const char *, bool> {
  bool operator()(const char *lhs , const char *rhs) const {
    bool result = lhs == rhs ;
    if ( ! result && NULL != lhs && NULL != rhs ) {
      for (; *lhs && *rhs && std::tolower(*lhs) == std::tolower(*rhs) ; ++lhs, ++rhs);
      result = 0 == *lhs && 0 == *rhs ;
    }
    return result ;
  }
};
 
template <class _Key> struct hash_nocase {};
 
inline
size_t hash_string_nocase(
  const char *    p)
{
  size_t h = 0;
  const size_t sr = std::numeric_limits<unsigned char>::digits *  sizeof(size_t) - 8;
  const size_t mask = ((size_t) 0xF) << (sr + 4);
  while (*p) {
    h = (h << 4) + std::tolower(*p++);
    size_t g = h & mask;
    h ^= g | (g >> sr);
  }
  return h;
}
 
template<>
struct hash_nocase<std::string>
{
  size_t operator()(const std::string & __s) const { return hash_string_nocase(__s.c_str()); }
};
 
template<>
struct hash_nocase<String>
{
  size_t operator()(const String & __s) const { return hash_string_nocase(__s.c_str()); }
};
 
// /**
//  * @brief Class specialization <b>hash_nocase</b> for <b>std::string</b>.
//  *
//  */
// template<>
// struct hash_nocase<const std::string>
// {
//   /**
//    * @brief Member function <b>operator()</b> returns the hash value of the
//    * specified string.
//    *
//    * @param __s    a <b>std::string</const reference to the string to hash.
//    *
//    * @return   a <b>size_t</b> value of the hash value of the specified
//    *     string.
//    */
//   size_t operator()(const std::string & __s) const { return hash_string_nocase(__s.c_str()); }
// };
 
// /**
//  * @brief Class specialization <b>hash_nocase</b> for <b>std::string</b>.
//  *
//  */
// template<>
// struct hash_nocase<const String>
// {
//   /**
//    * @brief Member function <b>operator()</b> returns the hash value of the
//    * specified string.
//    *
//    * @param __s    a <b>std::string</const reference to the string to hash.
//    *
//    * @return   a <b>size_t</b> value of the hash value of the specified
//    *     string.
//    */
//   size_t operator()(const String & __s) const { return hash_string_nocase(__s.c_str()); }
// };
 
 
template <class T>
T convert_cast(const String &s);
 
} // namespace sierra
 
#endif // STK_UTIL_DIAG_StringUtil_h