BorlandTalk.com

Ivo Bauer · Guest

Hi!

I'm designing a "database" of properties of chemical substances. Every
chemical substance needs to be described by properties like density,
molecular mass and so on. For this purpose I wrote class named
TSubstance. Now I need to hold a list of these TSubstances that is
meant to be a "database" (TSubstanceDatabase) where each substance has
to be uniquely identified by its name (string).

I'm not sure how to design this feature in an OO way. If I make the
UniqueName property of TSubstance, how do I ensure that it is really
unique in the context of TSubstanceDatabase when TSubstance is
supposed to know nothing about the TSubstanceDatabase where it
belongs? As for now I decided to go the other way round.
TSubstanceDatabase does not hold a list of TSubstance references
directly but rather TSubstanceItem references:

TSubstanceItem = class
private
FSubstance: TSubstance;
FName: string;
public
constructor Create(const AName: string);
destructor Destroy; override;
property Name: string read FName;
property Substance: TSubstance read FSubstance;
end;

constructor TSubstanceItem.Create(const AName: string);
begin
FName := AName;
FSubstance := TSubstance.Create;
end;

destructor TSubstanceItem.Destroy;
begin
FSubstance.Free;
inherited;
end;

Finally TSubstanceDatabase exposes a relevant methods/properties to
describe the relationship between TSubstance and its unique name.
Could you please comment on this design and tell me if I am going in a
right direction?

I'll post more of related code as a separate post in order to
encourage more people to read this message entirely. :-)

Thanks in advance!

--
Ivo Bauer [OZM Research]

Ivo Bauer · Guest

Here comes my code as promised. TSubstance class looks pretty
straightforward (private details were omitted for the sake of
readability). DiplayName property is used for presentation purposes only:

TSubstance = class
public
property AtomCounts[AKind: TAtomKind]: Integer read GetAtomCount
write SetAtomCount;
property Density: Double read FDensity write SetDensity;
property DisplayName: string read FDisplayName write SetDisplayName;
property EnthalpyOfFormation: Double read FEnthalpyOfFormation
write SetEnthalpyOfFormation;
property MolecularMass: Double read FMolecularMass write
SetMolecularMass;
property Role: TSubstanceRole read FRole write SetRole;
end;

Below is the implementation of substance database. I'd be very
grateful to obtain any comments regarding the class design:

TSubstanceDatabaseItem = class
private
FSubstance: TSubstance;
FName: string;
public
constructor Create(const AName: string);
destructor Destroy; override;
property Name: string read FName;
property Substance: TSubstance read FSubstance;
end;

TSubstanceDatabase = class
private
FItemList: TList;
function GetCount: Integer;
function GetSubstance(AIndex: Integer): TSubstance;
public
function Add(const AName: string): TSubstance;
constructor Create;
procedure Clear;
procedure Delete(AIndex: Integer);
destructor Destroy; override;
function IndexOf(ASubstance: TSubstance): Integer;
function NameBySubstance(ASubstance: TSubstance): string;
function SubstanceByName(const AName: string): TSubstance;
procedure Remove(ASubstance: TSubstance);
property Count: Integer read GetCount;
property Substances[AIndex: Integer]: TSubstance read
GetSubstance; default;
end;

{==============================================================================}
{ TSubstanceDatabaseItem
}
{==============================================================================}

constructor TSubstanceDatabaseItem.Create(const AName: string);
begin
Assert(AName = EmptyStr, 'Substance name may not be empty!');
FName := AName;
FSubstance := TSubstance.Create;
end;

{==============================================================================}

destructor TSubstanceDatabaseItem.Destroy;
begin
FSubstance.Free;
inherited;
end;

{==============================================================================}
{ TSubstanceDatabase
}
{==============================================================================}

function TSubstanceDatabase.Add(const AName: string): TSubstance;
var
VItem: TSubstanceDatabaseItem;
begin
{ TODO : Make sure AName is not empty }
if SubstanceByName(AName) = nil then
begin
VItem := TSubstanceDatabaseItem.Create(AName);
try
FItemList.Add(VItem);
Result := VItem.Substance;
except
VItem.Free;
raise;
end;
end
else
begin
raise ESubstanceDatabaseException.CreateStdError(Self,
@rsDuplicateSubstanceName, 'Add');
end;
end;

{==============================================================================}

procedure TSubstanceDatabase.Clear;
var
I: Integer;
begin
for I := Pred(Count) downto 0 do
Delete(I);
end;

{==============================================================================}

constructor TSubstanceDatabase.Create;
begin
FItemList := TList.Create;
end;

{==============================================================================}

procedure TSubstanceDatabase.Delete(AIndex: Integer);
var
VEntry: TSubstanceDatabaseItem;
begin
VEntry := FItemList[AIndex];
FItemList.Delete(AIndex);
VEntry.Free;
end;

{==============================================================================}

destructor TSubstanceDatabase.Destroy;
begin
Clear;
FItemList.Free;
inherited;
end;

{==============================================================================}

function TSubstanceDatabase.GetCount: Integer;
begin
Result := FItemList.Count;
end;

{==============================================================================}

function TSubstanceDatabase.GetSubstance(AIndex: Integer): TSubstance;
begin
Result := TSubstanceDatabaseItem(FItemList[AIndex]).Substance;
end;

{==============================================================================}

function TSubstanceDatabase.IndexOf(ASubstance: TSubstance): Integer;
begin
for Result := 0 to Pred(FItemList.Count) do
begin
if TSubstanceDatabaseItem(FItemList[Result]).Substance =
ASubstance then Exit;
end;
Result := -1;
end;

{==============================================================================}

function TSubstanceDatabase.NameBySubstance(ASubstance: TSubstance):
string;
var
I: Integer;
begin
I := IndexOf(ASubstance);
if I >= 0 then
Result := TSubstanceDatabaseItem(FItemList[I]).Name
else
Result := EmptyStr;
end;

{==============================================================================}

function TSubstanceDatabase.SubstanceByName(const AName: string):
TSubstance;
var
I: Integer;
VItem: TSubstanceDatabaseItem;
begin
Result := nil;
for I := 0 to Pred(FItemList.Count) do
begin
VItem := FItemList[I];
if AnsiCompareText(VItem.Name, AName) = 0 then
begin
Result := VItem.Substance;
Break;
end;
end;
end;

{==============================================================================}

procedure TSubstanceDatabase.Remove(ASubstance: TSubstance);
var
I: Integer;
begin
I := IndexOf(ASubstance);
if I >= 0 then
Delete(I);
end;

{==============================================================================}

--
Ivo Bauer [OZM Research]

Gerard · Guest

En/na Ivo Bauer ha escrit:

Gerard · Guest

En/na Ivo Bauer ha escrit:

Ivo Bauer · Guest

Gerard napsal(a):

Ivo Bauer · Guest

Hi, Gerard!

Gerard napsal(a):

Gerard · Guest

En/na Ivo Bauer ha escrit:

Gerard · Guest

Hi IVO,

En/na Ivo Bauer ha escrit:

Ivo Bauer · Guest

Hi, Gerard!

Gerard napsal(a):

Bart · Guest

Ivo Bauer · Guest

Hi, Gerard!

Gerard napsal(a):

Ivo Bauer · Guest

Hi, Bart!

Bart napsal(a):

Ivo Bauer · Guest

Ivo Bauer napsal(a):

Gerard · Guest

En/na Ivo Bauer ha escrit:

Bart · Guest

Ivo,

A little bit off topic. But do you know if there is any OPC server or what
so ever which communicates with a Simatic S5 PLC. (Maybe a free one)

I believe this is sort of your business isn't it ?

Regards,

Bart