col_string.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * 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 program 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., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef COLLECTIONS_STRING_H
#define COLLECTIONS_STRING_H

#include "fastlib/base/base.h"
#include "fastlib/col/arraylist.h"
//#include "arraylist.h"

#include <cstring>

class String {
 private:
  ArrayList<char> array_;

  OBJECT_TRAVERSAL(String) {
    OT_OBJ(array_);
  }
  
  OT_CUSTOM_PRINT(String) {
    const char *c_str = this->c_str();
    OT_OBJ(c_str);
  }

 public:
  String(const char *s) {
    Copy(s);
  }

  void Init() {
    array_.Init(1);
    array_[0] = 0;
  }

  void Init(int finalLength) {
    array_.Init(finalLength + 1);
  }
  
  COMPILER_PRINTF(2, 3)
  const String& InitSprintf(const char *format, ...);
  
  void Copy(const char *str_region_begin, index_t len) {
    array_.Init(len + 1);
    mem::Copy(array_.begin(), str_region_begin, len);
    Terminate();
  }
  
  void Copy(const char *str) {
    array_.InitCopy(str, index_t(strlen(str) + 1));
  }
  
  void Destruct() {
    array_.Renew();
  }
  
  void Swap(String* other) {
    array_.Swap(&other->array_);
  }
  
  void StealDestruct(String *other) {
    array_.InitSteal(&other->array_);
    other->Destruct();
  }
  
  void Steal(ArrayList<char> *null_terminated_char_list) {
    array_.InitSteal(null_terminated_char_list);
  }
  
  void Steal(char *str, index_t len, index_t capacity) {
    array_.InitSteal(str, len + 1, capacity);
  }
  
  void Steal(char *str, index_t len) {
    array_.InitSteal(str, len + 1, len + 1);
  }
  
  void Steal(char *str) {
    Steal(str, strlen(str));
  }
  
  operator const char * () const
   { return array_.begin(); }
  
  const char* c_str() const
   { return array_.begin(); }
  char* c_str()
   { return array_.begin(); }
  
  char* begin()
   { return array_.begin(); }
  const char* begin() const   
   { return array_.begin(); }
  const char *end() const {
    return array_.end() - 1;
  }
  char *end() {
    return array_.end() - 1;
  }
  
  index_t length() const
   { return array_.size() - 1; }
  
  void Truncate(const char *s) {
    array_.Resize(s - begin() + 1);
    Terminate();
  }
  
  void Truncate(index_t newlen) {
    array_.Resize(newlen + 1);
    Terminate();
  }
  
  void SetLength(index_t newlen) {
    array_.Resize(newlen + 1);
    Terminate();
  }
  
  void FixLength()
   { array_.Resize(strlen(array_.begin()) + 1); }
  
  void Terminate() {
    array_.back() = 0;
  }

  void Trim()
   { array_.Trim(); }
  
  index_t Find(char c) const {
    return IndexFromPtr(strchr(array_.begin(), c));
  }
  index_t FindR(char c) const {
    return IndexFromPtr(strrchr(array_.begin(), c));
  }
  index_t Find(const char* s) const {
    return IndexFromPtr(strstr(array_.begin(), s));
  }
  index_t FindAny(const char *char_set, index_t skip_initial = 0) const;
  
  index_t IndexFromPtr(const char *position) const {
    if (unlikely(!position)) {
      return -1;
    } else {
      return index_t(position - begin());
    }
  }

  bool is_empty() const
   { return array_.size() == 1; }
  
  void Append(const char *add_str, index_t add_length) {
    index_t mysize = array_.size();
    array_.Resize(mysize + add_length);
    strcpy(array_.begin() + mysize - 1, add_str);
  }
  
  void Append(const char *add_str) {
    Append(add_str, strlen(add_str));
  }
  
  void Append(char c) {
    array_.back() = c;
    array_.PushBackCopy('\0');
  }
  
  void Append(const String& str) {
    Append(str.array_.begin(), str.length());
  }
  
  
  const String& operator += (const String& o) {
    Append(o);
    return *this;
  }
  
  const String& operator += (char c) {
    Append(c);
    return *this;
  }
  
  const String& operator += (const char *s) {
    Append(s);
    return *this;
  }
  
  char operator [] (index_t index) const
   { return array_[index]; }
  char& operator [] (index_t index)
   { return array_[index]; }
  
  index_t Split(index_t start_index, const char *delimeters,
      const char *donechars, index_t max_portions,
      ArrayList<String> *result) const;
  
  index_t Split(const char *delimeters, ArrayList<String> *result) const {
    return Split(0, delimeters, "", 0, result);
  }
  
  void TrimLeft(const char *delimeters, String *result) const;

  void TrimRight(const char *delimeters, String *result) const;

  void Trim(const char *delimeters, String *result) const;

  int CompareNoCase(const char *s) const {
    return strcasecmp(array_.begin(), s);
  }
  bool EqualsNoCase(const char *s) const {
    return CompareNoCase(s) == 0;
  }
  
  bool StartsWith(const char *s) const {
    return strncmp(array_.begin(), s, strlen(s)) == 0;
  }
  
  int CompareTo(const String& other) const
   { return strcmp(begin(), other.begin()); }
  int CompareTo(const char* s) const
   { return strcmp(begin(), s); }

  friend bool operator < (const String& a, const String& b) {
     return strcmp(a.begin(), b.begin()) < 0;
  }
  EXPAND_LESS_THAN(String);
  friend bool operator == (const String& a, const String& b) {
     return strcmp(a.begin(), b.begin()) == 0;
  }
  EXPAND_EQUALS(String);
  
  friend bool operator < (const char *a, const String& b) {
     // >
     return strcmp(a, b.begin()) < 0;
  }
  EXPAND_HETERO_LESS_THAN(const char *, String);
  friend bool operator < (const String& a, const char *b) {
     // >
     return strcmp(a.begin(), b) < 0;
  }
  EXPAND_HETERO_LESS_THAN(String, const char *);
  friend bool operator == (const String& a, const char *b) {
     return strcmp(a.begin(), b) == 0;
  }
  EXPAND_HETERO_EQUALS(String, const char *);
  
  friend bool operator < (char a, const String& b) {
     // >
     DEBUG_ASSERT(b != '\0');
     return a < b[0] || (unlikely(a == b[0]) && b[1] != '\0');
  }
  EXPAND_HETERO_LESS_THAN(char, String);
  friend bool operator < (const String& a, char b) {
     // >
     DEBUG_ASSERT(b != '\0');
     return a[0] < b;
  }
  EXPAND_HETERO_LESS_THAN(String, char);
  friend bool operator == (const String& a, char b) {
     DEBUG_ASSERT(b != '\0');
     return a[0] == b && a[1] == '\0';
  }
  EXPAND_HETERO_EQUALS(String, char);
};

#endif