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