Rene's FAQ Liste
Dank auch den Schreibern in die dcl*

Liste der FAQ Einträge "Logik, Arrays"

Bitweises Testen von Bytes
Bitweises XOR
Array setzen/zurücksetzen
Arbeiten mit Collections

Bitweises Testen von Bytes

1. if (vbit1 AND 128) = 128 then ...;
2. type
    TByteBit = 0..7;
    TByteBits = set of TByteBit;
    ...
    // Prüfen, ob Bit n gesetzt:
    if n in TByteBits( vbit1 ) then ...

Seitenanfang

Bitweises XOR

  type
    TByteBit = 0..7;
    TByteBits = set of TByteBit;

  function SetXOR (s1, s2: TByteBits): TByteBits;
  var b1: Byte absolute s1;
      b2: byte absolute s2;
  begin
    Result := TByteBits (b1 xor b2);
  end;

Seitenanfang

Array setzen/zurücksetzen

  var
    test : array[0..1000] of Boolean;
  begin
    FillChar(Test, SizeOf(Test), Integer(True|False));
    .. oder..
    FillChar(Test, SizeOf(Test), Ord(True|False));
  end;

Seitenanfang

Arbeiten mit Collections

Eigenschaft wie 'FieldDefs' in TTable sind bekannt unter dem Namen 'Collection'. Um selbst solche Collectionen in eigenen Komponenten zu erstellen, ist relativ viel Code nötig. Hier ist ein Beispiel, wie ein solcher Code aufgebaut sein muss.

 unit Collection;
 
 interface
 uses classes;
 
 type
 TYourComponent = class ; { Den Typen deiner Komponente muss als }
   { forward deklariert sein, da er selbst in der TMyCollection benutzt wird }
 
 TMyCollectionItem = class (TCollectionItem)
   private
     FProp: string;
     procedure SetProp(const Value: string);
   protected
     procedure DefineProperties (Filer : TFiler) ; override ;
     function GetDisplayName : string ; override ;
   public
     constructor Create (Collection : TCollection) ; override ;
     destructor Destroy ; override ;
     procedure Assign (Source : TPersistent) ; override ;
   published
     { Hier werden deine eigene Collection Properties definiert }
     { Als Bsp. ist lediglich Prop definiert worden }
     property Prop : string read FProp write SetProp;
   end;
 
 
 TMyCollection = class (TCollection)
   private
     FOwner : TYourComponent ; { Benutze hier den Typ deiner Komponente }
     function GetItem(Index: integer): TMyCollectionItem;
     procedure SetItem(Index: integer; const Value: TMyCollectionItem);
   protected
     function GetOwner : TPersistent ; override ;
     procedure Update (Item : TCollectionItem) ; override ;
   public
     constructor Create (AOwner : TYourComponent) ;
     function Add : TMyCollectionItem ;
     property YourComponent : TYourComponent read FOwner ;
     property Items[Index : integer]: TMyCollectionItem read GetItem write SetItem ; default ;
   end;
 
 TYourComponent = class (TComponent)
   private
     FItems: TMyCollection;
     procedure SetItems(const Value: TMyCollection);
   public
     constructor Create (AOwner : TComponent) ; override ;
   published
     property Items : TMyCollection read FItems write SetItems;
   end;
 
 
 implementation
 
 { TMyCollectionItem }
 
 procedure TMyCollectionItem.Assign(Source: TPersistent);
 begin
   inherited Assign (Source) ;
 end;
 
 constructor TMyCollectionItem.Create(Collection: TCollection);
 begin
   inherited Create (Collection) ;
 end;
 
 procedure TMyCollectionItem.DefineProperties(Filer: TFiler);
 begin
   inherited DefineProperties (Filer) ;
 end;
 
 destructor TMyCollectionItem.Destroy;
 begin
   inherited Destroy ;
 end;
 
 function TMyCollectionItem.GetDisplayName: string;
 begin
   if (FProp = '')
   then GetDisplayName := inherited GetDisplayName
   else GetDisplayName := FProp ;
 end;
 
 procedure TMyCollectionItem.SetProp(const Value: string);
 begin
   FProp := Value ;
 end;
 
 { TMyCollection }
 
 function TMyCollection.Add: TMyCollectionItem;
 begin
   Result := TMyCollectionItem(inherited Add) ;
 end;
 
 constructor TMyCollection.Create(AOwner: TYourComponent);
 begin
   inherited Create (TMyCollectionItem) ;
   FOwner := AOwner ;
 end;
 
 function TMyCollection.GetItem(Index: integer): TMyCollectionItem;
 begin
   Result := TMyCollectionItem(inherited GetItem(index)) ;
 end;
 
 function TMyCollection.GetOwner: TPersistent;
 begin
   Result := FOwner ;
 end;
 
 procedure TMyCollection.SetItem(Index: integer;
   const Value: TMyCollectionItem);
 begin
   inherited SetItem (Index,Value) ;
 end;
 
 procedure TMyCollection.Update(Item: TCollectionItem);
 begin
   //
 end;
 
 
 { TYourComponent }
 
 constructor TYourComponent.Create(AOwner: TComponent);
 begin
   inherited Create (AOwner) ;
   FItems := TMyCollection.create (Self) ;
 end;
 
 procedure TYourComponent.SetItems(const Value: TMyCollection);
 begin
   FItems := Value;
 end;
 
 end.
 

Seitenanfang