?? arrays.h
字號:
return oarray.isFull();
}
void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
{
oarray.forEach( f, args );
}
Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
void _FAR *args
) const
{
return oarray.firstThat( f, args );
}
Object _FAR *lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
void _FAR *args
) const
{
return oarray.lastThat( f, args );
}
int getItemsInContainer() const
{
return oarray.getItemsInContainer();
}
int ownsElements()
{
return oarray.ownsElements();
}
void ownsElements( int del )
{
oarray.ownsElements( del );
}
protected:
BI_IArrayAsVector<Object> oarray;
};
class _CLASSTYPE BI_OArrayAsVectorIterator :
public BI_IArrayAsVectorIterator<Object>
{
public:
BI_OArrayAsVectorIterator( const BI_OArrayAsVector _FAR &a ) :
BI_IArrayAsVectorIterator<Object>(a.oarray)
{
restart();
}
void restart()
{
BI_IArrayAsVectorIterator<Object>::restart();
if( current() == 0 )
(*this)++;
}
};
/*------------------------------------------------------------------------*/
/* */
/* class BI_TCArrayAsVector */
/* */
/* Implements an Object array, with the full semantics of */
/* the BC 2.0 style array, using a vector as the underlying */
/* implementation. */
/* */
/*------------------------------------------------------------------------*/
class _CLASSTYPE BI_TCArrayAsVector : public AbstractArray
{
public:
friend class _CLASSTYPE BI_TCArrayAsVectorIterator;
BI_TCArrayAsVector( int upper, int lower = 0, sizeType delta = 0 ) :
array( upper, lower, delta )
{
}
virtual Object& operator []( int loc )
{
return ptrToRef(array[loc]);
}
virtual Object& operator []( int loc ) const
{
return ptrToRef(array[loc]);
}
virtual int lowerBound() const
{
return array.lowerBound();
}
virtual int upperBound() const
{
return array.upperBound();
}
virtual sizeType arraySize() const
{
return array.arraySize();
}
void add( Object _FAR &o )
{
array.add(&o);
}
void addAt( Object _FAR &o, int loc )
{
array.addAt(&o,loc);
}
virtual void detach( int loc, DeleteType dt = NoDelete )
{
array.detach( loc, dt );
}
void detach( Object _FAR &o,
TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
)
{
array.detach( &o, dt );
}
void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
{
array.flush( dt );
}
int hasMember( Object _FAR &o ) const
{
return array.hasMember(&o);
}
Object _FAR &findMember( Object _FAR &o ) const
{
return ptrToRef(array.findMember(&o));
}
int isEmpty() const
{
return array.isEmpty();
}
int isFull() const
{
return array.isFull();
}
void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
{
array.forEach( f, args );
}
Object _FAR &firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
void _FAR *args
) const
{
return ptrToRef(array.firstThat( f, args ));
}
Object _FAR &lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
void _FAR *args
) const
{
return ptrToRef(array.lastThat( f, args ));
}
int getItemsInContainer() const
{
return array.getItemsInContainer();
}
virtual classType isA() const
{
return arrayClass;
}
virtual char _FAR *nameOf() const
{
return "BI_TCArrayAsVector";
}
int ownsElements()
{
return array.ownsElements();
}
void ownsElements( int del )
{
array.ownsElements( del );
}
ContainerIterator _FAR &initIterator() const;
private:
BI_OArrayAsVector array;
};
class _CLASSTYPE BI_TCArrayAsVectorIterator : public ContainerIterator
{
public:
BI_TCArrayAsVectorIterator( const BI_TCArrayAsVector _FAR &a ) :
iter(a.array)
{
}
virtual operator int()
{
return int(iter);
}
virtual Object _FAR & current()
{
return Object::ptrToRef(iter.current());
}
virtual Object _FAR & operator ++ ( int )
{
return Object::ptrToRef(iter++);
}
virtual Object _FAR & operator ++ ()
{
return Object::ptrToRef(++iter);
}
virtual void restart()
{
iter.restart();
}
private:
BI_OArrayAsVectorIterator iter;
};
inline ContainerIterator _FAR & BI_TCArrayAsVector::initIterator() const
{ return *new BI_TCArrayAsVectorIterator( *this ); }
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_SArrayAsVector */
/* */
/* Implements a sorted array of objects of type T, using a vector as */
/* the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class _CLASSTYPE BI_SArrayAsVector :
public BI_ArrayAsVectorImp<BI_SVectorImp<T>,T>
{
public:
friend class _CLASSTYPE BI_SArrayAsVectorIterator<T>;
BI_SArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
BI_ArrayAsVectorImp<BI_SVectorImp<T>,T>( upper, lower, delta )
{
}
T& operator []( int loc )
{
grow( loc );
return data[zeroBase(loc)];
}
T& operator []( int loc ) const
{
PRECONDITION( loc >= lowerbound && loc < data.count() );
return data[zeroBase(loc)];
}
void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
{
if( !isEmpty() )
data.forEach( f, args );
}
T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
void _FAR *args
) const
{
if( isEmpty() )
return 0;
return data.firstThat( f, args );
}
T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
void _FAR *args
) const
{
if( isEmpty() )
return 0;
return data.lastThat( f, args );
}
};
template <class T> class _CLASSTYPE BI_SArrayAsVectorIterator :
BI_VectorIteratorImp<T>
{
public:
BI_SArrayAsVectorIterator( const BI_SArrayAsVector<T> _FAR & a ) :
BI_VectorIteratorImp<T>(a.data) {}
};
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_ISArrayAsVector */
/* */
/* Implements an indirect sorted array of objects of type T, using a */
/* vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class _CLASSTYPE BI_ISArrayAsVector :
public BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>,
public virtual TShouldDelete
{
public:
friend class _CLASSTYPE BI_ISArrayAsVectorIterator<T>;
BI_ISArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR*>( upper, lower, delta )
{
}
~BI_ISArrayAsVector()
{
flush();
}
T _FAR * _FAR & operator []( int loc )
{
grow( loc );
return data[zeroBase(loc)];
}
T _FAR * _FAR & operator []( int loc ) const
{
PRECONDITION( loc >= lowerbound && loc < data.count() );
return data[zeroBase(loc)];
}
void add( T _FAR *t )
{
BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>::add(t);
}
void addAt( T _FAR *t, int loc )
{
BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>::addAt(t,loc);
}
void detach( int loc, DeleteType dt = NoDelete )
{
data.detach( loc, delObj(dt) );
}
void detach( T _FAR *t, DeleteType dt = NoDelete )
{
unsigned loc = data.find( t );
if( loc == UINT_MAX )
return;
data.detach( loc, delObj(dt) );
}
void flush( DeleteType dt = DefDelete )
{
data.flush( delObj(dt), data.limit(), 0 );
}
int find( const T *t ) const
{
return data.find( (T *)t );
}
void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
{
if( !isEmpty() )
data.forEach( f, args );
}
T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
void _FAR *args
) const
{
if( isEmpty() )
return 0;
return data.firstThat( f, args );
}
T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
void _FAR *args
) const
{
if( isEmpty() )
return 0;
return data.lastThat( f, args );
}
};
template <class T> class _CLASSTYPE BI_ISArrayAsVectorIterator :
public BI_IVectorIteratorImp<T>
{
public:
BI_ISArrayAsVectorIterator( const BI_ISArrayAsVector<T> _FAR &a ) :
BI_IVectorIteratorImp<T>(a.data) {}
};
/*------------------------------------------------------------------------*/
/* */
/* class BI_ISObjectVector */
/* */
/* Implements a sorted vector of pointers to Object. */
/* This is implemented through the template BI_ISVectorImp<Object>. */
/* */
/*------------------------------------------------------------------------*/
class _CLASSTYPE BI_ISObjectVector :
public BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >
{
public:
BI_ISObjectVector( unsigned sz, unsigned d = 0 ) :
BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >(sz)
{
delta = d;
}
~BI_ISObjectVector()
{
flush();
}
void add( Object _FAR *o );
void addAt( Object _FAR *t, unsigned loc )
{
BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::addAt(t,loc);
}
void detach( unsigned loc, int del = 0 )
{
BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::detach( loc, del );
}
void detach( Object _FAR *t, int del = 0 )
{
unsigned loc = find( t );
if( loc == UINT_MAX )
return;
BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::detach( loc, del );
}
void flush( int del = 0 )
{
BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::flush( del );
}
unsigned find( Object _FAR *t ) const
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -