Public API Reference

csutil/stringarray.h

Go to the documentation of this file.

/*
  Crystal Space String Array
  Copyright (C) 2003 by Jorrit Tyberghein

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library 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
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_STRINGARRAY_H__
#define __CS_STRINGARRAY_H__

#include <stdarg.h>
#include "csextern.h"
#include "csutil/array.h"
#include "csutil/util.h"
#include "csutil/csstring.h"

class csStringArrayElementHandler : public csArrayElementHandler<const char*>
{
public:
  static void Construct (const char** address, const char* const& src)
  {
    *address = csStrNew (src);
  }

  static void Destroy (const char** address)
  {
    delete[] (char*)*address;
  }

  static void InitRegion (const char** address, size_t count)
  {
    memset (address, 0, count*sizeof (const char*));
  }
};

namespace CS
{
namespace Utility
{
template <class Allocator = CS::Memory::AllocatorMalloc,
          class CapacityHandler = csArrayCapacityFixedGrow<16> >
class StringArray :
  public csArray<const char*, csStringArrayElementHandler, Allocator,
                 CapacityHandler>
{
private:
  typedef csArray<const char*, csStringArrayElementHandler, Allocator,
                  CapacityHandler> superclass;

public:
  StringArray (size_t limit = 0, const CapacityHandler& ch = CapacityHandler())
        : superclass(limit, ch)
  {
  }

  static int CaseSensitiveCompare (const char* const &item1,
                                   const char* const &item2)
  {
    return strcmp (item1, item2);
  }

  static int CaseInsensitiveCompare (const char* const &item1,
                                     const char* const &item2)
  {
    return csStrCaseCmp (item1, item2);
  }

  void Sort (int(*compare)(char const* const&, char const* const&))
  {
    superclass::Sort (compare);
  }

  void Sort (bool case_sensitive = true)
  {
    if (case_sensitive)
      Sort (CaseSensitiveCompare);
    else
      Sort (CaseInsensitiveCompare);
  }

  size_t FindSortedKey (csArrayCmp<char const*, char const*> comparekey,
    size_t* candidate = 0) const
  {
    return superclass::FindSortedKey(comparekey, candidate);
  }

  size_t FindSortedKey (char const* key, bool case_sensitive = true,
    size_t* candidate = 0) const
  {
    int(*cf)(char const* const&, char const* const&) =
      case_sensitive ? CaseSensitiveCompare : CaseInsensitiveCompare;
    return FindSortedKey(csArrayCmp<char const*, char const*>(key, cf),
      candidate);
  }

  size_t InsertSorted (const char* item, bool case_sensitive = true,
    size_t* equal_index = 0)
  {
    int(*cf)(char const* const&, char const* const&) =
      case_sensitive ? CaseSensitiveCompare : CaseInsensitiveCompare;
    return superclass::InsertSorted (item, cf, equal_index);
  }

  char* Pop ()
  {
    CS_ASSERT (this->GetSize () > 0);
    size_t l = this->GetSize () - 1;
    char* ret = (char*)this->Get (l);
    this->InitRegion (l, 1);
    this->SetSize (l);
    return ret;
  }

  size_t Find (const char* str) const
  {
    for (size_t i = 0; i < this->GetSize (); i++)
      if (! strcmp (this->Get (i), str))
        return i;
    return (size_t)-1;
  }

  bool Delete (const char* item)
  {
    size_t const n = Find (item);
    if (n != csArrayItemNotFound)
      return superclass::DeleteIndex (n);
    return false;
  }

  size_t FindCaseInsensitive (const char* str) const
  {
    for (size_t i = 0; i < this->GetSize (); i++)
      if (!csStrCaseCmp (this->Get (i), str))
        return i;
    return (size_t)-1;
  }

  size_t Contains(const char* str, bool case_sensitive = true) const
  {
    return case_sensitive ? Find(str) : FindCaseInsensitive(str);
  }

  enum ConsecutiveDelimiterMode
  {
    delimSplitEach,
    delimIgnore,
    delimIgnoreDifferent
  };

  StringArray (const char* str, const char* delimiters, 
               ConsecutiveDelimiterMode delimMode = delimSplitEach,
               size_t limit = 0, const CapacityHandler& ch = CapacityHandler())
        : superclass(limit, ch)
  {
    SplitString(str, delimiters, delimMode);
  }
  
  size_t SplitString (const char* str, const char* delimiters, 
    ConsecutiveDelimiterMode delimMode = delimSplitEach)
  {
    size_t num = 0;
    csString currentString = "";
    int lastDelim = -1;

    const char* p = str;
    while (*p != 0)
    {
      if (strchr (delimiters, *p))
      {
        bool newString = true;
        switch (delimMode)
        {
          case delimSplitEach:
            break;
          case delimIgnore:
            newString = lastDelim == -1;
            break;
          case delimIgnoreDifferent:
            newString = (lastDelim == -1) || (lastDelim == *p);
            break;
        }
        if (newString)
        {
          this->Push (currentString);
          currentString.Empty();
          num++;
          lastDelim = *p;
        }
      }
      else
      {
        currentString.Append (*p);
        lastDelim = -1;
      }
      p++;
    }

    this->Push (currentString);
    return num + 1;
  }

  csString Join (const char* separator = "")
  {
    if (this->GetSize() == 0) return csString();

    csString str (this->Get (0));
    for (size_t i = 1; i < this->GetSize(); i++)
    {
      str.Append (separator);
      str.Append (this->Get (i));
    }

    return str;
  }
};
} // namespace Utility
} // namespace CS

class csStringArray : 
  public CS::Utility::StringArray<CS::Memory::AllocatorMalloc,
                                  csArrayCapacityDefault>
{
public:
  csStringArray (size_t limit = 0, size_t threshold = 0)
    : CS::Utility::StringArray<CS::Memory::AllocatorMalloc, 
                               csArrayCapacityDefault> (limit, threshold)
  {
  }

  csStringArray (const char* str, const char* delimiters, 
               ConsecutiveDelimiterMode delimMode = delimSplitEach,
               size_t limit = 0, size_t threshold = 0)
    : CS::Utility::StringArray<CS::Memory::AllocatorMalloc, 
                               csArrayCapacityDefault> (str, delimiters, 
                               delimMode, limit, threshold)
  {
  }
};

#endif // __CS_STRINGARRAY_H__

---