Subversion Repositories Kolibri OS

  int Delta;//increase buffer Delta

  int Items;//pointer to array of item pointers

  int Limit;//currently allocated size (in elements) of Items list

  TCollection( int ALimit,ADelta );

  int  At( int Index );

  void AtFree( int Index );

  void AtInsert( int Index, Item );

  void DeleteAll( void );

  void Free( int Item );

  void FreeAll( void );

  void FreeItem( int Item );

  void Insert( int Item );

  void SetLimit( int ALimit );

};

:int TCollection::At( int Index )

  return DSDWORD[ Index*sizeof(int)+Items ];

}

:void TCollection::AtDelete( int Index )

//  if(Index<0)||(Index>=Count){/*Error(coIndexError);*/return;}

  ECX = Count-Index-1;

  EDI = Index*sizeof(int)+Items; ESI = EDI+4; $cld; $rep;$movsd;

  Count --;

}

:void TCollection::AtFree( int Index )

  int Item = At( Index);

  AtDelete( Index );

  FreeItem( Item );

}

:void TCollection::AtInsert( int Index, Item )

  $pushfd

  IF( Count == Limit )

  {

    SetLimit( Count+Delta );

  }

  ECX = Count-Index;

  EDI = Count*sizeof(int)+Items;

  ESI = EDI-4; $std $rep $movsd $cld

  DSDWORD[ EDI ] = Item;

  Count ++;

  $popfd

}

:void TCollection::DeleteAll()

  Count=0;

}

:void TCollection::Free( int Item )

  Delete( Item );

  FreeItem( Item );

}

:void TCollection::FreeAll( void )

  int I;

  FOR( I = 0; I < Count; I ++ )FreeItem( At(I) );

  Count = 0;

}

:void TCollection::FreeItem( int Item )

  IF( Item )free( Item );//+++Dispose(PObject(Item), Done);

}

:void TCollection::Insert( int Item )

  AtInsert( Count, Item );

}

:void TCollection::SetLimit( int ALimit )

  int AItems;

  IF( ALimit < Count )ALimit = Count;

  {

    IF( !ALimit ) AItems = 0;

    ELSE

    {

      AItems = malloc(ALimit*sizeof(int) );

      IF( Count )&&( Items )

      {

        CopyMemory( AItems, Items, Limit*sizeof(int) );

      }

    }

    IF( Limit )free( Items );

    Items = AItems;

    Limit = ALimit;

  }

}

:TCollection::TCollection( int ALimit, ADelta )

  Items = 0;

  Count = 0;

  Limit = 0;

  Delta = ADelta;

  SetLimit( ALimit );

  return this;

}

:TCollection::~TCollection( void )

  FreeAll();

  SetLimit(0);

}

struct TSortedCollection:TCollection

  int  comparemethod;

  int  Duplicates;

  TSortedCollection( int ALimit, ADelta );

  int  Compare( int Key1, Key2 );

  int  Search( int Key, Index );

};

:int TSortedCollection::Compare( int Key1, Key2 )

  strcmp( Key1, Key2 );

}

:TSortedCollection::TSortedCollection( int ALimit, ADelta )

{

  comparemethod=#Compare;

  return this;

}

:void TSortedCollection::Insert( int Item )

  int i;

  IF( !Search(/*KeyOf(*/Item/*)*/,#i) ) || ( Duplicates )AtInsert( i, Item );

}

  int L, H, I, C;

  int S;

  S = 0;

  H = Count-1;

  WHILE( L <= H )

  {

    I = L+H >> 1;

    ECX = I*sizeof(int)+Items;

    comparemethod( this, /*KeyOf(*/DSDWORD[ECX]/*)*/, Key );

    C = EAX;

    IF( C < 0 ){ L = I+1; }

    ELSE

    {

      H = I-1;

      IF( !C ){

        S = 1;

        IF( !Duplicates )L = I;

      }

    }

  }

  DSDWORD[ Index ]=L;

  return S;

}