Cannot assign value to object with array of records - arrays

I'm writing a simple object that contain array of records. Just like invoice.(ID,date,customer name and array of records about the items).
type
Trows = record
private
Fcode: string;
Qty: Double;
cena: Currency;
procedure Setcode(const value: string);
public
property code: string read Fcode write SetCode;
end;
Tcart = class(TObject)
private
Frow: array of Trows;
function Getrow(Index: Integer): Trows;
procedure Setrow(Index: Integer; const Value: Trows);
public
ID: integer;
CustName: string;
Suma: currency;
Payed: boolean;
constructor Create(const Num: Integer);
destructor Destroy;
function carttostr: string;
procedure setcode(Index: integer;val: string);
property Row[Index: Integer]: Trows read Getrow write setrow;
end;
Everything seems fine since I'm trying to change value of one record. I have found 3 ways to do it. First, and second worked ok, but I'd like to simplify the code modifying the value of this record like this:
cart.row[0].code:='333';
but it doesn't work.
What am I'm missing?
Here is the code:
procedure TForm1.Button1Click(Sender: TObject);
var
Arows: Trows;
begin
Cart:=Tcart.Create(0);
cart.custName:='Customer 1';
cart.Suma:=5.55;
cart.Payed:=false;
Arows.code:='123';
cart.setrow(0,Arows); // this way working
cart.setcode(0,'333'); // this way also working
cart.row[0].code:='555'; //this way doesn''t change value. How to make it work?
memo1.Lines.Text:=cart.carttostr;
end;

It doesn't work because your Row[] property returns a TRows record by value, which means the caller receives a copy of the original record. Any modifications you make to the copy are not reflected in the original.
You need to assign the copy back to the property to apply changes:
procedure TForm1.Button1Click(Sender: TObject);
var
Arows: Trows;
begin
...
Arows := cart.row[0];
Arows.code:='555';
cart.row[0] := Arows; // <-- equivalent to 'cart.setrow(0,Arows);'
...
end;

Related

How can i add an item to this kind of array in Delphi?

I have a variable called apps which I think is a dynamic array:
apps2 = array of app3;
app3 = class(TRemotable)
private
Fname_: appNameType;
Fid: appIdType;
published
property name_: appNameType Index (IS_UNQL) read Fname_ write Fname_;
property id: appIdType Index (IS_UNQL) read Fid write Fid;
end;
I have a class inititateTechnicalRegistration and I must pass some value to its apps property. How can i do it?
initiateTechnicalRegistration_Type = class(TRemotable)
private
FpartnerName: partnerNameType;
FpartnerOrganizationIdentifier: partnerOrganizationIdentifierType;
Fapps: apps2;
Fapps_Specified: boolean;
Fdescription: descriptionType;
Fdescription_Specified: boolean;
FcontactEmail: contactEmailType;
FrequestedRole: Array_Of_roleType;
FpublicKey: string;
FpartnerAddress: partnerAddressType;
FpartnerAddress_Specified: boolean;
FpartnerURL: partnerURLType;
FpartnerURL_Specified: boolean;
procedure Setapps(Index: Integer; const Aapps2: apps2);
function apps_Specified(Index: Integer): boolean;
procedure Setdescription(Index: Integer; const AdescriptionType: descriptionType);
function description_Specified(Index: Integer): boolean;
procedure SetpartnerAddress(Index: Integer; const ApartnerAddressType: partnerAddressType);
function partnerAddress_Specified(Index: Integer): boolean;
procedure SetpartnerURL(Index: Integer; const ApartnerURLType: partnerURLType);
function partnerURL_Specified(Index: Integer): boolean;
public
constructor Create; override;
destructor Destroy; override;
published
property partnerName: partnerNameType Index (IS_UNQL) read FpartnerName write FpartnerName;
property partnerOrganizationIdentifier: partnerOrganizationIdentifierType Index (IS_UNQL) read FpartnerOrganizationIdentifier write FpartnerOrganizationIdentifier;
property apps: apps2 Index (IS_OPTN or IS_UNQL) read Fapps write Setapps stored apps_Specified;
property description: descriptionType Index (IS_OPTN or IS_UNQL) read Fdescription write Setdescription stored description_Specified;
property contactEmail: contactEmailType Index (IS_UNQL) read FcontactEmail write FcontactEmail;
property requestedRole: Array_Of_roleType Index (IS_UNBD or IS_UNQL) read FrequestedRole write FrequestedRole;
property publicKey: string Index (IS_UNQL) read FpublicKey write FpublicKey;
property partnerAddress: partnerAddressType Index (IS_OPTN or IS_UNQL) read FpartnerAddress write SetpartnerAddress stored partnerAddress_Specified;
property partnerURL: partnerURLType Index (IS_OPTN or IS_UNQL) read FpartnerURL write SetpartnerURL stored partnerURL_Specified;
end;
initiateTechnicalRegistration = class(initiateTechnicalRegistration_Type)
private
published
end;
So I want to pass some values to this from some TEdit in runtime or some other way possible, but I have never worked before with these kind of variables, how can I do it?
initiateTechnicalRegistration1.apps :=
Here after the code for a method to add an item to the Apps array:
// Function return the index allocated in the array
function TForm1.AddApp(Value: App3): Integer;
begin
Result := Length(FApps);
SetLength(FApps, Result + 1);
FApps[Result] := Value;
end;

Delphi - How can I pass an array of TAlignment itens to property?

I want to configure the alignment at runtime of some columns of a DBGrid that's inside a component, passing the alignment of each column as an array to a property, but I'm confusing about that.
I guess the code in component should be something like that (according Andreas Rejbrand reply in How can I declare an array property?):
property MyAlignment[Index: Integer]: TAlignment read GetMyAlignment;
function MyComponent.GetMyAlignment(Index: Integer): TAlignment;
begin
result := FMyAlignment[Index];
end;
How do I mount the array that will be pass to the component's property ?
I try the code below but I'm getting the error "[dcc32 Error] uCad.pas(31): E2188 Published property 'ColumnTitleName' cannot be of type ARRAY".
type
TCad = class
private
FColumnTitleName: array of String;
FColumnTitleAlign: array of TAlignment;
FColumnAlign: array of TAlignment;
function GetColumnAlignment(index: Integer): TAlignment;
function GetColumnTitleAlignment(index: Integer): TAlignment;
function GetColumnTitleName(index: Integer): String;
public
published
property ColumnTitleName[index: Integer]: String read GetColumnTitleName;
property ColumnTitleAlign[index: Integer]: TAlignment read GetColumnTitleAlign;
property ColumnAlign[index: Integer]: TAlignment read GetColumnAlignment;
end;
implementation
function TCad.GetColumnAlign(index: Integer): TAlignment;
begin
Result := FColumnAlign[index];
end;
function TCad.GetColumnTitleAlign(index: Integer): TAlignment;
begin
Result := FColumnTitleAlign[index];
end;
function TCad.GetColumnTitleName(index: Integer): String;
begin
Result := FColumnTitleName[index];
end;
end.

How to correctly declare an array property in Delphi?

I'm trying to create an array to store every item of a TStringList into an array which size may vary depending on the quantity of items in said TStringList.
I know my syntax is wrong and what I want is probably a dynamic array, so the [0..100] is probably wrong aswell but I could not find any alternative syntax online.
ProductAvailabilityResult = Class(TRemotable)
private
FResultArray : array[1..100] of string;
published
property ResultArray[Index: Integer]: array of string read FResultArray write FResultArray;
End;
And this is how I would invoke it and populate it. conditionList being my TStringList which I would populate into my array.
for I := 0 to conditionList.Count - 1 do
begin
aProductAvailabilityResult.ResultArray[I] := conditionList[I];
end;
In case you may or may not have alternative suggestions to what i'm doing, the reason for this setup is because it's a web service app sending results over a SOAP server, and I don't think my PHP/Soap client can read TStringLists, so I need to pass it to an array first.
Let me know, Thanks!
Your syntax for declaring an array property is close, but you need to use getter/setter methods instead of direct field access, and array properties cannot be declared as published:
type
ProductAvailabilityResult = class(TRemotable)
private
FResultArray : array of string;
function GetResultArray(Index: Integer): string;
function GetResultArrayCount: Integer;
procedure SetResultArray(Index: Integer; const Value: string);
procedure SetResultArrayCount(Value: Integer);
public
property ResultArray[Index: Integer]: string read GetResultArray write SetResultArray default;
property ResultArrayCount: Integer read GetResultArrayCount write SetResultArrayCount;
end;
function ProductAvailabilityResult.GetResultArray(Index: Integer): string;
begin
Result := FResultArray[Index];
end;
function ProductAvailabilityResult.GetResultArrayCount: Integer;
begin
Result := Length(FResultArray);
end;
procedure ProductAvailabilityResult.SetResultArray(Index: Integer; const Value: string);
begin
FResultArray[Index] := Value;
end;
procedure ProductAvailabilityResult.SetResultArrayCount(Value: Integer);
begin
SetLength(FResultArray, Value);
end;
Then you can do this:
aProductAvailabilityResult.ResultArrayCount := conditionList.Count;
for I := 0 to conditionList.Count - 1 do
begin
aProductAvailabilityResult[I] := conditionList[I];
end;
You might want to consider adding a method to copy strings from a source TStrings:
type
ProductAvailabilityResult = class(TRemotable)
private
...
public
procedure AssignStrings(AStrings: TStrings);
...
end;
procedure ProductAvailabilityResult.AssignStrings(AStrings: TStrings);
var
I: Integer;
begin
SetLength(FResultArray, AStrings.Count);
for I := 0 to AStrings.Count - 1 do
FResultArray[I] := AStrings[I];
end;
aProductAvailabilityResult.AssignStrings(conditionList);
You've declared an array property, albeit with some syntax errors. However, you state in the question and comments that you want a property that is a dynamic array. That's different from an array property.
Declare a dynamic array property like so:
type
ProductAvailabilityResult = class(TRemotable)
private
FResultArray: TArray<string>;
published
property ResultArray: TArray<string> read FResultArray write FResultArray;
end;
Populate it like this:
var
i: Integer;
List: TStringList;
par: ProductAvailabilityResult;
arr: TArray<string>;
....
List := ...;
par := ...;
SetLength(arr, List.Count);
for i := 0 to List.Count-1 do
arr[i] := List[i];
par.ResultArray := arr;

How to save multiple images from database to TMemoryStream at runtime and extract them later on

I am creating a project at delphi(RAD Studio). There are images stored at database table at some rows. I want to extract images at runtime (for which I am using Array of TMemoryStream) and show them at frxReport.
My code snippet as follows
Public variable TStream is declared as
Stream2 : Array of TStream; i,k: integer
Code segment for view button click event, which is placed on MainForm and expected to show frxReport.
`
procedure TFrmMain.btnViewClick(Sender: TObject);
begin
i := 0;
k := 0;
UniTable1.SQL.Text := 'Select * from userplays order by id';
UniTable1.Execute;
rowcount := UniTable1.RecordCount;
SetLength(myid, rowcount);
SetLength(mydesc, rowcount);
SetLength(myimg, rowcount);
SetLength(Stream2, rowcount);
while not UniTable1.Eof do
begin
try
Stream2[k] := TMemoryStream.Create;
myid[k] := UniTable1.FieldByName('id').Value;
Stream2[k] := UniTable1.CreateBlobStream(TBlobField(UniTable1.FieldByName('image')), bmRead);
mydesc[k] := UniTable1.FieldByName('description').Value;
UniTable1.Next;
inc(k);
finally
//Stream2[k].Free;
end;
end;
frxUserDataSet1.RangeEnd := reCount;
frxUserDataSet1.RangeEndCount := rowcount;
frxReport1.ShowReport;
i := 0;
end;
`
However this method is not loading any image to Stream2 array. There is an option to use array of JPEGImage however if JPEGImage array used then it would be problem to display it on frxRaport at
procedure TFrmMain.frxReport1GetValue(const VarName: string; var Value: Variant);
`
Graphic := TJPEGImage.Create;
Graphic.LoadFromStream(Stream2[j]);
TfrxPictureView(frxreport1.FindObject('Picture1')).Picture.Graphic := Graphic;
`
Kindly let me know how to do this.
However this method is not loading any image to Stream2 array
In your current code you are first assigning a newly created TMemoryStream to Stream2[k]:
Stream2[k] := TMemoryStream.Create;
then you are throwing the TMemoryStream away (creating a memory leak) and replacing it with the blob stream you create:
Stream2[k] := UniTable1.CreateBlobStream(TBlobField(UniTable1.FieldByName('image')), bmRead);
But you never read from the blob stream.
Here's the while loop rewritten (untested)
var
blobstream: TStream;
Stream2: array of TMemoryStream;
....
// read 'id', 'description' and 'image' fields to respective arrays
while not UniTable1.Eof do
begin
myid[k] := UniTable1.FieldByName('id').Value;
mydesc[k] := UniTable1.FieldByName('description').Value;
blobstream := UniTable1.CreateBlobStream(TBlobField(UniTable1.FieldByName('image')), bmRead);
try
Stream2[k] := TMemoryStream.Create;
Stream2[k].LoadFromStream(blobstream);
finally
blobstream.Free;
end;
UniTable1.Next;
inc(k);
end;
Btw, I would recommend to define a record to hold the id, description and image together, and then an array of those records, instead of three separate arrays. Much simpler to manage only one array instead of three.
I think in your situation most obvious thing would be just connect existing DataSet ( Unitable1) directly into DataBand in frxReport. I don't see why you would need to use frxUserDataset instead of frxDBDataset with its DataSet property set to Unitable1 since you created it anyway.
If you really need a list of objects then I would take a different approach.
Your multiple global variables look ugly and are dangerous (i,k...)
I would create a class that holds your data and populate this data into a
TObjectList from System.Generics.Collection:
unit DataPack;
interface
uses ExtCtrls...System.SysUtils;
type
TMyDataPack = class(TObject)
private
Query: TFDQuery; //O r TUniQery
_MyId: Integer;
_MyDescription: String;
_MyImage: TImage;
_Loaded: Boolean;
function LoadData: boolean;
protected
public
constructor Create(Data: TFDQuery); //Or Uniquery
property MyId: Integer read _MyId;
property MyDescription: String read _MyDescription;
property MyImage: TImage read _MyImage;
property Loaded: Boolean read _Loaded;
end;
implementation
{ TMyDataPack }
constructor TMyDataPack.Create(Data: TFDQuery);
begin
Inherited Create;
Query:=Data;
_Loaded:=true;
if not (LoadData) then
_Loaded:=false;
end;
function TMyDataPack.LoadData: boolean;
var
Stream: TStream;
begin
Stream:= TStream.Create;
Stream:=Query.CreateBlobStream(TBlobField(Query.FieldByName('image')), bmRead);
try
_MyImage:=TImage.Create(nil);
_MyImage.Picture.Bitmap.LoadFromStream(Stream);
_MyDescription:=Query.FieldByName('description').AsString;
_MyId:=Query.FieldByName('CategoryId').AsInteger;
except on E: Exception do
begin
FreeAndNil(Stream);
FreeAndNil(_MyImage);
Exit(false);
end;
end;
FreeAndNil(Stream);
Result:=true;
end;
end.
Then in your main code:
procedure TMain.Button2Click(Sender: TObject);
var
DataRow: TMyDataPack;
List: TObjectList<TMyDataPack>;
Num: integer;
CurrentImage: TImage;
CurrentDescription: String;
CurrentId: integer;
begin
UniTable1.SQL.Text:='SELECT * FROM Userplays';
UniTable1.Open();
List:=TObjectList<TMyDataPack>.Create;
while not (UniTable1.Eof) do
begin
DataRow:=TMyDataPack.Create(UniTable1);
if(DataRow.Loaded) then
List.Add(DataRow);
UniTable1.Next;
End;
for Num:=0 to List.Count do
begin
CurrentDescription:=List[Num].MyDescription;
CurrentImage:=List[Num].MyImage;
CurrentId:=List[Num].MyId;
//List[Num].MyImage.Picture.SaveToFile('Some'+IntToStr(Num)+'.bmp');
// You might save it to file then...
end;
end;
end.
Then pass an ObjectList further, just remember to free it at the end.
You might further expand it by creating class factory to create different objects if you'd need for example use different database with same data,
perform check if image is actually Bmp or Jpg and so on.
You might even just pass a query without setting it's SQL and get TobjectList as property.

Make Non-Windowed Component Data Aware

I have a non-windowed component with a date property. I would like to make this component data aware with read and write capabilities to a date field. (In other words, if I change the date at runtime, I would like to write the new date property value to the dataset.) I have googled for examples, but I haven't been able to find any. Found several read-only examples, e.g., TDbLabel, but none that allow changes to be written to the dataset. If anyone can point me to an example, I would be grateful.
Here is a generic code approach to your question
unit Unit1;
interface
uses
Classes
,DB
,DBCtrls
;
type
TDataAwareComponent = class(TComponent)
private
{ private declarations }
FDataLink : TFieldDataLink;
FFromDateChange : Boolean;
function GetDataField: string;
function GetDataSource: TDataSource;
function GetField: TField;
function GetReadOnly: Boolean;
procedure SetDataField(const Value: string);
procedure SetDataSource(const Value: TDataSource);
procedure SetReadOnly(const Value: Boolean);
function GetDateProperty: TDateTime;
procedure SetDateProperty(const Value: TDateTime);
protected
{ protected declarations }
procedure DataChange(Sender : TObject);
public
{ public declarations }
constructor Create(AOwner : TComponent);override;
destructor Destroy;override;
public
property Field : TField read GetField;
property DateProperty : TDateTime read GetDateProperty write SetDateProperty;
published
{ published declarations }
property DataSource : TDataSource read GetDataSource write SetDataSource;
property DataField : string read GetDataField write SetDataField;
property ReadOnly : Boolean read GetReadOnly write SetReadOnly;
end;
implementation
{ TDataAwareComponent }
{------------------------------------------------------------------------------}
constructor TDataAwareComponent.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FDataLink := TFieldDataLink.Create;
FDataLink.Control := Self;
FDataLink.OnDataChange := DataChange;
end;
{------------------------------------------------------------------------------}
destructor TDataAwareComponent.Destroy;
begin
FDataLink.Free;
FDataLink := nil;
inherited;
end;
{------------------------------------------------------------------------------}
procedure TDataAwareComponent.DataChange(Sender: TObject);
begin
// Here a visual object would display the underlying field value.
// For example if this component was a TEdit
// the code would be something like
{ if FDataLink.Active then
Self.Text := Field.AsString;
And on the exit event of the TEdit the code would be reversed
so the field can take the value the user entered.
Since you do not need any UI interaction propably this event
is useless to you.
}
// Of course there are more issues you should cover to
// have a complete working solution.
// This is only demostration code.
end;
{------------------------------------------------------------------------------}
function TDataAwareComponent.GetDataField: string;
begin
Result := FDataLink.FieldName
end;
{------------------------------------------------------------------------------}
function TDataAwareComponent.GetDataSource: TDataSource;
begin
Result := FDataLink.DataSource;
end;
{------------------------------------------------------------------------------}
function TDataAwareComponent.GetDateProperty: TDateTime;
begin
//You do not need a separate property since you can access directly the field value.
Result := 0;
if Assigned(Field) and (Field.DataType in [ftTime,ftDate,ftDateTime] then
Result := Field.AsDateTime;
end;
{------------------------------------------------------------------------------}
function TDataAwareComponent.GetField: TField;
begin
Result : FDataLink.Field;
end;
{------------------------------------------------------------------------------}
function TDataAwareComponent.GetReadOnly: Boolean;
begin
Result := FDataLink.ReadOnly;
end;
{------------------------------------------------------------------------------}
procedure TDataAwareComponent.SetDataField(const Value: string);
begin
FDataLink.FieldName := Value;
end;
{------------------------------------------------------------------------------}
procedure TDataAwareComponent.SetDataSource(const Value: TDataSource);
begin
FDataLink.DataSource := Value;
end;
{------------------------------------------------------------------------------}
procedure TDataAwareComponent.SetDateProperty(const Value: TDateTime);
begin
if Assigned(Field) then
begin
FFromDateChange := True;
try
Field.DataSet.Edit;
Field.Value := Value;
finally
FFromDateChange := False;
end;
end;
end;
{------------------------------------------------------------------------------}
procedure TDataAwareComponent.SetReadOnly(const Value: Boolean);
begin
FDataLink.ReadOnly := Value;
end;
{------------------------------------------------------------------------------}
end.
It'd be a bit of code, but if your component has events triggered when its value changes, then that could be used to send updated values to the dataset, if it's in the dsEdit state. You'd also need to handle the various TDataSource Events to know when the dataset is changing.

Resources