---

more/gen/gc_string.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  Petter Urkedal
//
//  This file 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 file 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: gc_string.h,v 1.2 2002/08/24 13:57:50 petter_urkedal Exp $


#ifndef MORE_GEN_GC_STRING_H
#define MORE_GEN_GC_STRING_H

#include <more/bits/config.h>

#include <bdwgc/gc.h>
#include <cwchar>
#include <cstdlib>
#include <string>
#include <algorithm>
#include <iostream>
#include <limits>


namespace more {
namespace gen {

  /** \internal */
  inline size_t cstrlen(char const* s) { return std::strlen(s); }
  /** \internal */
  inline size_t cstrlen(wchar_t const* s) { return std::wcslen(s); }

  template<typename Ch> inline      Ch* empty_c_str();
  template<>            inline    char* empty_c_str<char>()    { return ""; }
  template<>            inline wchar_t* empty_c_str<wchar_t>() { return L""; }

  /** \class basic_gc_string gc_string.h more/gen/gc_string.h
      A shallow copied garbage collected string to use for string
      literals.  With a limited set of operations, the string behaves
      as if deep copied.  (Actually, the operations which would break
      the deep-copy semantics, are excluded, at least for now.)  */
  template<typename Char>
    struct basic_gc_string
    {
        typedef Char char_type;
        typedef std::size_t size_type;
//      typedef char_type* iterator;
        typedef char_type const* iterator;
        typedef char_type const* const_iterator;
        static const size_type npos = std::numeric_limits<size_type>::max();

        /** Construct an empty string. */
        basic_gc_string()
            : m_size(0),
              m_storage(0),
              m_ptr(empty_c_str<Char>()) {}

        /** Construct as a copy of c_str. */
        basic_gc_string(char_type const* c_str)
            : m_size(cstrlen(c_str)),
              m_storage(m_size+1),
              m_ptr(alloc(m_storage))
        {
            std::copy(c_str, c_str + m_size, m_ptr);
        }

        /** Construct from persistent constant storage.  The lifetime
            of c_str must be longer than that of the constructed
            string.  c_str is not explicitely allocated, so it may
            point to static or collected memory. c_str must be at
            least \a n characters. */
        basic_gc_string(char_type const* c_str, size_type n)
            : m_size(n),
              m_storage(0),
              m_ptr(const_cast<char_type*>(c_str)) {}

        /** Construct a shallow copy of x. */
        basic_gc_string(basic_gc_string const& x)
            : m_size(x.m_size),
              m_storage(0),
              m_ptr(x.m_ptr) {}

        /** Assign a shallow copy of x. */
        basic_gc_string&
        operator=(basic_gc_string const& x)
        {
            m_ptr = x.m_ptr;
            m_size = x.m_size;
            m_storage = 0;
            return *this;
        }

        /** Return the character an \a i. */
        char_type
        operator[](size_type i) const
        {
            return m_ptr[i];
        }

//      iterator        begin() { return m_ptr; }
//      iterator        end()   { return m_ptr + m_size; }
        const_iterator  begin() const { return m_ptr; }
        const_iterator  end()   const { return m_ptr + m_size; }
        size_type       size()  const { return m_size; }
        size_type       length() const { return m_size; }
        bool            empty() const { return m_size == 0; }

        basic_gc_string&
        append(char_type const* s, size_type n)
        {
            if (m_storage < m_size + n)
                grow(m_size + n);
            std::copy(s, s + n, m_ptr + m_size);
            m_size += n;
            return *this;
        }

        basic_gc_string&
        append(char_type const* s)
        {
            return append(s, std::strlen(s));
        }

        basic_gc_string&
        append(basic_gc_string const& str, size_type pos, size_type n)
        {
            if (n > str.size() - pos)
                n = str.size() - pos;
            return append(str.c_str() + pos, n);
        }

        basic_gc_string&
        append(basic_gc_string const& str)
        {
            return append(str.c_str(), str.size());
        }

        basic_gc_string&
        append(size_type n, char_type ch)
        {
            if (m_storage < m_size + n)
                grow(m_size + n);
            std::fill(m_ptr + m_size, m_ptr + m_size + n, ch);
            m_size += n;
            return *this;
        }

        basic_gc_string&
        operator+=(char_type wc)
        {
            if (m_storage <= m_size)
                grow(m_size + 1);
            m_ptr[m_size++] = wc;
            return *this;
        }

        basic_gc_string&
        operator+=(basic_gc_string const& rhs)
        {
            return append(rhs);
        }

        basic_gc_string&
        operator+=(Char const* rhs)
        {
            return append(rhs);
        }

        char_type const*
        c_str() const
        {
            if (m_storage <= m_size)
                grow(m_size + 1);
            if (m_ptr[m_size] != 0)
                m_ptr[m_size] = 0;
            return m_ptr;
        }

        friend void
        swap(basic_gc_string& x, basic_gc_string& y)
        {
            std::swap(x.m_ptr, y.m_ptr);
            std::swap(x.m_size, y.m_size);
            std::swap(x.m_storage, y.m_storage);
        }

        basic_gc_string
        substr(size_type i, size_type n = npos) const
        {
            if (i + n > m_size)
                n = m_size - i;
            return basic_gc_string(m_ptr + i, n);
        }

      private:
        static Char*
        alloc(size_type size)
        {
            Char* ptr = static_cast<Char*>(GC_malloc(size*sizeof(Char)));
            if (!ptr) {
                std::cerr << "Out of memory." << std::endl;
                abort();
            }
            return ptr;
        }

        void
        grow(size_type minsize) const
        {
            char_type* old = m_ptr;
            m_storage = m_size*2;
            if (m_storage < minsize)
                m_storage = minsize;
            m_ptr = alloc(m_storage);
            std::copy(old, old + m_size, m_ptr);
        }

        size_type m_size;
        mutable size_type m_storage;
        mutable char_type* m_ptr;
    };

  /** True if the strings are equal. */
  template<typename Char>
    inline bool
    operator==(basic_gc_string<Char> const& x, basic_gc_string<Char> const& y)
    {
        return x.size() == y.size()
            && std::equal(x.begin(), x.end(), y.begin());
    }
  template<typename Char>
    inline bool
    operator==(basic_gc_string<Char> const& x, Char const* y)
    {
        return x == basic_gc_string<Char>(y, cstrlen(y));
    }
  template<typename Char>
    inline bool
    operator==(Char const* x, basic_gc_string<Char> const& y)
    {
        return basic_gc_string<Char>(x, cstrlen(x)) == y;
    }

  /** An arbitrary full ordering of strings. Use locale specific versions
      for dictionary ordering. */
  template<typename Char>
    inline bool
    operator<(basic_gc_string<Char> const& x, basic_gc_string<Char> const& y)
    {
        return std::lexicographical_compare(x.begin(), x.end(),
                                            y.begin(), y.end());
    }
  template<typename Char>
    inline bool
    operator<(basic_gc_string<Char> const& x, Char const* y)
    {
        return x < basic_gc_string<Char>(y, cstrlen(y));
    }
  template<typename Char>
    inline bool
    operator<(Char const* x, basic_gc_string<Char> const& y)
    {
        return basic_gc_string<Char>(x, cstrlen(x)) < y;
    }

  /** Concatenation of two strings. */
  template<typename Char>
    inline basic_gc_string<Char>
    operator+(basic_gc_string<Char> const& x, basic_gc_string<Char> const& y)
    {
        typename basic_gc_string<Char>::size_type n = x.size();
        typename basic_gc_string<Char>::size_type k = n + y.size();
        Char* s = static_cast<Char*>(GC_malloc((k + 1)*sizeof(Char)));
        std::copy(x.begin(), x.end(), s);
        std::copy(y.begin(), y.end(), s + n);
        return basic_gc_string<Char>(s, k);
    }

  template<typename Char>
    inline basic_gc_string<Char>
    operator+(Char const* x, basic_gc_string<Char> y)
    {
        return basic_gc_string<Char>(x, cstrlen(x)) + y;
    }

  template<typename Char>
    inline basic_gc_string<Char>
    operator+(basic_gc_string<Char> x, Char const* y)
    {
        return x + basic_gc_string<Char>(y, cstrlen(y));
    }

  typedef basic_gc_string<char> gc_string;
  typedef basic_gc_string<wchar_t> gc_wstring;

  inline std::ostream&
  operator<<(std::ostream& os, gc_string const& str)
  {
      os.write(str.begin(), str.size());
      return os;
  }

}}

#endif

---