istring.h

Go to the documentation of this file.

#ifndef ISTRING_CLASS
#define ISTRING_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : istring                                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1993-$now By Author.  This program 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.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "definitions.h"

#include <stdarg.h>


class istring
{
public:
  istring();

  istring(const char *initial);

  istring(char c, int repeat);

  istring(const istring &s);

  enum special_flag { UNTERMINATED = 62, SPRINTF = 84 };
  istring(special_flag way, const char *s, ...);

  ~istring();

  int length() const;

  inline int end() const { return length() - 1; }

  inline bool empty() const { return !length(); }
  inline bool non_empty() const { return !empty(); }
  inline bool operator ! () const { return empty(); }

  inline bool t() const { return !empty(); }

  static const istring &empty_string();

  const char *observe() const;

  inline const char *c_str() const { return observe(); }
  inline const char *s() const { return observe(); }

  char get(int index) const;

  char *access();

  inline char *c_str() { return access(); }
  inline char *s() { return access(); }

  char &operator [] (int position);

  const char &operator [] (int position) const;

  inline void put(int position, char to_put) { (*this)[position] = to_put; }

  istring &sprintf(const char *s, ...);

  int convert(int default_value) const;

  long convert(long default_value) const;
  float convert(float default_value) const;
  double convert(double default_value) const;

  bool operator < (const istring &that) const;
  bool operator > (const istring &that) const;
  bool operator <= (const istring &that) const;
  bool operator >= (const istring &that) const;
  bool operator != (const istring &that) const;
  bool operator == (const istring &that) const;

  bool operator == (const char *that) const;
  bool operator != (const char *that) const;

  bool iequals(const istring &that) const;
  bool iequals(const char *that) const;

  bool compare(const istring &to_compare, int start_first,
          int start_second, int count) const;

  bool oy_icompare(const istring &to_compare, int start_first,
          int start_second, int count) const;

  inline bool begins(const istring &maybe_prefix) const
        { return compare(maybe_prefix, 0, 0, maybe_prefix.length()); }
  inline bool operator *= (const istring &maybe_prefix) const
        { return begins(maybe_prefix); }

  inline bool ibegins(const istring &maybe_prefix) const
        { return oy_icompare(maybe_prefix, 0, 0, maybe_prefix.length()); }

  inline bool ends(const istring &maybe_suffix) const {
    const int diff = length() - maybe_suffix.length();
    return (diff >= 0) && compare(maybe_suffix, diff,
        0, maybe_suffix.length());
  }
  inline bool iends(const istring &maybe_suffix) const {
    const int diff = length() - maybe_suffix.length();
    return (diff >= 0) && oy_icompare(maybe_suffix, diff,
        0, maybe_suffix.length());
  }

  istring &operator = (const istring &s);
  istring &operator = (const char *s);

  inline void reset() { zap(0, end()); }

  void reset(special_flag way, const char *s, ...);

  void copy(char *to_stuff, int count) const;

  inline void stuff(char *to_stuff, int count) const { copy(to_stuff, count); }

  istring operator + (const istring &s) const;

  istring &operator += (const istring &s);

  istring &operator += (const char *s);  // this is efficient.
  inline istring operator + (const char *s) const { return *this + istring(s); }
    // this method is not efficient.

  istring &operator += (char c);  

  int find(char to_find, int position = 0, bool reverse = false) const;

  int find(const istring &to_find, int posn = 0, bool reverse = false) const;

  int ifind(char to_find, int position = 0, bool reverse = false) const;
  int ifind(const istring &to_find, int posn = 0, bool reverse = false) const;

  int find_any(const istring &to_find, int position = 0,
          bool reverse = false) const;

  int ifind_any(const istring &to_find, int position = 0,
          bool reverse = false) const;

  int find_non_match(const istring &to_find, int position = 0,
          bool reverse = false) const;

  bool contains(const istring &to_find) const;
  inline bool operator ^= (const istring &to_find) const
          { return contains(to_find); }

  istring substring(int start, int end) const;

  void substring(istring &target, int start, int end) const;

  void pad(int length, char padding = ' ');

  void trim(int length);

  void insert(int position, const istring &to_insert);

  void zap(int start, int end);

  void to_lower();

  void to_upper();
  istring lower() const;
  istring upper() const;

  bool replace(const istring &tag, const istring &replacement);

  bool replace_all(char to_replace, char new_char);
  bool replace_all(const istring &to_replace, const istring &new_string);

  void shrink();

  enum how_to_strip { FROM_FRONT = 1, FROM_END = 2, FROM_BOTH_SIDES = 3 };

  void strip(const istring &strip_list, how_to_strip way = FROM_BOTH_SIDES);

  inline void strip_spaces(how_to_strip way = FROM_BOTH_SIDES)
          { strip(" ", way); }

  inline void strip_white_spaces(how_to_strip way = FROM_BOTH_SIDES)
          { strip(" \t", way); }

  static bool matches(const istring &match_list, char to_match);

  void pack(byte_array &target) const;
  bool unpack(byte_array &source);

//hmmm: rename this--it is not a simple icompare, but a strncasecmp analogue.
  int icompare(const istring &to_compare, int length = -1) const;

  int icompare(const char *to_compare, int length = -1) const;

  static int slow_strncasecmp(const char *first, const char *second,
          int length = -1);

  const byte_sequence &low_level() const;

private:
  byte_sequence *_implementation;

  // the real find methods.
  int char_find(char to_find, int position, bool reverse,
          bool case_sense) const;
  // if "invert_find" is true, then non-matches are reported instead of matches.
  int char_find_any(const istring &to_find, int position, bool reverse,
          bool case_sense, bool invert_find = false) const;
  int str_find(const istring &to_find, int posn, bool reverse,
          bool case_s) const;

  // the functions below are used in the formatting string constructor.
public:  // only for base_sprintf.
  istring &base_sprintf(const char *s, va_list &args);
private:
  char *const *_held_string;  

  void seek_flag(const char *&traverser, char *flag_chars, bool &failure);
  void seek_width(const char *&traverser, char *width_chars);
  void seek_precision(const char *&traverser, char *precision_chars);
  void seek_modifier(const char *&traverser, char *modifier_char);
  void get_type_character(const char *&traverser, va_list &args,
        istring &output_string, const char *flag_chars,
        const char *width_chars, const char *precision_chars,
        const char *modifier_chars);
  public: byte_sequence &get_implem(); private: // for test programs only....
};



class isprintf : public istring
{
public:
  isprintf();
  isprintf(const char *initial, ...);
  isprintf(const istring &s);
};


typedef bool string_comparator_function(const istring &a, const istring &b);

bool istring_comparator(const istring &a, const istring &b);

#endif

---