nxsstring.h

//  Copyright (C) 1999-2003 Paul O. Lewis and Mark T. Holder
//
//  This file is part of NCL (Nexus Class Library) version 2.0.
//
//  NCL is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  NCL is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with NCL; if not, write to the Free Software Foundation, Inc.,
//  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//

#ifndef NCL_NXSSTRING_H
#define NCL_NXSSTRING_H


#include <cstring>
#include <cstdio>
#include <functional>
#include <ostream>
#include <string>
#include "ncl/nxsdefs.h"

class IndexSet;

class NxsString
  : public std::string
    {
    public:
        enum NxsQuotingRequirements
            {
            kNoQuotesNeededForNexus = 0, 
            kSingleQuotesNeededForNexus, 
            kUnderscoresSufficeForNexus  
            };

        class NxsX_NotANumber {};   /* exception thrown if attempt to convert string to a number fails */
        static bool case_insensitive_equals(const char *o, const char * t);
        static bool to_long(const char *c, long *n);
        static bool to_double(const char *c, double *n);
        static std::string strip_leading_whitespace(const std::string & s);
        static std::string strip_trailing_whitespace(const std::string & s);
        static std::string strip_surrounding_whitespace(const std::string & s);
        static std::string strip_whitespace(const std::string & s);
        static void split(const std::string &s, std::list<std::string> *);
        static std::string get_upper(const std::string &s)
            {
            std::string t(s);
            to_upper(t);
            return t;
            }
        static std::string & to_lower(std::string & s);
        static std::string & to_upper(std::string & s);
        static NxsQuotingRequirements determine_quoting_requirements(const std::string &);
        static void blanks_to_underscores(std::string &s);
        static void add_nxs_quotes(std::string &s);
        static int index_in_vector(const std::string &t, const std::vector<std::string> &v);
        static int index_in_array(const std::string &t, const char * * v, const unsigned n);

        enum CmpEnum                /* enum that is used to specify string comparison modes */
            {
            respect_case,
            no_respect_case,
            abbrev
            };

                            NxsString();
                            NxsString(const char *s);
                            NxsString(const NxsString &s);

        static std::string  GetEscaped(const std::string &s);
        static std::string  GetEscapedInt(const int &v);
        static std::string  GetEscapedDouble(const double &v);
        //  Accessors
        //
        bool                Abbreviates(const NxsString &s, NxsString::CmpEnum mode = NxsString::no_respect_case) const;
        unsigned            ConvertToUnsigned() const;
        int                 ConvertToInt() const;
        long                ConvertToLong() const;
        double              ConvertToDouble() const;
        bool                Equals(const NxsString &s, NxsString::CmpEnum mode = respect_case) const;
        bool                EqualsCaseInsensitive(const NxsString &s) const;
        NxsString           GetQuoted() const;
        bool                IsADouble() const;
        bool                IsALong() const;
        bool                IsCapAbbreviation(const NxsString &s) const;
        bool                IsInVector(const NxsStringVector &s, NxsString::CmpEnum mode = respect_case) const;
        bool                IsStdAbbreviation(const NxsString &s, bool respectCase) const;
        static bool         IsNexusPunctuation(const char c);
        bool                QuotesNeeded() const;
        NxsString           UpperCasePrefix() const;
        friend std::ostream &operator<<(std::ostream &out, const NxsString &s);

        //  Modifiers
        //
        //NxsString        &operator=(const NxsString &s);
        NxsString           &operator=(char);
        NxsString           &operator=(const char *s);
        NxsString           &operator+=(const char *s);
        NxsString           &operator+=(const std::string &s);
        NxsString           &operator+=(const char c);
        NxsString           &operator+=(const int i);
        NxsString           &operator+=(unsigned i);
        NxsString           &operator+=(unsigned long i);
        NxsString           &operator+=(const long l);
        NxsString           &operator+=(const double d);
        NxsString           &operator+=(const IndexSet &d);
        NxsString           &operator<<(int i);
        NxsString           &operator<<(unsigned i);
        NxsString           &operator<<(long l);
        NxsString           &operator<<(unsigned long l);
        NxsString           &operator<<(double d);
        NxsString           &operator<<(const char *c);
        NxsString           &operator<<(char c);
        NxsString           &operator<<(const std::string &s);
        NxsString           &operator<<(const IndexSet &s);
        NxsString           &operator<<(NxsString &(*funcPtr)(NxsString &));

        // Functions that should be in base class string but aren't
        void                clear();

        int                 PrintF(const char *formatStr, ...);

        unsigned char       *p_str(unsigned char *) const;

        NxsString           &AddQuotes();
        NxsString           &AddTail(char c, unsigned n);
        NxsString           &NumberThenWord(unsigned i, NxsString s);
        NxsString           &ShortenTo(unsigned n);
        NxsString           &AppendDouble(unsigned minFieldFormat, unsigned precFormat, double x);
        NxsString           &Capitalize();

        NxsString           &RightJustifyString(const NxsString &s, unsigned w, bool clear_first = false);
        NxsString           &RightJustifyLong(long x, unsigned w, bool clear_first = false);
        NxsString           &RightJustifyDbl(double x, unsigned w, unsigned p, bool clear_first = false);

        NxsString           &ToLower()
            {
            to_lower(*this);
            return *this;
            }
        NxsString           &ToUpper()
            {
            to_upper(*this);
            return *this;
            }


        NxsString           &BlanksToUnderscores();
        NxsString           &UnderscoresToBlanks();

        //  Debugging
        //
        static NxsString    ToHex(long p, unsigned nFours);
    };

#if defined (NXS_SUPPORT_OLD_NAMES)
    typedef NxsString nxsstring;
#endif


inline NxsString &NxsString::AddQuotes()
    {
    add_nxs_quotes(*this);
    return *this;
    }

inline std::string  NxsString::GetEscapedDouble(const double &v)
    {
    NxsString s;
    s << v;
    return NxsString::GetEscaped(s);
    }

inline std::string  NxsString::GetEscapedInt(const int &v)
    {
    NxsString s;
    s << v;
    return NxsString::GetEscaped(s);
    }

inline std::string  NxsString::GetEscaped(const std::string &s)
    {
    NxsQuotingRequirements r = determine_quoting_requirements(s);
    if (r == kNoQuotesNeededForNexus)
        return s;
    std::string x(s.c_str());
    if (r == kUnderscoresSufficeForNexus)
        blanks_to_underscores(x);
    else
        add_nxs_quotes(x);
    return x;
    }


class NStrCaseInsensitiveEquals
    {
    public :

                    NStrCaseInsensitiveEquals(const NxsString &s);
        bool        operator()(const NxsString &s);

    protected :

        NxsString   compStr;
    };

class NStrCaseSensitiveEquals
    {
    public :

                    NStrCaseSensitiveEquals(const NxsString &s);
        bool        operator()(const NxsString &s) const;

    protected :

        NxsString   compStr;
    };

struct NxsStringEqual
  : public std::binary_function<NxsString, NxsString, bool>
    {
    bool operator()(const NxsString &x, const NxsString &y) const;
    };

// ############################# start NStrCaseInsensitiveEquals functions ##########################

inline NStrCaseInsensitiveEquals::NStrCaseInsensitiveEquals(
  const NxsString &s)   /* the string to be compared */
    {
    compStr = s;
    compStr.Capitalize();
    }

inline bool NStrCaseInsensitiveEquals::operator()(
  const NxsString &s)   /* the string to be compared */
    {
    if (s.length() == compStr.length())
        {
        NxsString capS(s);
        capS.Capitalize();
        return capS == compStr;
        }
    return false;
    }

// ############################# start NStrCaseSensitiveEquals functions ##########################

inline NStrCaseSensitiveEquals::NStrCaseSensitiveEquals(
  const NxsString &s)   /* the string that all other strings will be compared to when the (const NxsString &) operator is called */
    {
    compStr = s;
    }

inline bool NStrCaseSensitiveEquals::operator()(
  const NxsString &s)   /* the string to be compared */
  const
    {
    return (compStr == s);
    }

// ############################# start NxsStringEqual functions ##########################

inline bool NxsStringEqual::operator()(
  const NxsString &x,   /* first string */
  const NxsString &y)   /* second string to be compared with `x' */
  const
    {
    return x.EqualsCaseInsensitive(y);
    }

// ############################# start NxsString functions ##########################

inline NxsString::NxsString()
    {
    }

inline NxsString NxsString::GetQuoted()
  const
    {
    NxsString s(*this);
    s.AddQuotes();
    return s;
    }

inline void NxsString::clear()
    {
    erase();
    }

inline bool NxsString::IsInVector(
  const NxsStringVector &s, /* the vector of NxsString objects to be searched */
  NxsString::CmpEnum mode)  /* the argument passed to the Equals function, which is called for every element in the vector `s' */
  const
    {
    for (NxsStringVector::const_iterator sIt = s.begin(); sIt != s.end(); sIt++)
        {
        if (Equals(*sIt, mode))
            return true;
        }
    return false;
    }

inline NxsString::NxsString(
  const char *s)    /* the C-string that forms the basis for the new NxsString object */
    {
    assign(s);
    }

inline NxsString::NxsString(
  const NxsString &s)   /* reference to a NxsString to be used to create this copy */
  :std::string()
    {
    assign(s);
    }

inline NxsString &NxsString::operator=(
  const char *s)    /* the string for comparison */
    {
    assign(s);
    return *this;
    }

//inline NxsString& NxsString::operator=(
//  const NxsString &s)
//  {
//  assign(s);
//  return *this;
//  }

inline NxsString &NxsString::operator+=(
  const char *s)    /* the C-string to be appended */
    {
    append(std::string(s));
    return *this;
    }

inline NxsString &NxsString::operator+=(
  const std::string &s) /* the string to append */
    {
    append(s);
    return *this;
    }

inline NxsString &NxsString::operator+=(
  const char c) /* the character to append */
    {
    char s[2];
    s[0] = c;
    s[1] = '\0';
    append(std::string(s));
    return *this;
    }

inline NxsString &NxsString::operator=(
  char c)   /* the character to which the stored std::string should be set */
    {
    clear();
    return (*this += c);
    }

inline NxsString &NxsString::operator+=(
  const int i)  /* the int to append */
    {
    char tmp[81];
    sprintf(tmp, "%d", i);
    append(tmp);
    return *this;
    }

inline NxsString &NxsString::Capitalize()
    {
    ToUpper();
    return *this;
    }

inline bool NxsString::Abbreviates(
  const NxsString   &s,     /* the full comparison string */
  NxsString::CmpEnum    mode)   /* if equal to abbrev, a non-case-sensitive comparison will be made, otherwise comparison will respect case */
  const
    {
    if (mode == NxsString::abbrev)
        return IsCapAbbreviation(s);
    else
        return IsStdAbbreviation(s, mode == respect_case);
    }

inline NxsString& NxsString::operator+=(
  unsigned i)   /* the integer to be appended */
    {
    char tmp[81];
    sprintf(tmp, "%u", i);
    append(tmp);
    return *this;
    }

inline NxsString& NxsString::operator+=(
  const long l) /* the long integer to be appended */
    {
    char tmp[81];
    sprintf(tmp, "%ld", l);
    append(tmp);
    return *this;
    }

inline NxsString& NxsString::operator+=(
  const unsigned long l)    /* the unsigned long integer to be appended */
    {
    char tmp[81];
    sprintf(tmp, "%lu", l);
    append(tmp);
    return *this;
    }

inline bool NxsString::Equals(
  const NxsString &s,       /* the string to which *this is compared */
  NxsString::CmpEnum mode)  /* should be one of these three: respect_case, no_respect_case or abbrev */
  const
    {
    switch (mode) {
        case NxsString::respect_case :
            return (strcmp(this->c_str(), s.c_str()) == 0);
        case NxsString::no_respect_case :
            return this->EqualsCaseInsensitive(s);
        case NxsString::abbrev :
            return this->IsCapAbbreviation(s);
        default :
            NCL_ASSERT(0);// incorrect setting for mode
        }
    return false;
    }

inline NxsString &NxsString::operator<<(
  NxsString &(*funcPtr)(NxsString &))   /* pointer to a function returning a reference to a NxsString */
    {
    return funcPtr(*this);
    }

inline bool NxsString::IsNexusPunctuation(
  const char c) /* the character in question */
    {
    return (strchr("()[]{}/\\,;:=*\'\"`-+<>", c) != NULL);
    }

inline NxsString &NxsString::NumberThenWord(
  unsigned i,           /* the number */
  const NxsString s)    /* the string needing to be pluralized */
    {
    (*this).erase();
    *this << i << ' ' << s;
    if (i != 1)
        *this << 's';
    return *this;
    }

inline NxsString &NxsString::operator<<(
  int i)    /* the integer to append */
    {
    return (*this += i);
    }

inline NxsString &NxsString::operator<<(
  unsigned i)   /* the unsigned integer to append */
    {
    return (*this += (int) i);
    }

inline NxsString &NxsString::operator<<(
  long l)   /* the long integer to append */
    {
    return (*this += l);
    }

inline NxsString &NxsString::operator<<(
  unsigned long l)  /* the unsigned long integer to append */
    {
    return (*this += l);
    }

inline NxsString &NxsString::operator<<(
  double d) /* the double floating point value to append */
    {
    return (*this += d);
    }

inline NxsString &NxsString::operator<<(
  const char *c)    /* the C-string to append */
    {
    return (*this += c);
    }

inline NxsString &NxsString::operator<<(
  char c)   /* the char to append */
    {
    return (*this += c);
    }

inline NxsString &NxsString::operator<<(
  const std::string &s) /* the NxsString to append */
    {
    return (*this += s);
    }

inline unsigned char *NxsString::p_str(
  unsigned char *buffer)    /* buffer to receive current string in Pascal form (i.e. length in first byte) */
  const
    {
    memmove(buffer + 1, c_str(), length());
    buffer[0] = (unsigned char)length();
    return buffer;
    }

// ############################# start of standalone functions ##########################

# if ! defined(HIDE_NCL_NXSSTRING_ENDL)
/* "Define HIDE_NCL_NXSSTRING_ENDL to hide the dangerous definition of endl from NCLs nxsstring.h" */
inline NxsString &endl(
  NxsString &s) /* the string to which the newline character is to be appended */
    {
    return (s += '\n');
    }
#endif

inline NxsString &nxsendl(
  NxsString &s) /* the string to which the newline character is to be appended */
    {
    return (s += '\n');
    }

inline std::ostream &operator<<(
  std::ostream &out,            /* the stream to which the string `s' is to be written */
  const NxsString &s)   /* the string to write */
    {
    out << s.c_str();
    return out;
    }

NxsStringVector     BreakPipeSeparatedList(const NxsString &strList);
NxsStringVector     GetVecOfPossibleAbbrevMatches(const NxsString &testStr,const NxsStringVector &possMatches);
bool                SetToShortestAbbreviation(NxsStringVector &strVec, bool allowTooShort = false);

#endif

---