RiverSoftAVG Products Help

Create

Creates the interface list

Destroy

Represents the destructor of the TInterfaceListPersistent class.

Capacity

Specifies the list capacity.

Use Capacity to determine the list capacity. Before adding many interfaces to the list, you can improve performance by setting Capacity to the final number of interfaces. This prevents the interface list from having to reallocate the list every time an interface is added.
 

Count

Specifies the number of interfaces in the list.

Use Count to determine the number of interfaces in the list.
 

Items[Integer]

Provides direct access to an interface in the list.

Use Items to directly access an interface in the list. Index identifies each interface by its position in the list.

Note: In Delphi, Items is the default property of TInterfaceListPersistent. That means you can omit the property name. Thus, instead of writing:

Delphi

InterfaceList1.Items[i]

Add(IInterface)

Adds an interface to the list.

Call Add to add an interface to the list. For multithreading purposes, the list is locked before the adding operation begins and unlocked afterwards.

The function returns the index at which the newly added interface is found.
 

Assign(IInterface)

Overloaded. Copies the input List interfaces to the current list. The current list is cleared.

Assign(TPersistent)

Overloaded. Copies the input List interfaces to the current list. The current list is cleared.

Clear

Clears the interface list.

Call Clear to remove all the interfaces from the list.

Clone

Creates a copy of the list.

Delete(Integer)

Deletes an interface from the list.

Call Delete to delete an interface from the list.
 

Equals(IInterface)

Overloaded. Returns true if the input AValue equals the current list.

Exchange(Integer,Integer)

Swaps the position of two interfaces in the list.

Call Exchange to move the interface at position Index1 so that it appears at position Index2 and move the interface at position Index2 so that it appears at position Index1. Index1 and Index2 identify two positions (zero offset) in the Items property array.
 

Expand

Increases the capacity of the interface list.

If Capacity is greater than 64, then Capacity is increased by Capacity / 4. If Capacity is between eight and 64, Capacity is increased by 16. If Capacity is less than eight, Capacity is increased by four.
 

First

Returns the first interface in the list.

Call First to obtain the first interface in the list.
 

Get(Integer)

Accessor method for the   Items property.

GetCapacity

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Capacity property.

GetCount

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Count property.

GetEnumerator

Returns a TInterfaceList enumerator.

GetEnumerator returns a TInterfaceListIterator reference, which enumerates all IInterfaces in the Interface list.
 

To do so, call the TInterfaceListIterator GetCurrent method within a While MoveNext do loop.
 

GetTag

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Tag property.

get_Tag

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Tag property.

IndexOf(IInterface)

Returns the index of an interface.

Call IndexOf to obtain the index of an interface.

IndexOfItem(IInterface,TDirection)

Returns the index of an interface. The Direction parameter controls which direction the search should go: forward from 0 or backwards from Count-1.

Call IndexOfItem to obtain the index of an interface.

Insert(Integer,IInterface)

Inserts an interface into the list at a specified position.

Call Insert to insert an interface into the list. Item is the interface to insert, and Index indicates the position (zero-offset) where the interface should be added.
 

Last

Returns the last interface in the list.

Call Last to obtain the last interface in the list.
 

Lock

Prevents other threads from accessing the list.

Call Lock to lock the list, preventing other threads from accessing the list.
 

Move(Integer,Integer)

Moves the interface at CurIndex to the NewIndex location.

Notify(IInterface,TListNotification)

Called when an interface is added, removed, or extracted from the list

Put(Integer,IInterface)

Accessor method for the   Items property.

QueryInterface(TGUID,Void)

Represents method QueryInterface(TGUID,Void).

Remove(IInterface)

Removes an interface from the list.

Call Remove to remove an interface from the list. For multithreading purposes, the list is locked before the removing operation begins and unlocked afterwards.

Remove returns either the index of the removed interface or –1, if the interface was not found.

RemoveItem(IInterface,TDirection)

Removes an interface from the list. The Direction parameter controls which direction the search should go: forward from 0 or backwards from Count-1.

Call RemoveItem to remove an interface from the list. For multithreading purposes, the list is locked before the removing operation begins and unlocked afterwards.

RemoveItem returns either the index of the removed interface or –1, if the interface was not found.

SetCapacity(Integer)

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Capacity property.

SetCount(Integer)

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Count property.

SetTag(TRSTag)

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Tag property.

set_Tag(TRSTag)

Accessor method for the RSInterfaceCollections.TInterfaceListPersistent.Tag property.

Sort

Overloaded.  Performs a QuickSort on the list.

Call Sort to sort the items in the Items array.
 

Sort(IComparer)

Overloaded.  Performs a QuickSort on the list based on the comparison function Compare.

Call Sort to sort the items in the Items array. AComparer is a comparison function that indicates how the items are to be ordered.
 

Unlock

Unlocks the list, allowing other threads to access it.

Call Unlock to unlock the list so that other threads can have access to the interfaces it contains.
 

_AddRef

Represents method _AddRef.

_Release

Represents method _Release.

FRefCount

Represents field FRefCount.

  TMyOwner = class;
   TMyList = class(TIList)
   private
     { Private Declarations }
     FOwner: TMyOwner;
   protected
     { Protected Declarations }
     procedure Notify(Item: IUnknown; Action: TListNotification); override;
     property Owner: TMyOwner read FOwner;
   public
     { Public Declarations }
     constructor Create( AOwner: TMyOwner ); virtual;
   published
     { Published Declarations }
   end;
 
   TMyOwner = class
   private
     FMyList: TMyList;
     { Private declarations }
   protected
     { Protected declarations }
     procedure ListNotification(Item: IUnknown; Action: TListNotification); virtual;
   public
     { Public declarations }
     constructor Create; virtual;
     destructor Destroy; override;
     property List: TMyList read FMyList;
   published
     { Published declarations }
   end;
 
 implementation
 
 { TMyList }
 
 constructor TMyList.Create(AOwner: TMyOwner);
 begin
      inherited Create;
      FOwner := AOwner;
 end;
 
 procedure TMyList.Notify(Item: IUnknown; Action: TListNotification);
 begin
      inherited;
      if Owner <> nil then
         Owner.ListNotification( Item, Action );
 end;
 
 { TMyOwner }
 
 constructor TMyOwner.Create;
 begin
      FMyList := TMyList.Create(Self);
 end;
 
 destructor TMyOwner.Destroy;
 begin
      FMyList.Free;
      inherited Destroy;
 end;
 
 procedure TMyOwner.ListNotification(Item: IUnknown;
   Action: TListNotification);
 begin
      case Action of
        lnAdded:     ;
        lnExtracted,
        lnDeleted:   ;
      end;
 end;