/******************************************************************************
FILE:               BpArray.hh
LANGUAGE:           C++
SYSTEM:             ANSI (stdio)
USER-INTERFACE:     None
DESCRIPTION
    This C++ class defines arrays of objects.
    Note: if a pre-condition is not fulfilled then the methods will RAISE
    an exception.
AUTHOR
    <PJB> Pascal J. Bourguignon
MODIFICATIONS
    Revision 1.1  2001/06/05 06:38:19  uid1006
    Added common libraries and dosname utility to the repository.

    Revision 1.6  95/11/23  03:47:43  pascal
    Added BpClass and runtime class support in BpObject.
    Updated subclasses.

    Added dependant/dependee in BpObject.

    Revision 1.5  95/10/22  03:19:32  pascal
    Setting revision name V1.

    Revision 1.2  95/10/22  03:04:20  pascal
    Modifications while agdding BpDict.

    1992-07-21 <PJB> Creation.
    1993-01-18 <PJB> Refined, added exceptions.
    1993-03-19 <PJB> Renamed BpXxxx for "B"ourguignon's C"P"lusplus library;
                    (instead of "B"ourguignon's "O"bjective-C library, or
                                "B"ourguignon's "C" library).
                    This is needed for we can mix Objective-C with CPlusPlus
                    in the same sources.
LEGAL
    Copyright Pascal J. Bourguignon 1992 - 2011

    This file is part of the bplib library..

    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; see the  file COPYING; if  not, write to
    the Free  Software Foundation, Inc.,  59 Temple Place,  Suite 330,
    Boston, MA 02111-1307 USA
******************************************************************************/
#ifndef __BpArray__
#define __BpArray__
#include <names.h>
#include BcInterface_h
#include BcTypes_h
#include BpObject_hh
#include BpClass_hh

#define BpArray_eBadIndex       (10022) // BpArray* array,CARD32 badindex

    typedef void (*BpArray_ActionPr)(BpObject* obj);
    typedef void (*BpArray_ActionWithPr)(BpObject* obj,BpObject* with);
    typedef void (*BpArray_ActionWithAndWithPr)
                    (BpObject* obj,BpObject* with, BpObject* andWith);

#define BpArray_SUPER BpObject
class BpArray:public BpArray_SUPER
{
public:

// birth and death:

    CONSTRUCTOR(BpArray)
        /*
            NOTE:       My constructors have all zero parameters! Use resize
                        to set the newSize.
            POST:       this->size()==0.
                        You should send a resize message to allocate wanted
                        size.
            RETURN:     self;
        */

    DESTRUCTOR(BpArray)
        /*
            DO:         Release the memory used by self.
            NOTE:       This does release the objects in the array.
        */

// override BpObject methods:

    METHOD(BpArray,makeBrother,(void),BpObject*)
    METHOD(BpArray,printOnLevel,(FILE* file,CARD32 level),void)

// new methods:

    METHOD(BpArray,initWithObjectsCount,(BpObject** objects,CARD32 count),void)
        /*
            POST:       this->size()=count
                        for each i in [0..count-1],
                            objects[i]==this->objectAt(i).
        */

    METHOD(BpArray,size,(void),CARD32)
        /*
            RETURN:     the current size of the array.
        */

    METHOD(BpArray, resize,(CARD32 newSize),BpArray*)
        /*
            PRE:        newSize>[self size]
                        m=Minimum([self size],newSize)
                        for each i in [0..m-1], t[i]=[self objectAt:i];
            POST:       [self size]=newSize,
                        for each i in [0..m-1], t[i]=[self objectAt:i],
                        for each i in [m..[self size]-1],
                                                [self objectAt:i]=NIL;
            NOTE:       it is possible but meaningless to set the size to 0.
            RETURN:     self.
        */

    METHOD(BpArray,objectAt,(CARD32 index),BpObject*)
        /*
            PRE:        index<[self size];
            RETURN:     the element in the slot index of the array self
        */

    METHOD(BpArray,replaceObjectAtWith,
                (CARD32 index,BpObject* newObject), BpObject*)
        /*
            PRE:        index<[self size];
            POST:       [self objectAt:index]=newObject;
            NOTE:       retains newObject and releases returned object.
            RETURN:     the old [self objectAt:index];
        */

    METHOD(BpArray,insertObjectAt,(BpObject* newObject,CARD32 index),BpArray*)
        /*
            PRE:        index<[self size],
                        for each i in [index..[self size]-2],
                                t[i]=[self objectAt:i];
            POST:       [self objectAt:index]=newObject,
                        for each i in [index+1..[self size]-1],
                                t[i-1]=[self objectAt:i];
            RETURN:     self;
            NOTE:       [self objectAt:[self size]-1] is lost.
            NOTE:       retains newObject.
        */

    METHOD(BpArray,removeObjectAt,(CARD32 index),BpObject*)
        /*
            PRE:        index<[self size],
                        for each i in [index..[self size]-1],
                                t[i]=[self objectAt:i];
            POST:       [self objectAt:[self size]-1]=NIL,
                        for each i in [index..[self size]-2],
                                t[i+1]=[self objectAt:i];
            NOTE:       releases returned object.
            RETURN:     g => t[index];
        */

    METHOD(BpArray,indexOf,(BpObject* oldObject),CARD32)
        /*
            RETURN:     the smallest index such as
                            [self objectAt:index]=oldObject,
                        or MAX_CARD32.
        */

    METHOD(BpArray,makeObjectsPerform,(BpArray_ActionPr proc),BpArray*)
        /*
            DO:         send the message aSelector:anObject to each element
                        of the array.
        */

    METHOD(BpArray,makeObjectsPerformWith,
            (BpArray_ActionWithPr proc,BpObject* anObject),BpArray*)
        /*
            DO:         send the message aSelector:anObject to each element
                        of the array.
        */

    METHOD(BpArray,withEachMakePerform,
            (BpObject* receiver,BpArray_ActionWithPr proc),BpArray*)
        /*
            DO:         for each current in self,
                            [receiver perform:sel with:current].
        */

    METHOD(BpArray,withEachMakePerformWithAndWith,
            (BpObject* receiver,BpArray_ActionWithAndWithPr proc,
             BpObject* obj),BpArray*)
        /*
            DO:         for each current in self,
                            [receiver perform:sel with:current with:obj].
        */

// SEE: We may need a method stopping the loop when the receiver returns FALSE.

protected:
    CARD32          lsize;          // array size
    CARD32          psize;          // size of elements array (size<=psize).
    BpObject**      elements;       // actually ARRAY [0..size-1] OF id;
    // psize is there for when we reduce the size of the array, we don't want
    // to copy the elements array.
};//BpArray.


#define BpArray_cInitializedWithObjects     (1)
#define BpArray_cResized                    (2)
#define BpArray_cObjectReplaced             (3)
#define BpArray_cObjectInserted             (4)
#define BpArray_cObjectRemoved              (5)




#endif
ViewGit