string_array.h

Go to the documentation of this file.

#ifndef STRING_ARRAY_CLASS
#define STRING_ARRAY_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : string_array                                                      *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1993-$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 "object_packers.h"
 
#include <basis/astring.h>
#include <basis/byte_array.h>
#include <basis/functions.h>
 
namespace structures {
 
 
class string_array
: public basis::array<basis::astring>,
  public virtual basis::packable,
  public virtual basis::equalizable
{
public:
  string_array(int number = 0, const basis::astring *initial_contents = NULL_POINTER)
          : basis::array<basis::astring>(number, initial_contents,
                EXPONE | FLUSH_INVISIBLE) {}
 
 
  string_array(int number, const char *initial_contents[])
      : basis::array<basis::astring>(number, NULL_POINTER, EXPONE | FLUSH_INVISIBLE) {
    for (int i = 0; i < number; i++) {
      put(i, basis::astring(initial_contents[i]));
    }
  }
 
  string_array(const basis::array<basis::astring> &to_copy)
      : basis::array<basis::astring>(to_copy) {}
 
  DEFINE_CLASS_NAME("string_array");
 
  basis::astring text_format(const basis::astring &separator = ",",
          const basis::astring &delimiter = "\"") const {
    basis::astring to_return;
    for (int i = 0; i < length(); i++) {
      to_return += delimiter;
      to_return += get(i);
      to_return += delimiter;
      if (i < last())
        to_return += separator;
    }
    return to_return;
  }
 
  basis::astring text_form() const { return text_format(); }
 
//hmmm: extract as re-usable equality operation.
 
  bool equal_to(const equalizable &to_compare) const {
    const string_array *cast = cast_or_throw(to_compare, *this);
    if (length() != cast->length())
      return false;
    for (int i = 0; i < length(); i++)
      if (cast->get(i) != get(i))
        return false;
    return true;
  }
 
  int find(const basis::astring &to_find) const {
    for (int i = 0; i < length(); i++) {
      if (to_find.equal_to(get(i))) return i;
    }
    return basis::common::NOT_FOUND;
  }
 
 
  bool prefix_compare(const string_array &second) const {
    if (second.length() < length()) return false;
    if (!length()) return false;
    for (int i = 0; i < length(); i++)
      if ((*this)[i] != second[i]) return false;
    return true;
  }
 
  virtual void pack(basis::byte_array &packed_form) const
      { pack_array(packed_form, *this); }
  
  virtual bool unpack(basis::byte_array &packed_form)
      { return unpack_array(packed_form, *this); }
 
  virtual int packed_size() const {
    int to_return = sizeof(int) * 2;  // length packed in, using obscure.
    for (int i = 0; i < length(); i++)
      to_return += get(i).length() + 1;
    return to_return;
  }
};
 
} //namespace.
 
#endif