FXArray.h

/********************************************************************************
*                                                                               *
*                          G e n e r i c   A r r a y                            *
*                                                                               *
*********************************************************************************
* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or                 *
* modify it under the terms of the GNU Lesser General Public                    *
* License as published by the Free Software Foundation; either                  *
* version 2.1 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             *
* Lesser General Public License for more details.                               *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public              *
* License along with this library; if not, write to the Free Software           *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
*********************************************************************************
* $Id: FXArray.h 2335 2006-01-28 02:33:03Z lyle $                           *
********************************************************************************/
#ifndef FXARRAY_H
#define FXARRAY_H

#ifndef FXELEMENT_H
#include "FXElement.h"
#endif

namespace FX {


/// Array of some generic type
template<class TYPE>
class FXArray {
protected:
  TYPE  *ptr;   // Data array
  FXint  num;   // Number in array
public:

  /// Create as empty
  FXArray():ptr(NULL),num(0){
    }

  /// Create with given size n
  FXArray(FXint n):ptr(NULL),num(0){
    if(allocElms(ptr,n)){ constructElms(ptr,n); num=n; }
    }

  /// Create initialized from another array
  FXArray(const FXArray<TYPE>& src):ptr(NULL),num(0){
    if(allocElms(ptr,src.num)){ constructElms(ptr,src.num); copyElms(ptr,src.ptr,src.num); num=src.num; }
    }

  /// Create initialized with n copies of object
  FXArray(const TYPE& src,FXint n):ptr(NULL),num(0){
    if(allocElms(ptr,n)){ constructElms(ptr,n); fillElms(ptr,src,n); num=n; }
    }

  /// Create initialized with array of n objects
  FXArray(const TYPE* src,FXint n):ptr(NULL),num(0){
    if(allocElms(ptr,n)){ constructElms(ptr,n); copyElms(ptr,src,n); num=n; }
    }

  /// Return number of elements
  FXint no() const { return num; }

  /// Change number of elements to n
  bool no(FXint n){
    if(n!=num){
      if(n<num){
        destructElms(ptr+n,num-n);
        if(!resizeElms(ptr,n)) return false;
        }
      else{
        if(!resizeElms(ptr,n)) return false;
        constructElms(ptr+num,n-num);
        }
      num=n;
      }
    return true;
    }

  /// Assign from another list
  FXArray<TYPE>& operator=(const FXArray<TYPE>& src){
    if(ptr!=src.ptr){ no(src.num); copyElms(ptr,src.ptr,src.num); }
    return *this;
    }

  /// Index into array
  TYPE& operator[](FXint i){ return ptr[i]; }
  const TYPE& operator[](FXint i) const { return ptr[i]; }

  /// Index into list
  TYPE& at(FXint i){ return ptr[i]; }
  const TYPE& at(FXint i) const { return ptr[i]; }

  /// Return pointer to list
  TYPE* data() const { return ptr; }

  /// Adopt array from source
  FXArray<TYPE>& adopt(FXArray<TYPE>& src){
    no(0);
    ptr=src.ptr; src.ptr=NULL;
    num=src.num; src.num=0;
    return *this;
    }

  /// Assign object p to list
  FXArray<TYPE>& assign(const TYPE& src){
    if(no(1)){ ptr[0]=src; }
    return *this;
    }

  /// Assign n copies of object to list
  FXArray<TYPE>& assign(const TYPE& src,FXint n){
    if(no(n)){ fillElms(ptr,src,n); }
    return *this;
    }

  /// Assign n objects to list
  FXArray<TYPE>& assign(const TYPE* src,FXint n){
    if(no(n)){ copyElms(ptr,src,n); }
    return *this;
    }

  /// Assign n objects to list
  FXArray<TYPE>& assign(const FXArray<TYPE>& src){
    if(no(src.num)){ copyElms(ptr,src.ptr,src.num); }
    return *this;
    }

  /// Insert an object
  FXArray<TYPE>& insert(FXint pos,const TYPE& src){
    if(no(num+1)){ moveElms(ptr+pos+1,ptr+pos,num-pos-1); ptr[pos]=src; }
    return *this;
    }

  /// Insert n copies of object at specified position
  FXArray<TYPE>& insert(FXint pos,const TYPE& src,FXint n){
    if(no(num+n)){ moveElms(ptr+pos+n,ptr+pos,num-pos-n); fillElms(ptr+pos,src,n); }
    return *this;
    }

  /// Insert n objects at specified position
  FXArray<TYPE>& insert(FXint pos,const TYPE* src,FXint n){
    if(no(num+n)){ moveElms(ptr+pos+n,ptr+pos,num-pos-n); copyElms(ptr+pos,src,n); }
    return *this;
    }

  /// Insert n objects at specified position
  FXArray<TYPE>& insert(FXint pos,const FXArray<TYPE>& src){
    if(no(num+src.num)){ moveElms(ptr+pos+src.num,ptr+pos,num-pos-src.num); copyElms(ptr+pos,src.ptr,src.num); }
    return *this;
    }

  /// Prepend object
  FXArray<TYPE>& prepend(const TYPE& src){
    if(no(num+1)){ moveElms(ptr+1,ptr,num-1); ptr[0]=src; }
    return *this;
    }

  /// Prepend n copies of object
  FXArray<TYPE>& prepend(const TYPE& src,FXint n){
    if(no(num+n)){ moveElms(ptr+n,ptr,num-n); fillElms(ptr,src,n); }
    return *this;
    }

  /// Prepend n objects
  FXArray<TYPE>& prepend(const TYPE* src,FXint n){
    if(no(num+n)){ moveElms(ptr+n,ptr,num-n); copyElms(ptr,src,n); }
    return *this;
    }

  /// Prepend n objects
  FXArray<TYPE>& prepend(const FXArray<TYPE>& src){
    if(no(num+src.num)){ moveElms(ptr+src.num,ptr,num-src.num); copyElms(ptr,src.ptr,src.num); }
    return *this;
    }

  /// Append object
  FXArray<TYPE>& append(const TYPE& src){
    if(no(num+1)){ ptr[num-1]=src; }
    return *this;
    }

  /// Append n copies of object
  FXArray<TYPE>& append(const TYPE& src,FXint n){
    if(no(num+n)){ fillElms(ptr+num-n,src,n); }
    return *this;
    }

  /// Append n objects
  FXArray<TYPE>& append(const TYPE* src,FXint n){
    if(no(num+n)){ copyElms(ptr+num-n,src,n); }
    return *this;
    }

  /// Append n objects
  FXArray<TYPE>& append(const FXArray<TYPE>& src){
    if(no(num+src.num)){ copyElms(ptr+num-src.num,src.ptr,src.num); }
    return *this;
    }

  /// Remove object at pos
  FXArray<TYPE>& erase(FXint pos){
    moveElms(ptr+pos,ptr+pos+1,num-pos-1); no(num-1);
    return *this;
    }

  /// Remove n objects starting at pos
  FXArray<TYPE>& erase(FXint pos,FXint n){
    moveElms(ptr+pos,ptr+pos+n,num-n-pos); no(num-n);
    return *this;
    }

  /// Remove all objects
  FXArray<TYPE>& clear(){
    destructElms(ptr,num); freeElms(ptr); num=0;
    return *this;
    }

  /// Delete data
  ~FXArray(){
    destructElms(ptr,num); freeElms(ptr);
    }
  };

}

#endif