Re: [fpc-pascal]TCollection question

[James Mills]

On Sun, Jul 06, 2003 at 04:25:15PM +0200, Marco van de Voort wrote:
> > Is there an example of using TCollection or something (without having to
> > write the code myself) that manages a collection of FPC style classes
> > (objects) ?
> > 
> > I'd like to see one, code I have written to handle a dynamic array of
> > objects has gone out of control... (Using FPC classes here)
> 
> IIRC, TCollection only stores TCollectionItem derived classes.
> 
> TList is closer to what you want probably.

Is there an example other than list.pp in the fcl source ?

Also just for the record of knowing... I have attached datanicks.pas
which hold a dynamic array of TNick ... Is this what TList already does
(if so I'm wasting my time writing my own code...) ?

cheers
James

> 
> _______________________________________________
> fpc-pascal maillist  -  [EMAIL PROTECTED]
> http://lists.freepascal.org/mailman/listinfo/fpc-pascal

-- 
-
- James Mills
Zero Defect Software Engineers Group - ZDSEG

unit dataNicks;

interface

uses
	sysUtils, Functions, tokenizerClass, nickClass;

var
	nicks:	PNick;
	nNicks:	Integer;

procedure init;
procedure done;

procedure addNick(data: String);
procedure addNick(data: String; index: Integer);
function backupNick(nick: String): TNick;
procedure copyNickData(srcNick: TNick; destNick: TNick);
function getNick(nick: String): Integer;
procedure delNick(nick: String);

function isIdentified(nick: String): Boolean;
function isIdentified(nick: String; otherNick: String): Boolean;

implementation

procedure init;
begin
	nNicks := 0;
	getMem(nicks, sizeOf(TNick) * nNicks);
end;

procedure done;
var
	I:	Integer;
begin
	for I := 0 to (nNicks - 1) do
		begin
			nicks[I].free;
		end;
	freeMem(nicks);
end;

procedure addNick(data: String);
var
	tokens:	TTokenizer;
	nick:		String;
	hops:		Integer;
	signon:	longInt;
	ident:	String;
	host:		String;
	server:	String;
	unused:	String;
	name:		String;
begin
	tokens := TTokenizer.Create(data);

	nick := tokens.nextToken;
	hops := strToInt(tokens.nextToken);
	signon := strToInt(tokens.nextToken);
	ident := tokens.nextToken;
	host := tokens.nextToken;
	server := tokens.nextToken;
	unused := tokens.nextToken;
	name := strip(tokens.restOfTokens);

	tokens.free;

	inc(nNicks);
	reAllocMem(nicks, sizeOf(TNick) * nNicks);
	nicks[(nNicks - 1)] := TNick.Create(nick, hops, signon, ident, host, server, unused, name);
end;

procedure addNick(data: String; index: Integer);
var
	tokens:	TTokenizer;
	nick:		String;
	hops:		Integer;
	signon:	longInt;
	ident:	String;
	host:		String;
	server:	String;
	unused:	String;
	name:		String;
	tmpNick:	TNick;
	I:			Integer;
begin
	tokens := TTokenizer.Create(data);

	nick := tokens.nextToken;
	hops := strToInt(tokens.nextToken);
	signon := strToInt(tokens.nextToken);
	ident := tokens.nextToken;
	host := tokens.nextToken;
	server := tokens.nextToken;
	unused := tokens.nextToken;
	name := strip(tokens.restOfTokens);

	tokens.free;

	if index < nNicks then
		begin
			tmpNick := backupNick(nick);
			nicks[index].free;
			nicks[index] := TNick.Create(nick, hops, signon, ident, host, server, unused, name);
			copyNickData(tmpNick, nicks[index]);
			tmpNick.free;
		end;
end;

function backupNick(nick: String): TNick;
var
	data:		String;
	tokens:	TTokenizer;
	hops:		Integer;
	signon:	longInt;
	ident:	String;
	host:		String;
	server:	String;
	unused:	String;
	name:		String;
	index:	Integer;
	I:			Integer;
	tmpNick:	TNick;
begin
	index := getNick(nick);

	if index > -1 then
		begin
			data := nicks[index].getData;
			tokens := TTokenizer.Create(data);

			tokens.nextToken;
			hops := strToInt(tokens.nextToken);
			signon := strToInt(tokens.nextToken);
			ident := tokens.nextToken;
			host := tokens.nextToken;
			server := tokens.nextToken;
			unused := tokens.nextToken;
			name := strip(tokens.restOfTokens);

			tokens.free;

			tmpNick := TNick.Create(nick, hops, signon, ident, host, server, unused, name);
			for I := 0 to (nicks[index].numAccess - 1) do
				begin
					tmpNick.addAccess(nicks[index].getAccess(I));
				end;
			tmpNick.addMode(nicks[index].getModes);
			for I := 0 to (nicks[index].numChannels - 1) do
				begin
					tmpNick.addChannel(nicks[index].getChannel(I));
				end;
			tmpNick.setUseMsg(nicks[index].getUseMsg);
			tmpNick.setAutoAdd(nicks[index].getAutoAdd);
			backupNick := tmpNick;
		end
	else
		begin
			backupNick := nil;
		end;
end;

procedure copyNickData(srcNick: TNick; destNick: TNick);
var
	I:	Integer;
begin
	for I := 0 to (srcNick.numAccess - 1) do
		begin
			destNick.addAccess(srcNick.getAccess(I));
		end;
	for I := 0 to (srcNick.numChannels - 1) do
		begin
			destNick.addChannel(srcNick.getChannel(I));
		end;
	destNick.addMode(srcNick.getModes);
	destNick.setUseMsg(srcNick.getUseMsg);
	destNick.setAutoAdd(srcNick.getAutoAdd);
end;

function getNick(nick: String): Integer;
var
	I:			Integer;
	index:	Integer;
begin
	index := -1;
	for I := 0 to (nNicks - 1) do
		begin
			if upperCase(nicks[I].getNick) = upperCase(nick) then
				begin
					index := I;
					break;
				end;
		end;
	getNick := index;
end;

procedure delNick(nick: String);
var
	I:			Integer;
	X:			Integer;
	n:			PNick;
	C:			Integer;
begin
	X := getNick(nick);
	if X > -1 then
		begin
			for I := X to (nNicks - 2) do
				begin
					addNick(nicks[(I + 1)].getData, I);
				end;
		end;
end;

function isIdentified(nick: String): Boolean;
var
	index:	Integer;
	I:			Integer;
begin
	index := getNick(nick);
	if index > -1 then
		begin
			if nicks[index].getAccess(nick) > -1 then
				begin
					isIdentified := TRUE;
				end
			else
				begin
					isIdentified := FALSE;
				end;
		end
	else
		begin
			isIdentified := FALSE;
		end;
end;

function isIdentified(nick: String; otherNick: String): Boolean;
var
	index:	Integer;
begin
	index := getNick(nick);
	if index > -1 then
		begin
			if nicks[index].getAccess(otherNick) > -1 then
				begin
					isIdentified := TRUE;
				end
			else
				begin
					isIdentified := FALSE;
				end;
		end
	else
		begin
			isIdentified := FALSE;
		end;
end;

end.