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