---

strings.H

Go to the documentation of this file.

/*
 * Copyright 1997, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef STRINGS_H
#define STRINGS_H

#include <string.h>
#include <stdio.h>
#include "std/config.H"
#include "std/hash.H"
#include "std/ref.H"
#include "std/list.H"

/* ------------------ class definitions --------------------- */

#define cSTR const STR
class STR : public REFcounter {
  protected:
   char *_s;
   static DllImpExp HASH<char*> *strpool;
  public:
   static DllImpExp STR *null;

   STR()                    { _s = 0; }
   STR(const char *s)       { if (!strpool) strpool = new HASH<char*>(128); 
                              if (!s) s = "";
                              strpool->add(s, 0, _s); }
   STR(char        s)       { char str[2]; str[0]=s; str[1] = '\0'; 
                              if (!strpool) strpool = new HASH<char*>(128); 
                              strpool->add(str, 0, _s); }
   STR(const STR  &s)       { _s = s._s; }
   STR(int         x)       { char buff[1024];sprintf(buff,"%d", x);
                              if (!strpool) strpool = new HASH<char*>(128);
                  strpool->add(buff, 0, _s); }
   STR(double      d)       { char buff[1024];sprintf(buff,"%g", d);
                              if (!strpool) strpool = new HASH<char*>(128);
                  strpool->add(buff, 0, _s); }
  ~STR()                    { }
   size_t len()               const { return strlen(_s); }
   STR  &operator = (cSTR &s)       { _s = s._s; return *this;}
   char *operator * ()        const { return _s; }
   char  operator [](int   i) const { return _s[i]; }
   int   operator ==(cSTR &s) const { return _s == s._s; }
   STR*  operator + (cSTR &s) const { char buff[1024];
                                      sprintf(buff,"%s%s",_s,s._s);
                                      return new STR(buff); }
   int   contains   (cSTR &s) const { return strstr(_s, s._s) != 0; }
   friend inline ostream &operator<<(ostream &os, cSTR *s) { return os<< s->_s;}
};

#define Cstr_ptr const str_ptr
#define Cstr_list const str_list
class str_ptr;

typedef LIST<str_ptr> str_list;
//
//  str_ptrs -- reference counted strings
//    support standard string operations including
//   the '+' operator for concatenating strings.
//   NOTE: the '+' operator doesn't seem to work on the right
//         hand side of the ? operator on the SGIs.
//
extern DllImpExp Cstr_ptr null_str_ptr;
class DllImpExp str_ptr : public REFptr<STR> {
  public :
   static Cstr_ptr &null_str() { if (null_str_ptr.p_ == 0) 
                                    ((str_ptr&) null_str_ptr) = (STR::null=new STR(""));
                                 return null_str_ptr; }

   str_ptr()              : REFptr<STR>(new STR("")){ }
   str_ptr(Cstr_ptr   &p) : REFptr<STR>(p)          { }
   str_ptr(STR        *s) : REFptr<STR>(s?s:null_str_ptr.p_){ }
   str_ptr(const char *s) : REFptr<STR>(new STR(s)) { }
   str_ptr(char        c) : REFptr<STR>(new STR(c)) { }
   str_ptr(int         x) : REFptr<STR>(new STR(x)) { }
   str_ptr(double      d) : REFptr<STR>(new STR(d)) { }
   size_t  len        ()            const { return   p_->len(); }
   char    operator [](int i)       const { return   (*p_)[i];  }
   int     operator ==(Cstr_ptr &s) const { return   *s.p_ == *p_;  }
   int     operator !=(Cstr_ptr &s) const { return !(*s.p_ == *p_); }
   int     operator !  ()           const { return (!p_ || !**p_ || !***p_) ; }
           operator int()           const { return !(!p_ || !**p_ || !***p_) ; }
   str_ptr operator + (int       i) const { return *this + str_ptr(i);}
   str_ptr operator + (const char *s) const { return str_ptr(*p_ + STR(s)); }
   str_ptr operator + (Cstr_ptr &s) const { return str_ptr(*p_ + *s.p_); }
   str_ptr to_upper   () const;
   str_ptr to_lower    () const;
   int     contains   (Cstr_ptr &s) const {return p_->contains(*s.p_);}
   // Does this string contain any of the strings in str_list s?
   int     contains   (Cstr_list &s) const;
   friend inline ostream &operator << (ostream &s, Cstr_ptr &p) { return s << **p; }
   friend inline istream &operator >> (istream &s,  str_ptr &p) {
      char buf[1000] = "\0"; s >> buf; p = str_ptr(buf); return s; }
};

#ifdef GLUE_AVOID_STATIC_LOCAL_INLINE_VAR
#   define RET_STAT_STR(s)  return str_ptr(s)
#else
#   define RET_STAT_STR(s)  static str_ptr st(s); return st
#endif

DllImpExp str_list tokenize(Cstr_ptr &str, Cstr_ptr &delim=" ");
extern str_list dir_list(Cstr_ptr &directory);

#endif // STRINGS_H

---