astring.h

Go to the documentation of this file.

#ifndef ASTRING_CLASS
#define ASTRING_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : astring                                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$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 "base_string.h"
#include "byte_array.h"
#include "contracts.h"
 
#include <stdarg.h>
 
namespace basis {
 
 
class astring
: public virtual base_string,
  public virtual hoople_standard
{
public:
  astring();
 
  astring(const char *initial);
 
  astring(char c, int repeat);
 
  astring(const astring &s);
 
  astring(const base_string &initial);
 
  enum special_flag { UNTERMINATED = 62, SPRINTF = 84 };
  astring(special_flag way, const char *s, ...);
 
  virtual ~astring();
 
  DEFINE_CLASS_NAME("astring");
 
  virtual int comparator(const astring &s2) const;
 
  int length() const;
 
  int end() const { return length() - 1; }
 
  bool empty() const { return !length(); }
  bool non_empty() const { return !empty(); }
  bool operator ! () const { return empty(); }
 
  bool t() const { return !empty(); }
 
  static const astring &empty_string();
 
  virtual const char *observe() const;
 
  const char *c_str() const { return observe(); }
  const char *s() const { return observe(); }
 
  virtual char get(int index) const;
 
  virtual char *access();
 
  char *c_str() { return access(); }
  char *s() { return access(); }
 
  char &operator [] (int position);
 
  const char &operator [] (int position) const;
 
  virtual void put(int position, char to_put) { (*this)[position] = to_put; }
 
  astring &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 equal_to(const char *that) const;
 
  bool iequals(const astring &that) const;
  bool iequals(const char *that) const;
 
  bool compare(const astring &to_compare, int start_first,
          int start_second, int count, bool case_sensitive) const;
 
  bool begins(const astring &maybe_prefix) const
        { return compare(maybe_prefix, 0, 0, maybe_prefix.length(), true); }
 
  bool ibegins(const astring &maybe_prefix) const
        { return compare(maybe_prefix, 0, 0, maybe_prefix.length(), false); }
 
  bool ends(const astring &maybe_suffix) const {
    const int diff = length() - maybe_suffix.length();
    return (diff >= 0) && compare(maybe_suffix, diff, 0, maybe_suffix.length(), true);
  }
  bool iends(const astring &maybe_suffix) const {
    const int diff = length() - maybe_suffix.length();
    return (diff >= 0) && compare(maybe_suffix, diff, 0, maybe_suffix.length(), false);
  }
 
  astring &operator = (const astring &s);
  astring &operator = (const char *s);
 
  void reset() { zap(0, end()); }
 
  void reset(special_flag way, const char *s, ...);
 
  void copy(char *to_stuff, int count) const;
 
  void stuff(char *to_stuff, int count) const { copy(to_stuff, count); }
 
  astring operator + (const astring &s) const;
 
  astring &operator += (const astring &s);
 
  astring &operator += (const char *s);  // this is efficient.
  astring operator + (const char *s) const { return *this + astring(s); }
    // this method is not efficient.
 
  astring &operator += (char c);  
 
  int find(char to_find, int position = 0, bool reverse = false) const;
 
  int find(const astring &to_find, int posn = 0, bool reverse = false) const;
 
  int ifind(char to_find, int position = 0, bool reverse = false) const;
  int ifind(const astring &to_find, int posn = 0, bool reverse = false) const;
 
  int find_any(const char *to_find, int position = 0,
          bool reverse = false) const;
 
  int ifind_any(const char *to_find, int position = 0,
          bool reverse = false) const;
 
  int find_non_match(const char *to_find, int position = 0,
          bool reverse = false) const;
 
  bool contains(const astring &to_find) const;
 
  bool substring(astring &target, int start, int end) const;
 
  astring substring(int start, int end) const;
 
  // helper methods similar to other string's choppers.
  astring middle(int start, int count);
  astring left(int count);
  astring right(int count);
 
  void pad(int length, char padding = ' ');
 
  void trim(int length);
 
  void insert(int position, const astring &to_insert);
 
  virtual void zap(int start, int end);
 
  void to_lower();
 
  void to_upper();
  astring lower() const;
  astring upper() const;
 
  bool replace(const astring &tag, const astring &replacement);
 
  bool replace_all(char to_replace, char new_char);
  bool replace_all(const astring &to_replace, const astring &new_string);
 
  void shrink();
 
  enum how_to_strip { FROM_FRONT = 1, FROM_END = 2, FROM_BOTH_SIDES = 3 };
 
  void strip(const astring &strip_list, how_to_strip way = FROM_BOTH_SIDES);
 
  void strip_spaces(how_to_strip way = FROM_BOTH_SIDES)
          { strip(" ", way); }
 
  void strip_white_spaces(how_to_strip way = FROM_BOTH_SIDES)
          { strip(" \t", way); }
 
  static bool matches(const astring &match_list, char to_match);
 
  int packed_size() const;
 
  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 astring &to_compare, int length = -1) const;
 
 
 
  // play-yard for implementing base class requirements.
 
  // these implement the orderable and equalizable interfaces.
  virtual bool equal_to(const equalizable &s2) const;
  virtual bool less_than(const orderable &s2) const;
 
  virtual base_string &concatenate_string(const base_string &s);
  virtual base_string &concatenate_char(char c);
  virtual base_string &assign(const base_string &s);
  virtual base_string &upgrade(const char *s);
  virtual bool sub_string(base_string &target, int start, int end) const;
  virtual bool sub_compare(const base_string &to_compare, int start_first,
      int start_second, int count, bool case_sensitive) const;
  virtual void insert(int position, const base_string &to_insert);
  virtual void text_form(base_string &state_fill) const;
 
private:
  byte_array c_character_manager;
 
  // 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 astring &to_find, int position, bool reverse,
          bool case_sense, bool invert_find = false) const;
  int str_find(const astring &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.
  astring &base_sprintf(const char *s, va_list &args);
private:
  char *const *c_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,
        astring &output_string, const char *flag_chars,
        const char *width_chars, const char *precision_chars,
        const char *modifier_chars);
  public: byte_array &get_implementation(); private: // for test programs only....
};
 
 
 
class a_sprintf : public astring
{
public:
  a_sprintf();
  a_sprintf(const char *initial, ...);
  a_sprintf(const astring &s);
};
 
 
typedef bool string_comparator_function(const astring &a, const astring &b);
 
bool astring_comparator(const astring &a, const astring &b);
 
 
void attach(byte_array &packed_form, const char *to_attach);
bool detach(byte_array &packed_form, astring &to_detach);
 
} //namespace.
 
#endif