Collection in einem ColectionItem

[Cyberaxx]

Hab es jetzt hinbekommen, wußte halt nur nicht wo das TChans hingehört und wie ich es initialisiere.

Delphi-Quellcode:

Type
  TChan = class (TCollectionItem)
  private
    FName: String;
  published
    property Name: String read FName write FName;
  end;

Type
 TChans = class (TCollection)
 private
   function GetItem(Index: Integer): TChan;
 public
  function Add: TChan;
  function Find(AChan: String; Var AIndex: Integer): Boolean;
  property Item[Index: Integer]: TChan read GetItem;
 end;

Type
  TUser = class (TCollectionItem)
  private
    FNick: String;
    FDummy1: String;
    FDummy2: String;
    FUserID: String;
    FAddress: String;
    FServer: String;
    FDummy3: String;
    FName: String;
    FMode: String;
    FHost: String;
    FChans: TChans;
  published
    property Nick: String read FNick write FNick;
    property Dummy1: String read FDummy1 write FDummy1;
    property Dummy2: String read FDummy2 write FDummy2;
    property UserID: String read FUserID write FUserID;
    property Address: String read FAddress write FAddress;
    property Server: String read FServer write FServer;
    property Dummy3: String read FDummy3 write FDummy3;
    property Name: String read FName write FName;
    property Mode: String read FMode write FMode;
    property Host: String read FHost write FHost;
    property Chans: TChans read FChans write FChans;
  end;

Type
 TUsers = class (TCollection)
 private
   FUpdate: TUpdate;
   function GetItem(Index: Integer): TUser;
 public
  function Add: TUser;
  function AddEx(Name : String): TUser;
  function Find(ANick: String; Var AIndex: Integer): Boolean;
  Procedure Upt();
  property Item[Index: Integer]: TUser read GetItem;
  Property Update: TUpdate read FUpdate write FUpdate;
 end;

implementation

{ TUsers }

function TUsers.Add: TUser;
begin
result := inherited Add as TUser;
Result.FChans := TChans.Create(TChan);
end;

Ich hoffe damit seid ihr alle einverstanden, falls nicht nehme ich gerne Verbesserungsvorschläge an.

Dazu kommen aber nun noch einmal zwei kleinere Fragen auf. Eine direkt mit den Collections/Items und die andere mehr so genrell.

Wie sieht es mit dem Speicherbedarf aus. Nehmen wir mal an ich würde eine ULine bei Gamesurge oder Quakenet bekommen. Die Server sind ja recht voll und ich würde nach dem obigen Source alle User inkl. aller Channels in denen sie sind hiermit verwalten. Ca. einige tausend User mit mehreren Channels.
Mit was für einer Speicherbelastung dürfte ich da grob rechnen und wie sieht es noch mit der Geschwindigkeit aus wenn ich einen User suche. Klar ne ULine würde ich nie bekommen aber interessieren würde es mich halt dennoch.

Hierüber Suche ich einen User, dazu gibt es nochmal eine Funktion zum Suchen eines Channels innerhalb des Users.

Delphi-Quellcode:

function TUsers.Find(ANick: String; var AIndex: Integer): Boolean;
begin
Result := False;
AIndex := 0;

While AIndex < Count Do
  Begin
  Result := AnsiCompareText(ANick, Item[AIndex].Nick) = 0;
  If Result Then
    Exit;

  Inc(AIndex);
  End;

AIndex := -1;
end;

Die zweite Frage hat nichts direkt mit der Fragestellung des Threads zu tun aber gehört für mich irgendwie noch zum Thema.

Die Collections und CollectionItems sind in einer eigenen Klasse untergebracht.
Ich habe eine Klasse in der ich die ankommenden Daten auswerte siehe unten und dann von da aus auf eine andere Klasse verweise um den Betreffenden Befehl auszuführen. In dem Fall HandleUsers

Kleiner BeispielSource TIRCService.

Delphi-Quellcode:

    GCMDIndex := GetGenericCMDIndex(FToken);

    If (GCMDIndex > -1) Then
      Begin
      Case GCMDIndex of
        0: If (FConnectionState = sConnected) Then KeepAliveEvent; { PING }
        1: If (FConnectionState = sConnected) Then HandleUsers.AddUser(Users, Str); { NICK }
        //2: { QUIT }
        3: If (FConnectionState = sConnecting) Then SetServerName(Str); { SERVER }
        End;

      Exit;
      End;

HandleUsers

Delphi-Quellcode:

Procedure AddUser(AUsers: TUsers; ANickLine: String);
Var
  User: TUser;
  Index: Integer;
  TmpStr: String;

  CMD: String;
  Nick: String;
  Dummy1: String;
  Dummy2: String;
  UserID: String;
  Address: String;
  Server: String;
  Dummy3: String;
  Name: String;
Begin
TmpStr := ANickLine;

Index := Pos(' ', TmpStr);
CMD := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Index := Pos(' ', TmpStr);
Nick := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Index := Pos(' ', TmpStr);
Dummy1 := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Index := Pos(' ', TmpStr);
Dummy2 := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Index := Pos(' ', TmpStr);
UserID := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Index := Pos(' ', TmpStr);
Address := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Index := Pos(' ', TmpStr);
Server := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Index := Pos(' ', TmpStr);
Dummy3 := Copy(TmpStr, 1, Index -1);
TmpStr := Copy(TmpStr, Index +1, Length(TmpStr) - Index);

Name := Copy(TmpStr, 2, Length(TmpStr) -1);

User := AUsers.Add;
User.Nick := Nick;
User.Dummy1 := Dummy1;
User.Dummy2 := Dummy2;
User.UserID := UserID;
User.Address := Address;
User.Server := Server;
User.Dummy3 := Dummy3;
User.Name := Name;

AUsers.Upt;
End;

Macht es Sinn es so auszulagern? Ich persönlich dachte da hauptsächlich an die Übersicht des Sources.

Gruß

Daniel