2073 lines
57 KiB
ObjectPascal
2073 lines
57 KiB
ObjectPascal
unit uRODL;
|
|
|
|
{----------------------------------------------------------------------------}
|
|
{ RemObjects SDK Library - Core Library }
|
|
{ }
|
|
{ compiler: Delphi 5 and up, Kylix 2 and up }
|
|
{ platform: Win32, Linux }
|
|
{ }
|
|
{ (c)opyright RemObjects Software. all rights reserved. }
|
|
{ }
|
|
{ Using this code requires a valid license of the RemObjects SDK }
|
|
{ which can be obtained at http://www.remobjects.com. }
|
|
{----------------------------------------------------------------------------}
|
|
|
|
{$I RemObjects.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
{$IFDEF REMOBJECTS_TRIAL}uROTrial, {$ENDIF}
|
|
Classes, Contnrs, uROClasses;
|
|
|
|
const
|
|
EmptyGUID: TGUID = (D1: 0; D2: 0; D3: 0; D4: (0, 0, 0, 0, 0, 0, 0, 0));
|
|
|
|
DefaultIntfName = 'Default';
|
|
|
|
type
|
|
{ Misc types }
|
|
TRODLParamFlag = (fIn, fOut, fInOut, fResult);
|
|
|
|
const
|
|
RODLParamFlagNames: array[TRODLParamFlag] of string = ('in', 'out', 'in/out', 'result');
|
|
|
|
type
|
|
{ TRODLNameInfo }
|
|
TRODLEntity = class;
|
|
TRODLLibrary = class;
|
|
|
|
TRoPluginMessageType = (rmtInfo, rmtHint, rmtWarning, rmtError, rmtSuccess, rmtCustom);
|
|
|
|
IROPluginMessages = interface
|
|
['{9B07B5C2-FC07-4B9B-9207-D487CDC58D0E}']
|
|
procedure AddMessage(iType:TRoPluginMessageType; const iSource, iMessage:string; aReserved:integer=-1; aEntity:TRODLEntity=nil);
|
|
end;
|
|
|
|
IRODLEntityWithAncestor = interface
|
|
['{88D59A20-5B47-4CF0-A06C-C135EB598B12}']
|
|
function GetAncestor:string;
|
|
procedure SetAncestor(const iValue:string);
|
|
property Ancestor:string read GetAncestor write SetAncestor;
|
|
end;
|
|
|
|
TRODLUse = class;
|
|
TRODLGroup = class;
|
|
|
|
{ TRODLEntity }
|
|
TRODLEntity = class(TObject, IUnknown)
|
|
private
|
|
fIsFromUsedRodl: boolean;
|
|
fLocatedInRodlUse: TRODLUse;
|
|
fOwner:TRODLEntity;
|
|
|
|
fData: TObject;
|
|
fGroupUnder: TRODLGroup;
|
|
|
|
fName: string;
|
|
fAttributes: TStringList;
|
|
fDocumentation: string;
|
|
fUID: TGUID;
|
|
|
|
procedure SetName(const Value: string); virtual;
|
|
procedure SetDocumentation(const Value: string);
|
|
function GetAttributes: TStrings;
|
|
|
|
function GetInfo: TRODLEntity;
|
|
function GetOwnerLibrary: TRODLLibrary;
|
|
|
|
protected
|
|
function _AddRef: Integer; stdcall;
|
|
function _Release: Integer; stdcall;
|
|
function QueryInterface(const IID: TGUID; out Obj): HRESULT; stdcall;
|
|
|
|
public
|
|
constructor Create; virtual;
|
|
destructor Destroy; override;
|
|
|
|
procedure Validate(iMessages:IRoPluginMessages); virtual;
|
|
//function Validate(out FaultyEntity: TRODLEntity; out ErrorMessage: string): boolean; virtual;
|
|
|
|
property Name: string read fName write SetName;
|
|
property Documentation: string read fDocumentation write SetDocumentation;
|
|
property UID: TGUID read fUID write fUID;
|
|
property Attributes: TStrings read GetAttributes;
|
|
|
|
property Owner:TRODLEntity read fOwner;
|
|
property OwnerLibrary:TRODLLibrary read GetOwnerLibrary;
|
|
|
|
property Info: TRODLEntity read GetInfo; { for backwards comatibility }
|
|
property IsFromUsedRodl:boolean read fIsFromUsedRodl write fIsFromUsedRodl;
|
|
property LocatedInRodlUse:TRODLUse read fLocatedInRodlUse write fLocatedInRodlUse;
|
|
|
|
{ Helpers for visual representation in SB and elsewhere }
|
|
property GroupUnder:TRODLGroup read fGroupUnder write fGroupUnder;
|
|
class function ReadableEntityTypeName: string;
|
|
|
|
{ Properties to hold custom application-specific data at runtime, for
|
|
the application coding convenience. These are not persisted in any way }
|
|
property Data:TObject read fData write fData;
|
|
|
|
end;
|
|
|
|
TRODLEntityClass = class of TRODLEntity;
|
|
|
|
TRODLGroup = class(TRODLEntity)
|
|
end;
|
|
|
|
{ TRODLComplexEntity }
|
|
TRODLComplexEntity = class(TRODLEntity)
|
|
private
|
|
fItems: TObjectList;
|
|
fAutoCreateParams: boolean;
|
|
fAbstract: boolean;
|
|
|
|
function GetCount: integer;
|
|
function GetItems(Index: integer): TRODLEntity;
|
|
|
|
protected
|
|
function GetItemClass: TRODLEntityClass; virtual; abstract;
|
|
|
|
public
|
|
constructor Create; override;
|
|
destructor Destroy; override;
|
|
|
|
procedure Validate(iMessages:IRoPluginMessages); override;
|
|
//function Validate(out FaultyEntity: TRODLEntity; out ErrorMessage: string): boolean; override;
|
|
|
|
function ContainsEntity(aEntity: TRODLEntity; aRecurse:boolean=true):boolean;
|
|
|
|
function ItemByName(const aName: string): TRODLEntity;
|
|
function ItemByUID(const aUID: TGUID): TRODLEntity;
|
|
|
|
function Add(anEntity: TRODLEntity): integer; overload; virtual;
|
|
function Add: TRODLEntity; overload; virtual;
|
|
procedure Insert(aIndex: integer; anEntity: TRODLEntity); overload; virtual;
|
|
function Insert(aIndex: integer): TRODLEntity; overload; virtual;
|
|
|
|
function UniqueName(aBaseName:string):string;
|
|
|
|
procedure Exchange(Index1, Index2: integer); virtual;
|
|
|
|
|
|
procedure Remove(anEntity: TRODLEntity); virtual;
|
|
procedure Delete(Index: integer); virtual;
|
|
procedure Clear;
|
|
procedure Sort;
|
|
|
|
property AutoCreateParams:boolean read fAutoCreateParams write fAutoCreateParams;
|
|
property Abstract:boolean read fAbstract write fAbstract;
|
|
|
|
property ItemClass: TRODLEntityClass read GetItemClass;
|
|
property Items[Index: integer]: TRODLEntity read GetItems; default;
|
|
property Count: integer read GetCount;
|
|
|
|
end;
|
|
|
|
{ TRODLTypedEntity }
|
|
TRODLTypedEntity = class(TRODLEntity)
|
|
private
|
|
fDataType: string;
|
|
procedure SetDataType(const Value: string);
|
|
public
|
|
procedure Validate(iMessages: IRoPluginMessages); override;
|
|
property DataType: string read fDataType write SetDataType;
|
|
end;
|
|
|
|
{ TRODLStruct }
|
|
TRODLBaseStruct = class(TRODLComplexEntity, IRODLEntityWithAncestor)
|
|
private
|
|
fAncestor: string;
|
|
function GetItems(Index: integer): TRODLTypedEntity;
|
|
procedure SetAncestor(const Value: string);
|
|
|
|
protected
|
|
function GetItemClass: TRODLEntityClass; override;
|
|
|
|
public
|
|
function Add(aStructElement: TRODLTypedEntity): integer; reintroduce; overload;
|
|
function Add: TRODLTypedEntity; reintroduce; overload;
|
|
|
|
procedure Validate(iMessages:IRoPluginMessages); override;
|
|
property Items[Index: integer]: TRODLTypedEntity read GetItems; default;
|
|
property Ancestor: string read fAncestor write SetAncestor;
|
|
function GetAncestor: string;
|
|
|
|
function CalcItemsMarshalingOrder(aIncludeAncestors: boolean=true): IROStrings;
|
|
end;
|
|
|
|
TRODLStruct = class(TRODLBaseStruct);
|
|
|
|
{ TRODLArray }
|
|
TRODLArray = class(TRODLEntity)
|
|
private
|
|
fElementType: string;
|
|
procedure SetElementType(const Value: string);
|
|
public
|
|
procedure Validate(iMessages:IRoPluginMessages); override;
|
|
//function Validate(out FaultyEntity: TRODLEntity; out ErrorMessage: string): boolean; override;
|
|
|
|
property ElementType: string read fElementType write SetElementType;
|
|
end;
|
|
|
|
{ TRODLEnumValue }
|
|
TRODLEnumValue = class(TRODLEntity)
|
|
private
|
|
end;
|
|
|
|
{ TRODLEnum }
|
|
TRODLEnum = class(TRODLComplexEntity)
|
|
private
|
|
fPrefixEnumValues: Boolean;
|
|
function GetItems(Index: integer): TRODLEnumValue;
|
|
|
|
protected
|
|
function GetItemClass: TRODLEntityClass; override;
|
|
|
|
public
|
|
constructor Create; override;
|
|
|
|
function Add(aStructElement: TRODLEnumValue): integer; reintroduce; overload;
|
|
function Add: TRODLEnumValue; reintroduce; overload;
|
|
|
|
procedure Validate(iMessages:IRoPluginMessages); override;
|
|
property Items[Index: integer]: TRODLEnumValue read GetItems; default;
|
|
|
|
property PrefixEnumValues: Boolean read fPrefixEnumValues write fPrefixEnumValues;
|
|
end;
|
|
|
|
{ TRODLOperationParam }
|
|
TRODLOperationParam = class(TRODLTypedEntity)
|
|
private
|
|
fFlag: TRODLParamFlag;
|
|
function GetFlag: string;
|
|
procedure SetFlag(const aValue: string);
|
|
public
|
|
property Flag: TRODLParamFlag read fFlag write fFlag;
|
|
property FlagAsString: string read GetFlag write SetFlag;
|
|
end;
|
|
|
|
{ TRODLOperation }
|
|
TRODLOperation = class(TRODLComplexEntity)
|
|
private
|
|
fOperationResult: TRODLOperationParam;
|
|
fCodeBodies: TStringList;
|
|
fForceAsyncResponse: boolean;
|
|
function GetItems(Index: integer): TRODLOperationParam;
|
|
function GetResult: TRODLOperationParam;
|
|
function GetCodeBody(iLanguage: string): TStrings;
|
|
function GetCodeBodyCount: integer;
|
|
function GetCodeBodyLanguages(iIndex: integer): string;
|
|
|
|
protected
|
|
function GetItemClass: TRODLEntityClass; override;
|
|
|
|
public
|
|
constructor Create; override;
|
|
destructor Destroy; override;
|
|
|
|
function Add(aParam: TRODLOperationParam): integer; reintroduce; overload;
|
|
function Add: TRODLOperationParam; reintroduce; overload;
|
|
|
|
{procedure MoveResult();
|
|
procedure Exchange(Index1, Index2: integer); override;}
|
|
|
|
procedure SetCodeBody(iLanguage: string; Value: TStrings);
|
|
procedure SetCodeBodyAsString(iLanguage: string; const Value: string);
|
|
|
|
function GetParameter(const aParameterName : string) : TRODLOperationParam;
|
|
|
|
property Items[Index: integer]: TRODLOperationParam read GetItems; default;
|
|
|
|
property Result: TRODLOperationParam read GetResult;
|
|
function AddResult: TRODLOperationParam;
|
|
procedure RemoveResult;
|
|
|
|
property ForceAsyncResponse:boolean read fForceAsyncResponse write fForceAsyncResponse;
|
|
|
|
property CodeBodies[iLanguage:string]:TStrings read GetCodeBody write SetCodeBody;
|
|
property CodeBodyCount:integer read GetCodeBodyCount;
|
|
property CodeBodyLanguages[iIndex:integer]:string read GetCodeBodyLanguages;
|
|
|
|
procedure Validate(iMessages: IROPluginMessages); override;
|
|
end;
|
|
|
|
{ TRODLServiceInterface }
|
|
TRODLServiceInterface = class(TRODLComplexEntity)
|
|
private
|
|
function GetItems(Index: integer): TRODLOperation;
|
|
|
|
protected
|
|
function GetItemClass: TRODLEntityClass; override;
|
|
|
|
public
|
|
procedure GetOperationsList(AList: TList);
|
|
function FindOperation(const anOperationName : string; IncludeAnchestors : boolean = FALSE) : TRODLOperation;
|
|
function GetOperation(const anOperationName : string; IncludeAnchestors : boolean = FALSE) : TRODLOperation;
|
|
|
|
function Add(aParam: TRODLOperation): integer; reintroduce; overload;
|
|
function Add: TRODLOperation; reintroduce; overload;
|
|
|
|
property Items[Index: integer]: TRODLOperation read GetItems; default;
|
|
end;
|
|
|
|
{ TRODLBaseService }
|
|
TRODLBaseService = class(TRODLComplexEntity, IRODLEntityWithAncestor)
|
|
private
|
|
fAncestor: string;
|
|
fImplClass: string;
|
|
fImplUnit: string;
|
|
fisPrivate: Boolean;
|
|
function GetItems(Index: integer): TRODLServiceInterface;
|
|
function GetDefault: TRODLServiceInterface;
|
|
procedure SetAncestor(const Value: string);
|
|
|
|
protected
|
|
function GetItemClass: TRODLEntityClass; override;
|
|
public
|
|
constructor Create; override;
|
|
|
|
function Add(aServiceInterface: TRODLServiceInterface): integer; reintroduce; overload;
|
|
function Add: TRODLServiceInterface; reintroduce; overload;
|
|
|
|
procedure Validate(iMessages: IRoPluginMessages); override;
|
|
property Items[Index: integer]: TRODLServiceInterface read GetItems; default;
|
|
property Default: TRODLServiceInterface read GetDefault;
|
|
property Ancestor: string read fAncestor write SetAncestor;
|
|
|
|
property ImplUnit:string read fImplUnit write fImplUnit;
|
|
property ImplClass:string read fImplClass write fImplClass;
|
|
function GetAncestor:string;
|
|
property isPrivate: Boolean read fisPrivate write fisPrivate;
|
|
end;
|
|
|
|
TRODLService = class(TRODLBaseService);
|
|
TRODLEventSink = class(TRODLBaseService);
|
|
|
|
{ TRODLArray }
|
|
TRODLException = class(TRODLBaseStruct)
|
|
public
|
|
procedure Validate(iMessages:IRoPluginMessages); override;
|
|
end;
|
|
|
|
{ TRODLUse }
|
|
TRODLUse = class(TRODLEntity)
|
|
private
|
|
fRodlFile: string;
|
|
fAbsoluteRodlFile: string;
|
|
fLoadedRodlLibraryName: string;
|
|
fGenerateCode: boolean;
|
|
public
|
|
procedure Validate(iMessages:IRoPluginMessages); override;
|
|
property RodlFile:string read fRodlFile write fRodlFile;
|
|
property AbsoluteRodlFile:string read fAbsoluteRodlFile write fAbsoluteRodlFile;
|
|
property LoadedRodlLibraryName: string read fLoadedRodlLibraryName write fLoadedRodlLibraryName;
|
|
property GenerateCode: boolean read fGenerateCode write fGenerateCode;
|
|
end;
|
|
|
|
{ TRODLLibrary }
|
|
TRODLLibrary = class(TRODLComplexEntity)
|
|
private
|
|
fArrayCount: integer;
|
|
fServiceCount: integer;
|
|
fStructCount: integer;
|
|
fEnumCount: integer;
|
|
fExceptionCount: integer;
|
|
fUseCount: integer;
|
|
fEventSinkCount: integer;
|
|
fGroupCount: integer;
|
|
fRodlFilename: string;
|
|
fNamespace: string;
|
|
|
|
function GetByType(aIndex:integer; aType:TRODLEntityClass):TRODLEntity;
|
|
function GetArray(Index: integer): TRODLArray;
|
|
function GetEnums(Index: integer): TRODLEnum;
|
|
function GetServices(Index: integer): TRODLService;
|
|
function GetStructs(Index: integer): TRODLStruct;
|
|
function GetExceptions(Index: integer): TRODLException;
|
|
function GetUse(Index: integer): TRODLUse;
|
|
function CalcOrder(const iObjects: IROStrings): IROStrings;
|
|
function GetGroups(Index: integer): TRODLGroup;
|
|
function GetEventSinks(Index: integer): TRODLEventSink;
|
|
|
|
protected
|
|
function GetItemClass: TRODLEntityClass; override;
|
|
|
|
public
|
|
constructor Create(); override;
|
|
|
|
procedure GetArraysByElement(const aElementName:string; AList: TList);
|
|
function FindService(const iServiceName: string): TRODLService;
|
|
function FindStruct(const iStructName: string): TRODLStruct;
|
|
function FindBaseStruct(const iStructName: string): TRODLBaseStruct;
|
|
function FindEnum(const iEnumName: string): TRODLEnum;
|
|
function FindArray(const iArrayName: string): TRODLArray;
|
|
function FindGroup(const aID: TGUID): TRODLGroup; overload;
|
|
function FindException(const iExceptionName: string): TRODLException;
|
|
function FindUse(const iUseName: string): TRODLUse;
|
|
function FindUseByFilename(const iUseRODLFile: string): TRODLUse;
|
|
|
|
procedure ClearDuplicates();
|
|
|
|
function GetService(const aServiceName: string): TRODLService;
|
|
function GetStruct(const aStructName: string): TRODLStruct;
|
|
|
|
function IsValidCustomType(const iTypeName:string):boolean;
|
|
function IsValidSimpleType(const iTypeName: string): boolean;
|
|
function IsValidType(const iTypeName:string):boolean;
|
|
function IsValidService(const iServiceName:string):boolean;
|
|
function IsValidEventSink(const iEventSink:string):boolean;
|
|
function IsValidException(const iTypeName:string):boolean;
|
|
|
|
function Add(anEntity: TRODLEntity): integer; override;
|
|
|
|
function CalcServiceOrder:IROStrings;
|
|
function CalcEventSinkOrder: IROStrings;
|
|
function CalcExceptionOrder: IROStrings;
|
|
function CalcStructOrder: IROStrings;
|
|
|
|
procedure Delete(Index: integer); override;
|
|
procedure Remove(anEntity: TRODLEntity); override;
|
|
|
|
property RodlFilename:string read fRodlFilename write fRodlFilename;
|
|
property Namespace: string read fNamespace write fNamespace;
|
|
|
|
property Structs[Index: integer]: TRODLStruct read GetStructs;
|
|
property StructCount: integer read fStructCount;
|
|
|
|
property Arrays[Index: integer]: TRODLArray read GetArray;
|
|
property ArrayCount: integer read fArrayCount;
|
|
|
|
property Enums[Index: integer]: TRODLEnum read GetEnums;
|
|
property EnumCount: integer read fEnumCount;
|
|
|
|
property Services[Index: integer]: TRODLService read GetServices;
|
|
property ServiceCount: integer read fServiceCount;
|
|
|
|
property Exceptions[Index: integer]: TRODLException read GetExceptions;
|
|
property ExceptionCount: integer read fExceptionCount;
|
|
|
|
property Use[Index: integer]: TRODLUse read GetUse;
|
|
property UseCount: integer read fUseCount;
|
|
|
|
property Groups[Index: integer]: TRODLGroup read GetGroups;
|
|
property GroupCount: integer read fGroupCount;
|
|
|
|
property EventSinks[Index: integer]: TRODLEventSink read GetEventSinks;
|
|
property EventSinkCount: integer read fEventSinkCount;
|
|
end;
|
|
|
|
{ TRODLConverter }
|
|
TRODLConverter = class
|
|
private
|
|
fBuffer: TStringList;
|
|
fTargetEntity: string;
|
|
|
|
function GetBuffer: TStrings;
|
|
|
|
protected
|
|
procedure IntConvert(const aLibrary: TRODLLibrary; const aTargetEntity: string = ''); virtual; abstract;
|
|
function ValidateTargetEntity(const aLibrary: TRODLLibrary; const aTargetEntity: string): boolean; virtual;
|
|
|
|
public
|
|
constructor Create(const aLibraryFile: string; const aTargetEntity: string = ''); overload; virtual;
|
|
constructor Create(const aLibrary: TRODLLibrary; const aTargetEntity: string = ''); overload; virtual;
|
|
destructor Destroy; override;
|
|
|
|
procedure Write(const someText: string; Indentation: integer = 0); overload;
|
|
procedure WriteLines(const someText: string);
|
|
procedure WriteEmptyLine;
|
|
|
|
procedure Convert(const aLibrary: TRODLLibrary; const aTargetEntity: string = '');
|
|
class function GetTargetFileName(const aLibrary: TRODLLibrary; const aTargetEntity: string = ''): string; virtual;
|
|
|
|
property Buffer: TStrings read GetBuffer;
|
|
property TargetEntity: string read fTargetEntity;
|
|
end;
|
|
|
|
TRODLConverterClass = class of TRODLConverter;
|
|
|
|
{ TRODLReader }
|
|
TRODLReader = class
|
|
private
|
|
protected
|
|
function IntReadFromStream(aStream: TStream; aFilename:string): TRODLLibrary; virtual; abstract;
|
|
|
|
public
|
|
constructor Create; virtual;
|
|
|
|
function Read(aStream: TStream; const aFilename:string=''): TRODLLibrary;
|
|
function ReadFromFile(const aFileName: string): TRODLLibrary;
|
|
end;
|
|
|
|
TRODLReaderClass = class of TRODLReader;
|
|
|
|
function ReadRODLFromFile(aReaderClass: TRODLReaderClass; const aFileName: string): TRODLLibrary;
|
|
|
|
function ExpandVariables(const aFilename:string):string;
|
|
|
|
implementation
|
|
|
|
uses
|
|
{$IFDEF DEBUG_REMOBJECTS_RODL}eDebugServer, {$ENDIF}
|
|
{$IFDEF DELPHI5} ActiveX, Windows, {$ENDIF}
|
|
{$IFDEF MSWINDOWS}Registry, {$IFNDEF DELPHI5}Windows,{$ENDIF}{$ENDIF}
|
|
SysUtils, TypInfo, uRORes, uRODLToXML, uROTypes, Math;
|
|
|
|
{ Support routines }
|
|
|
|
{$IFDEF MSWINDOWS}
|
|
function LookupVariable(const aVariable:string):string;
|
|
begin
|
|
with TRegistry.Create do try
|
|
RootKey := HKEY_CURRENT_USER;
|
|
OpenKey('Software\RemObjects\RemObjects SDK\Variables',false);
|
|
result := ReadString(aVariable);
|
|
{ if result = '' then
|
|
RaiseError('Variable $(%s) used in RODL is not defined.',[aVariable]);
|
|
}
|
|
finally
|
|
Free;
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{$IFDEF MSWINDOWS}
|
|
function ExpandVariables(const aFilename:string):string;
|
|
var
|
|
p: Integer;
|
|
lName,lVar:string;
|
|
begin
|
|
lName := aFilename;
|
|
if Pos('$(',lName) = 1 then begin
|
|
p := Pos(')',lName);
|
|
if p > 1 then begin
|
|
lVar := Copy(lName,3,p-3);
|
|
Delete(lName,1,p);
|
|
result := LookupVariable(lVar)+lName;
|
|
exit;
|
|
end;
|
|
end;
|
|
result := aFilename;
|
|
end;
|
|
{$ELSE}
|
|
function ExpandVariables(const aFilename:string):string;
|
|
begin
|
|
result := aFilename;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function CleanupText(const someText: string): string;
|
|
var
|
|
i: integer;
|
|
begin
|
|
result := Trim(someText);
|
|
for i := 1 to Length(result) do
|
|
case result[i] of
|
|
'0'..'9': begin
|
|
if (i = 1) then result[i] := '_';
|
|
end;
|
|
'a'..'z',
|
|
'A'..'Z',
|
|
'_': Continue;
|
|
else
|
|
result[i] := '_';
|
|
end;
|
|
end;
|
|
|
|
function CleanupTextAllowSpaces(const someText: string): string;
|
|
var
|
|
i: integer;
|
|
begin
|
|
result := Trim(someText);
|
|
for i := 1 to Length(result) do
|
|
case result[i] of
|
|
{'0'..'9' : begin
|
|
if (i=1) then result[i] := '_';
|
|
end;}
|
|
#13, #10, #09,
|
|
#$20..#$21,
|
|
#$23..#$25,
|
|
#$27..#$3b,
|
|
#$3d,
|
|
#$3f..#$7e: Continue;
|
|
else
|
|
result[i] := '_';
|
|
end;
|
|
end;
|
|
|
|
function ReadRODLFromFile(aReaderClass: TRODLReaderClass; const aFileName: string): TRODLLibrary;
|
|
begin
|
|
with aReaderClass.Create do try
|
|
result := ReadFromFile(aFileName);
|
|
finally
|
|
Free;
|
|
end;
|
|
end;
|
|
|
|
{ TRODLNameInfo }
|
|
|
|
{constructor TRODLNameInfo.Create(const aName: string; aOwner:TRODLEntity);
|
|
begin
|
|
Name := aName;
|
|
fOwner := aOwner;
|
|
fUID := NewUID();
|
|
end;
|
|
|
|
destructor TRODLNameInfo.Destroy;
|
|
begin
|
|
if Assigned(fAttributes) then fAttributes.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TRODLNameInfo.GetAttributes: TStrings;
|
|
begin
|
|
if (fAttributes = nil) then fAttributes := TStringList.Create;
|
|
result := fAttributes;
|
|
end;
|
|
|
|
procedure TRODLNameInfo.SetName(const Value: string);
|
|
begin
|
|
fName := CleanupText(Value);
|
|
end;
|
|
|
|
procedure TRODLNameInfo.SetDocumentation(const Value: string);
|
|
begin
|
|
fDocumentation := CleanupTextAllowSpaces(Value);
|
|
end; }
|
|
|
|
{ TRODLEntityInfo }
|
|
|
|
{constructor TRODLEntityInfo.Create(const aName: string; const aUID: TGUID; const someDocumentation: string; aOwner:TRODLEntity);
|
|
begin
|
|
inherited Create(aName,aOwner);
|
|
|
|
UID := aUID;
|
|
Documentation := someDocumentation;
|
|
end;}
|
|
|
|
{procedure TRODLEntityInfo.Validate(iMessages:IRoPluginMessages);
|
|
//function TRODLEntityInfo.GetIsValid: boolean;
|
|
begin
|
|
//result := inherited GetIsValid and
|
|
if IsEqualGUID(UID, EmptyGUID) then
|
|
iMessages.AddMessage(rmtWarning,Name,'No UID specified',-1,Owner);
|
|
end;}
|
|
|
|
{ TRODLEntity }
|
|
|
|
constructor TRODLEntity.Create;
|
|
begin
|
|
fUID := NewGUID();
|
|
end;
|
|
|
|
destructor TRODLEntity.Destroy;
|
|
begin
|
|
if Assigned(fAttributes) then fAttributes.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TRODLEntity.GetInfo: TRODLEntity;
|
|
begin
|
|
result := self;
|
|
end;
|
|
|
|
procedure TRODLEntity.Validate(iMessages:IRoPluginMessages);
|
|
begin
|
|
if (Trim(Name) = '') then
|
|
iMessages.AddMessage(rmtError,'','No Name specified',-1,Owner);
|
|
|
|
{ ToDo: add a flag that specified whether UID is needed for the explicit base types }
|
|
if IsEqualGUID(UID, EmptyGUID) then
|
|
iMessages.AddMessage(rmtWarning,Name,'No UID specified',-1,Owner);
|
|
|
|
{result := Info.IsValid;
|
|
if not result then begin
|
|
FaultyEntity := Self;
|
|
ErrorMessage := err_InvalidInfo;
|
|
end;}
|
|
end;
|
|
|
|
function TRODLEntity.GetOwnerLibrary: TRODLLibrary;
|
|
var lOwner:TRODLEntity;
|
|
begin
|
|
lOwner := fOwner;
|
|
while Assigned(lOwner) and (not (lOwner is TRODLLibrary)) do
|
|
lOwner := lOwner.Owner;
|
|
|
|
Assert(Assigned(lOwner));
|
|
result := lOwner as TRODLLibrary;
|
|
end;
|
|
|
|
function TRODLEntity._AddRef: Integer;
|
|
begin
|
|
result := 1;
|
|
end;
|
|
|
|
function TRODLEntity._Release: Integer;
|
|
begin
|
|
result := 1;
|
|
end;
|
|
|
|
function TRODLEntity.QueryInterface(const IID: TGUID; out Obj): HRESULT;
|
|
begin
|
|
if GetInterface(IID, Obj) then
|
|
Result := 0
|
|
else
|
|
Result := E_NOINTERFACE;
|
|
end;
|
|
|
|
class function TRODLEntity.ReadableEntityTypeName: string;
|
|
begin
|
|
result := ClassName;
|
|
Delete(result,1,5); { delete the "TRODL" }
|
|
end;
|
|
|
|
function TRODLEntity.GetAttributes: TStrings;
|
|
begin
|
|
if (fAttributes = nil) then fAttributes := TStringList.Create;
|
|
result := fAttributes;
|
|
end;
|
|
|
|
procedure TRODLEntity.SetDocumentation(const Value: string);
|
|
begin
|
|
fDocumentation := Value;
|
|
end;
|
|
|
|
procedure TRODLEntity.SetName(const Value: string);
|
|
begin
|
|
fName := CleanupText(Value);
|
|
end;
|
|
|
|
{ TRODLComplexEntity }
|
|
|
|
function TRODLComplexEntity.Add(anEntity: TRODLEntity): integer;
|
|
begin
|
|
if not (anEntity is ItemClass) then RaiseError(err_InvalidType, [anEntity.ClassName, ItemClass.ClassName]);
|
|
result := fItems.Add(anEntity);
|
|
anEntity.fOwner := self;
|
|
end;
|
|
|
|
function TRODLComplexEntity.Add: TRODLEntity;
|
|
begin
|
|
result := ItemClass.Create;
|
|
result.fOwner := self;
|
|
Add(result);
|
|
end;
|
|
|
|
procedure TRODLComplexEntity.Insert(aIndex: integer; anEntity: TRODLEntity);
|
|
begin
|
|
if not (anEntity is ItemClass) then RaiseError(err_InvalidType, [anEntity.ClassName, ItemClass.ClassName]);
|
|
fItems.Insert(aIndex, anEntity);
|
|
anEntity.fOwner := self;
|
|
end;
|
|
|
|
function TRODLComplexEntity.Insert(aIndex: integer): TRODLEntity;
|
|
begin
|
|
result := ItemClass.Create;
|
|
result.fOwner := self;
|
|
Insert(aIndex, result);
|
|
end;
|
|
|
|
procedure TRODLComplexEntity.Clear;
|
|
begin
|
|
fItems.Clear;
|
|
end;
|
|
|
|
constructor TRODLComplexEntity.Create;
|
|
begin
|
|
inherited;
|
|
fAutoCreateParams := true;
|
|
fItems := TObjectList.Create;
|
|
end;
|
|
|
|
procedure TRODLComplexEntity.Delete(Index: integer);
|
|
begin
|
|
fItems.Delete(Index);
|
|
end;
|
|
|
|
destructor TRODLComplexEntity.Destroy;
|
|
begin
|
|
fItems.Free;
|
|
inherited;
|
|
end;
|
|
|
|
function TRODLComplexEntity.GetCount: integer;
|
|
begin
|
|
result := fItems.Count
|
|
end;
|
|
|
|
procedure TRODLComplexEntity.Validate(iMessages:IRoPluginMessages);
|
|
//function TRODLComplexEntity.Validate(out FaultyEntity: TRODLEntity; out ErrorMessage: string): boolean;
|
|
var
|
|
i, n: integer;
|
|
begin
|
|
inherited Validate(iMessages);
|
|
//if not result then Exit;
|
|
//result := FALSE;
|
|
|
|
// Check type names are unique
|
|
for i := 0 to (Count - 2) do
|
|
for n := i + 1 to (Count - 1) do
|
|
if (CompareText(Items[i].Info.Name, Items[n].Info.Name) = 0) then begin
|
|
|
|
iMessages.AddMessage(rmtError,Info.Name+'.'+Items[i].Info.Name,err_RodlDuplicateName,-1,Items[n]);
|
|
|
|
{FaultyEntity := ;
|
|
ErrorMessage := Format(err_DuplicateName, [Items[n].Info.Name]);
|
|
Exit;}
|
|
end;
|
|
|
|
// Check they are all valid on a basic level
|
|
for i := 0 to (Count - 1) do
|
|
Items[i].Validate(iMessages);
|
|
//if not Items[i].Validate(FaultyEntity, ErrorMessage) then Exit;
|
|
|
|
//result := TRUE;
|
|
end;
|
|
|
|
function TRODLComplexEntity.GetItems(Index: integer): TRODLEntity;
|
|
begin
|
|
result := TRODLEntity(fItems[Index]);
|
|
end;
|
|
|
|
function TRODLComplexEntity.ItemByName(const aName: string): TRODLEntity;
|
|
var
|
|
i: integer;
|
|
begin
|
|
result := nil;
|
|
|
|
for i := 0 to (Count - 1) do
|
|
if (CompareText(Items[i].Info.Name, aName) = 0) then begin
|
|
result := Items[i];
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
function TRODLComplexEntity.ItemByUID(const aUID: TGUID): TRODLEntity;
|
|
var
|
|
i: integer;
|
|
begin
|
|
result := nil;
|
|
|
|
for i := 0 to (Count - 1) do
|
|
if IsEqualGUID(Items[i].Info.UID, aUID) then begin
|
|
result := Items[i];
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
procedure TRODLComplexEntity.Remove(anEntity: TRODLEntity);
|
|
begin
|
|
fItems.Remove(anEntity)
|
|
end;
|
|
|
|
procedure TRODLComplexEntity.Exchange(Index1, Index2: integer);
|
|
begin
|
|
fItems.Exchange(Index1, Index2);
|
|
end;
|
|
|
|
function TRODLComplexEntity.UniqueName(aBaseName: string): string;
|
|
var
|
|
i: Integer;
|
|
lIndex: Integer;
|
|
lOk: boolean;
|
|
begin
|
|
lIndex := 0;
|
|
result := aBasename;
|
|
repeat
|
|
lOk := true;
|
|
for i := 0 to Count-1 do begin
|
|
if result = Items[i].Info.Name then begin
|
|
inc(lIndex);
|
|
result := aBaseName+IntToStr(lIndex);
|
|
lOk := false;
|
|
end;
|
|
end; { for }
|
|
until lOk;
|
|
end;
|
|
|
|
function TRODLComplexEntity.ContainsEntity(aEntity: TRODLEntity; aRecurse:boolean=true): boolean;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
result := false;
|
|
for i := 0 to Count-1 do begin
|
|
if Items[i] = aEntity then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
if aRecurse and (Items[i] is TRODLComplexEntity) then begin
|
|
result := TRODLComplexEntity(Items[i]).ContainsEntity(aEntity);
|
|
if result then exit;
|
|
end;
|
|
end; { for }
|
|
end;
|
|
|
|
function SortItem(Item1, Item2: Pointer): Integer;
|
|
begin
|
|
Result := CompareText(TRODLEntity(Item1).Name, TRODLEntity(Item2).name);
|
|
end;
|
|
|
|
procedure TRODLComplexEntity.Sort;
|
|
begin
|
|
fItems.Sort(@SortItem);
|
|
end;
|
|
|
|
{ TRODLTypedEntity }
|
|
|
|
procedure TRODLTypedEntity.Validate(iMessages:IRoPluginMessages);
|
|
begin
|
|
if (DataType = '') then begin
|
|
iMessages.AddMessage(rmtError,Owner.Owner.Info.Name+'.'+Name,err_RodlNoDataTypeSpecified,-1,Owner);
|
|
exit;
|
|
end;
|
|
|
|
if not Owner.OwnerLibrary.IsValidType(DataType) then
|
|
iMessages.AddMessage(rmtError,Owner.Owner.Info.Name+'.'+Name,Format(err_RodlInvalidDataType,[DataType]),-1,Owner);
|
|
|
|
if not (Owner is TRODLOperation) then
|
|
begin
|
|
if (CompareText(DataType,Owner.Info.Name) = 0) then
|
|
iMessages.AddMessage(rmtError,Owner.Info.Name,Format(err_RodlStructCannotBeNested,[DataType]),-1,Owner);
|
|
end;
|
|
end;
|
|
|
|
procedure TRODLTypedEntity.SetDataType(const Value: string);
|
|
begin
|
|
fDataType := CleanupText(Value);
|
|
end;
|
|
|
|
{ TRODLStruct }
|
|
|
|
function TRODLBaseStruct.Add(aStructElement: TRODLTypedEntity): integer;
|
|
begin
|
|
result := inherited Add(aStructElement)
|
|
end;
|
|
|
|
function TRODLBaseStruct.Add: TRODLTypedEntity;
|
|
begin
|
|
result := TRODLTypedEntity(inherited Add);
|
|
result.Info.Name := 'Field' + IntToStr(Count);
|
|
end;
|
|
|
|
function CompareRODLBaseStructItems(List: TStringList; Index1, Index2: Integer): Integer;
|
|
begin
|
|
Result := CompareText(List[Index1], List[Index2]);
|
|
end;
|
|
|
|
function TRODLBaseStruct.CalcItemsMarshalingOrder(aIncludeAncestors: boolean=true): IROStrings;
|
|
var
|
|
lAncestor: TRODLBaseStruct;
|
|
i:integer;
|
|
begin
|
|
result := NewROStrings();
|
|
result.Sorted := True;
|
|
result.Duplicates := dupIgnore;
|
|
|
|
lAncestor := self;
|
|
repeat
|
|
for i := lAncestor.Count-1 downto 0 do
|
|
result.AddObject(lAncestor.Items[i].Name, lAncestor.Items[i]);
|
|
|
|
if lAncestor.Ancestor <> '' then
|
|
lAncestor := OwnerLibrary.FindBaseStruct(lAncestor.Ancestor)
|
|
else
|
|
lAncestor := nil;
|
|
|
|
until (not Assigned(lAncestor)) or (not aIncludeAncestors);
|
|
|
|
// Do not use "Result.Sorted" because it uses AnsiCompareText for the comparisons
|
|
// whereas the SortPropList method originally used via GetGetPropList in TROSerializer.ReadObject
|
|
// does a case insensitive ASCII based sort. Hence the need to do our own
|
|
// sorting that calls CompareText.
|
|
result.Sorted := False;
|
|
result.CustomSort(CompareRODLBaseStructItems);
|
|
end;
|
|
|
|
function TRODLBaseStruct.GetAncestor: string;
|
|
begin
|
|
result := fAncestor;
|
|
end;
|
|
|
|
function TRODLBaseStruct.GetItemClass;
|
|
begin
|
|
result := TRODLTypedEntity;
|
|
end;
|
|
|
|
function TRODLBaseStruct.GetItems(Index: integer): TRODLTypedEntity;
|
|
begin
|
|
result := TRODLTypedEntity(inherited Items[Index]);
|
|
end;
|
|
|
|
procedure TRODLBaseStruct.SetAncestor(const Value: string);
|
|
begin
|
|
fAncestor := Trim(Value);
|
|
end;
|
|
|
|
procedure TRODLBaseStruct.Validate(iMessages: IRoPluginMessages);
|
|
begin
|
|
inherited;
|
|
{ Hack: for exemptions, dont warn about missing elements }
|
|
{ ToDo: create a command base class for struct and exception, and derrive both, to avoid this kind of prob. }
|
|
if (Count = 0) and not (self is TRODLException) and (Ancestor = '') then
|
|
iMessages.AddMessage(rmtWarning,Info.Name,err_RodlNoStructElementsDefined,-1,self);
|
|
|
|
if (Ancestor <> '') and not OwnerLibrary.IsValidType(Ancestor) and not (self is TRODLException) then // exceptions ancestors are checked in TRODLException.Validate
|
|
iMessages.AddMessage(rmtError,Info.Name,Format(err_RodlInvalidAncestorType,[Ancestor]),-1,self);
|
|
end;
|
|
|
|
{ TRODLEnum }
|
|
|
|
function TRODLEnum.Add(aStructElement: TRODLEnumValue): integer;
|
|
begin
|
|
result := inherited Add(aStructElement)
|
|
end;
|
|
|
|
function TRODLEnum.Add: TRODLEnumValue;
|
|
begin
|
|
result := TRODLEnumValue(inherited Add);
|
|
result.Info.Name := 'Value' + IntToSTr(Count);
|
|
end;
|
|
|
|
constructor TRODLEnum.Create;
|
|
begin
|
|
inherited;
|
|
fPrefixEnumValues := True;
|
|
end;
|
|
|
|
function TRODLEnum.GetItemClass: TRODLEntityClass;
|
|
begin
|
|
result := TRODLEnumValue;
|
|
end;
|
|
|
|
function TRODLEnum.GetItems(Index: integer): TRODLEnumValue;
|
|
begin
|
|
result := TRODLEnumValue(inherited Items[Index]);
|
|
end;
|
|
|
|
procedure TRODLEnum.Validate(iMessages: IRoPluginMessages);
|
|
begin
|
|
inherited;
|
|
if Count = 0 then
|
|
iMessages.AddMessage(rmtError,Info.Name,err_RodlNoEnumValues,-1,self);
|
|
end;
|
|
|
|
{ TRODLBaseService }
|
|
|
|
function TRODLBaseService.Add(aServiceInterface: TRODLServiceInterface): integer;
|
|
begin
|
|
result := inherited Add(aServiceInterface);
|
|
end;
|
|
|
|
function TRODLBaseService.Add: TRODLServiceInterface;
|
|
begin
|
|
result := TRODLServiceInterface(inherited Add);
|
|
end;
|
|
|
|
constructor TRODLBaseService.Create;
|
|
var
|
|
defintf: TRODLServiceInterface;
|
|
begin
|
|
inherited;
|
|
fisPrivate := False;
|
|
defintf := Add;
|
|
defintf.Info.Name := DefaultIntfName;
|
|
defintf.Info.UID := NewGUID;
|
|
end;
|
|
|
|
function TRODLBaseService.GetAncestor: string;
|
|
begin
|
|
result := fAncestor;
|
|
end;
|
|
|
|
function TRODLBaseService.GetDefault: TRODLServiceInterface;
|
|
var
|
|
i: integer;
|
|
begin
|
|
result := nil;
|
|
if (Count = 1) then
|
|
result := Items[0]
|
|
else
|
|
for i := 0 to (Count - 1) do
|
|
if (CompareText(Items[i].Info.name, DefaultIntfName) = 0) then begin
|
|
result := Items[i];
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
function TRODLBaseService.GetItemClass: TRODLEntityClass;
|
|
begin
|
|
result := TRODLServiceInterface;
|
|
end;
|
|
|
|
function TRODLBaseService.GetItems(Index: integer): TRODLServiceInterface;
|
|
begin
|
|
result := TRODLServiceInterface(inherited Items[Index]);
|
|
end;
|
|
|
|
procedure TRODLBaseService.SetAncestor(const Value: string);
|
|
begin
|
|
fAncestor := Trim(Value);
|
|
end;
|
|
|
|
procedure TRODLBaseService.Validate(iMessages: IRoPluginMessages);
|
|
var
|
|
i:integer;
|
|
begin
|
|
inherited;
|
|
for i := 0 to Count-1 do begin
|
|
//Items[i].Validate(iMessages);
|
|
if (Items[i].Count = 0) and (Ancestor = '') then
|
|
iMessages.AddMessage(rmtWarning,Info.Name+'.'+Items[i].Info.Name,err_RodlNoOperationsDefined,-1,self);
|
|
end;
|
|
|
|
if (Ancestor <> '') then begin
|
|
if self is TRODLEventSink then begin
|
|
if not OwnerLibrary.IsValidEventSink(Ancestor) then
|
|
iMessages.AddMessage(rmtError,Info.Name,Format(err_RodlInvalidAncestorType,[Ancestor]),-1,self);
|
|
end else begin
|
|
if not OwnerLibrary.IsValidService(Ancestor) then
|
|
iMessages.AddMessage(rmtError,Info.Name,Format(err_RodlInvalidAncestorType,[Ancestor]),-1,self);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TRODLOperationParam }
|
|
|
|
{constructor TRODLOperationParam.Create(const aName, aTypeName: string; aFlag: TRODLParamFlag; aOwner:TRODLEntity);
|
|
begin
|
|
inherited Create(aName, aTypeName, aOwner);
|
|
Flag := aFlag;
|
|
end;}
|
|
|
|
function TRODLOperationParam.GetFlag: string;
|
|
begin
|
|
result := RODLParamFlagNames[fFlag];
|
|
end;
|
|
|
|
procedure TRODLOperationParam.SetFlag(const aValue: string);
|
|
var
|
|
lFlag: TRODLParamFlag;
|
|
begin
|
|
for lFlag := Low(TRODLParamFlag) to High(TRODLParamFlag) do
|
|
if SameText(RODLParamFlagNames[lFlag], aValue) then begin
|
|
fFlag := lFlag;
|
|
exit;
|
|
end;
|
|
RaiseError(err_InvalidParamFlag, [aValue]);
|
|
end;
|
|
|
|
{ TRODLOperation }
|
|
|
|
function TRODLOperation.Add(aParam: TRODLOperationParam): integer;
|
|
begin
|
|
if aParam.fFlag = fResult then
|
|
RaiseError(err_MayNotAddResult);
|
|
|
|
result := inherited Add(aParam)
|
|
end;
|
|
|
|
function TRODLOperation.Add: TRODLOperationParam;
|
|
begin
|
|
result := TRODLOperationParam(inherited Add);
|
|
result.Info.Name := 'Param' + IntToStr(Count);
|
|
end;
|
|
|
|
function TRODLOperation.GetItemClass: TRODLEntityClass;
|
|
begin
|
|
result := TRODLOperationParam;
|
|
end;
|
|
|
|
function TRODLOperation.GetItems(Index: integer): TRODLOperationParam;
|
|
begin
|
|
result := TRODLOperationParam(inherited Items[Index]);
|
|
end;
|
|
|
|
function TRODLOperation.GetResult: TRODLOperationParam;
|
|
{var
|
|
i: integer;}
|
|
begin
|
|
result := fOperationResult;
|
|
{result := nil;
|
|
for i := 0 to (Count - 1) do
|
|
if (Items[i].Info.Flag = fResult) then begin
|
|
result := Items[i];
|
|
Exit;
|
|
end;}
|
|
end;
|
|
|
|
{ Makes sure the Result patrameter is always at the top of the list, so it
|
|
doesn't get in the way of sorting methods. }
|
|
|
|
{procedure TRODLOperation.MoveResult;
|
|
var
|
|
i: integer;
|
|
begin
|
|
for i := 0 to (Count - 1) do
|
|
if (Items[i].Info.Flag = fResult) then begin
|
|
if i <> 0 then fItems.Move(i,0);
|
|
Exit;
|
|
end;
|
|
end;}
|
|
|
|
|
|
function TRODLOperation.GetCodeBody(iLanguage: string): TStrings;
|
|
var
|
|
lIndex:integer;
|
|
begin
|
|
result := nil;
|
|
|
|
lIndex := fCodeBodies.IndexOf(iLanguage);
|
|
if lIndex > -1 then result := fCodeBodies.Objects[lIndex] as TStrings
|
|
end;
|
|
|
|
procedure TRODLOperation.SetCodeBody(iLanguage: string; Value: TStrings);
|
|
var
|
|
lStrings:TStrings;
|
|
lIndex:integer;
|
|
begin
|
|
if Assigned(Value) then begin
|
|
lStrings := GetCodeBody(iLanguage);
|
|
if not Assigned(lStrings) then begin
|
|
lStrings := TStringList.Create();
|
|
fCodeBodies.AddObject(Lowercase(iLanguage),lStrings);
|
|
end;
|
|
lStrings.Assign(Value);
|
|
end
|
|
else begin
|
|
lIndex := fCodeBodies.IndexOf(iLanguage);
|
|
if lIndex > 0 then fCodeBodies.Delete(lIndex);
|
|
end;
|
|
end;
|
|
|
|
procedure TRODLOperation.SetCodeBodyAsString(iLanguage: string; const Value: string);
|
|
var
|
|
lStrings:TStrings;
|
|
lIndex:integer;
|
|
begin
|
|
if Value <> '' then begin
|
|
lStrings := GetCodeBody(iLanguage);
|
|
if not Assigned(lStrings) then begin
|
|
lStrings := TStringList.Create();
|
|
fCodeBodies.AddObject(Lowercase(iLanguage),lStrings);
|
|
end;
|
|
lStrings.Text := Value;
|
|
end
|
|
else begin
|
|
lIndex := fCodeBodies.IndexOf(iLanguage);
|
|
if lIndex > 0 then fCodeBodies.Delete(lIndex);
|
|
end;
|
|
end;
|
|
|
|
constructor TRODLOperation.Create;
|
|
begin
|
|
inherited;
|
|
fCodeBodies := TStringList.Create();
|
|
fCodeBodies.Sorted := true;
|
|
fCodeBodies.Duplicates := dupError;
|
|
end;
|
|
|
|
destructor TRODLOperation.Destroy;
|
|
var i:integer;
|
|
begin
|
|
RemoveResult;
|
|
for i := 0 to fCodeBodies.Count-1 do fCodeBodies.Objects[i].Free();
|
|
FreeAndNil(fCodeBodies);
|
|
inherited;
|
|
end;
|
|
|
|
function TRODLOperation.GetCodeBodyCount: integer;
|
|
begin
|
|
result := fCodeBodies.Count;
|
|
end;
|
|
|
|
function TRODLOperation.GetCodeBodyLanguages(iIndex: integer): string;
|
|
begin
|
|
result := fCodeBodies[iIndex];
|
|
end;
|
|
|
|
{procedure TRODLOperation.Exchange(Index1, Index2: integer);
|
|
begin
|
|
MoveResult();
|
|
if Assigned(GetResult()) then begin
|
|
inc(Index1);
|
|
inc(Index2);
|
|
end;
|
|
inherited Exchange(Index1, Index2);
|
|
end;}
|
|
|
|
function TRODLOperation.AddResult: TRODLOperationParam;
|
|
begin
|
|
if not Assigned(fOperationResult) then begin
|
|
fOperationResult := TRODLOperationParam.Create;
|
|
fOperationResult.fOwner := self;
|
|
fOperationResult.Flag := fResult;
|
|
fOperationResult.Name := 'Result';
|
|
end;
|
|
result := fOperationResult;
|
|
end;
|
|
|
|
procedure TRODLOperation.RemoveResult;
|
|
begin
|
|
if Assigned(fOperationResult) then
|
|
FreeAndNil(fOperationResult);
|
|
end;
|
|
|
|
function TRODLOperation.GetParameter(const aParameterName: string): TRODLOperationParam;
|
|
begin
|
|
result := TRODLOperationParam(ItemByName(aParameterName));
|
|
if result=NIL then raise EROUnknownItem.CreateFmt('Cannot find parameter %s', [aParameterName]);
|
|
end;
|
|
|
|
procedure TRODLOperation.Validate(iMessages: IROPluginMessages);
|
|
begin
|
|
inherited;
|
|
if (Result <> nil) and (Result.DataType <> '') then begin
|
|
if not Owner.OwnerLibrary.IsValidType(Result.DataType) then
|
|
iMessages.AddMessage(rmtError,Info.Name+'.'+Name,Format(err_RodlInvalidDataType,[Result.DataType]),-1,Self);
|
|
end;
|
|
end;
|
|
|
|
{ TRODLServiceInterface }
|
|
|
|
function TRODLServiceInterface.Add(aParam: TRODLOperation): integer;
|
|
begin
|
|
result := inherited Add(aParam)
|
|
end;
|
|
|
|
function TRODLServiceInterface.Add: TRODLOperation;
|
|
begin
|
|
result := TRODLOperation(inherited Add);
|
|
result.Info.Name := 'Operation' + IntToStr(Count);
|
|
result.Info.UID := NewGUID;
|
|
end;
|
|
|
|
function TRODLServiceInterface.GetOperation(
|
|
const anOperationName: string;
|
|
IncludeAnchestors : boolean = FALSE) : TRODLOperation;
|
|
begin
|
|
result := FindOperation(anOperationName, IncludeAnchestors);
|
|
if (result=NIL) then raise EROUnknownItem.CreateFmt('Cannot find operation %s', [anOperationName]);
|
|
end;
|
|
|
|
procedure TRODLServiceInterface.GetOperationsList(AList: TList);
|
|
var svc : TRODLService;
|
|
i: Integer;
|
|
lib : TRODLLibrary;
|
|
begin
|
|
AList.Clear;
|
|
|
|
For i:=0 to Count-1 do
|
|
AList.Add(Items[i]);
|
|
|
|
lib := info.Owner.OwnerLibrary;
|
|
svc := lib.FindService((Owner as TRODLService).Info.Name);
|
|
|
|
while TRUE do begin
|
|
if (svc.Ancestor='') then Break;
|
|
|
|
svc := lib.GetService(svc.Ancestor);
|
|
|
|
For i:=0 to Count-1 do
|
|
AList.Add(svc.Default.Items[i]);
|
|
end;
|
|
end;
|
|
|
|
function TRODLServiceInterface.GetItemClass: TRODLEntityClass;
|
|
begin
|
|
result := TRODLOperation;
|
|
end;
|
|
|
|
function TRODLServiceInterface.GetItems(Index: integer): TRODLOperation;
|
|
begin
|
|
result := TRODLOperation(inherited Items[Index]);
|
|
end;
|
|
|
|
function TRODLServiceInterface.FindOperation(const anOperationName : string; IncludeAnchestors : boolean = FALSE) : TRODLOperation;
|
|
var svc : TRODLService;
|
|
i: Integer;
|
|
lib : TRODLLibrary;
|
|
begin
|
|
result := NIL;
|
|
for i := 0 to (Count-1) do
|
|
if SameText(anOperationName, Items[i].Info.Name) then begin
|
|
result := Items[i];
|
|
Exit;
|
|
end;
|
|
|
|
if (result=NIL) and IncludeAnchestors then begin
|
|
lib := info.Owner.OwnerLibrary;
|
|
//intf := TRODLServiceInterface;
|
|
svc := lib.FindService((Owner as TRODLService).Info.Name);
|
|
|
|
while TRUE do begin
|
|
if (svc.Ancestor='') then Break;
|
|
|
|
svc := lib.GetService(svc.Ancestor);
|
|
result := svc.Default.FindOperation(anOperationName);
|
|
|
|
if (result<>NIL) then Exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TRODLLibrary }
|
|
|
|
function TRODLLibrary.Add(anEntity: TRODLEntity): integer;
|
|
begin
|
|
if (anEntity is TRODLArray) then
|
|
Inc(fArrayCount)
|
|
else if (anEntity is TRODLEnum) then
|
|
Inc(fEnumCount)
|
|
else if (anEntity is TRODLStruct) then
|
|
Inc(fStructCount)
|
|
else if (anEntity is TRODLService) then
|
|
Inc(fServiceCount)
|
|
else if (anEntity is TRODLUse) then
|
|
Inc(fUseCount)
|
|
else if (anEntity is TRODLException) then
|
|
Inc(fExceptionCount)
|
|
else if (anEntity is TRODLEventSink) then
|
|
Inc(fEventSinkCount)
|
|
else if (anEntity is TRODLGroup) then
|
|
Inc(fGroupCount);
|
|
|
|
result := inherited Add(anEntity);
|
|
end;
|
|
|
|
function TRODLLibrary.GetItemClass: TRODLEntityClass;
|
|
begin
|
|
result := TRODLEntity;
|
|
end;
|
|
|
|
procedure TRODLLibrary.Remove(anEntity: TRODLEntity);
|
|
var
|
|
i: Integer;
|
|
begin
|
|
if (anEntity is TRODLGroup) then begin
|
|
for i := 0 to Count-1 do
|
|
if Items[i].GroupUnder = anEntity then
|
|
Items[i].GroupUnder := anEntity.GroupUnder;
|
|
end
|
|
else if (anEntity is TRODLUse) then begin
|
|
for i := Count-1 downto 0 do
|
|
if Items[i].LocatedInRodlUse = anEntity then
|
|
Remove(Items[i]);
|
|
end;
|
|
|
|
if (anEntity is TRODLArray) then
|
|
Dec(fArrayCount)
|
|
else if (anEntity is TRODLEnum) then
|
|
Dec(fEnumCount)
|
|
else if (anEntity is TRODLStruct) then
|
|
Dec(fStructCount)
|
|
else if (anEntity is TRODLService) then
|
|
Dec(fServiceCount)
|
|
else if (anEntity is TRODLUse) then
|
|
Dec(fUseCount)
|
|
else if (anEntity is TRODLException) then
|
|
Dec(fExceptionCount)
|
|
else if (anEntity is TRODLEventSink) then
|
|
Dec(fEventSinkCount)
|
|
else if (anEntity is TRODLGroup) then
|
|
Dec(fGroupCount);
|
|
|
|
inherited;
|
|
end;
|
|
|
|
procedure TRODLLibrary.Delete(Index: integer);
|
|
var
|
|
item: TRODLEntity;
|
|
begin
|
|
item := Items[Index];
|
|
Remove(item);
|
|
inherited Delete(Index);
|
|
end;
|
|
|
|
function TRODLLibrary.GetArray(Index: integer): TRODLArray;
|
|
begin
|
|
if (Index > ArrayCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLArray) as TRODLArray;
|
|
end;
|
|
|
|
function TRODLLibrary.GetEnums(Index: integer): TRODLEnum;
|
|
begin
|
|
if (Index > EnumCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLEnum) as TRODLEnum;
|
|
end;
|
|
|
|
function TRODLLibrary.GetServices(Index: integer): TRODLService;
|
|
begin
|
|
if (Index > ServiceCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLService) as TRODLService;
|
|
end;
|
|
|
|
function TRODLLibrary.GetStructs(Index: integer): TRODLStruct;
|
|
begin
|
|
if (Index > StructCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLStruct) as TRODLStruct;
|
|
end;
|
|
|
|
function TRODLLibrary.GetExceptions(Index: integer): TRODLException;
|
|
begin
|
|
if (Index > ExceptionCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLException) as TRODLException;
|
|
end;
|
|
|
|
function TRODLLibrary.GetUse(Index: integer): TRODLUse;
|
|
begin
|
|
if (Index > UseCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLUse) as TRODLUse;
|
|
end;
|
|
|
|
function TRODLLibrary.GetGroups(Index: integer): TRODLGroup;
|
|
begin
|
|
if (Index > GroupCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLGroup) as TRODLGroup;
|
|
end;
|
|
|
|
function TRODLLibrary.GetEventSinks(Index: integer): TRODLEventSink;
|
|
begin
|
|
if (Index > EventSinkCount - 1) then RaiseError(err_InvalidIndex, [Index]);
|
|
result := GetByType(Index,TRODLEventSink) as TRODLEventSink;
|
|
end;
|
|
|
|
function TRODLLibrary.GetByType(aIndex:integer; aType:TRODLEntityClass):TRODLEntity;
|
|
var
|
|
i, c: integer;
|
|
begin
|
|
result := nil;
|
|
if (aIndex < 0) then RaiseError(err_InvalidIndex, [aIndex]);
|
|
|
|
c := -1;
|
|
for i := 0 to (Count - 1) do begin
|
|
if (Items[i] is aType) then Inc(c);
|
|
if (c = aIndex) then begin
|
|
result := Items[i];
|
|
Exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
constructor TRODLLibrary.Create;
|
|
begin
|
|
inherited;
|
|
Info.Name := 'NewLibrary';
|
|
Info.UID := NewGUID;
|
|
end;
|
|
|
|
function TRODLLibrary.IsValidCustomType(const iTypeName: string): boolean;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := false;
|
|
for i := 0 to ArrayCount-1 do begin
|
|
if CompareText(Arrays[i].Info.Name,iTypeName) = 0 then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
for i := 0 to StructCount-1 do begin
|
|
if CompareText(Structs[i].Info.Name,iTypeName) = 0 then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
for i := 0 to EnumCount-1 do begin
|
|
if CompareText(Enums[i].Info.Name,iTypeName) = 0 then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.IsValidSimpleType(const iTypeName: string): boolean;
|
|
var
|
|
d:TRODataType;
|
|
i: Integer;
|
|
begin
|
|
result := false;
|
|
for d := Low(TRODataType) to High(TRODataType) do begin
|
|
if (not (d in [rtUserDefined])) and
|
|
(CompareText(DataTypeNames[d],iTypeName) = 0) then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
for i := Low(DataTypeRemapping) to High(DataTypeRemapping) do begin
|
|
if CompareText(DataTypeRemapping[i].Name, iTypeName) = 0 then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TRODLLibrary.IsValidType(const iTypeName: string): boolean;
|
|
begin
|
|
result := IsValidCustomType(iTypeName) or IsValidSimpleType(iTypeName);
|
|
end;
|
|
|
|
function TRODLLibrary.FindStruct(const iStructName: string): TRODLStruct;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to StructCount-1 do begin
|
|
if CompareText(Structs[i].Info.Name,iStructName) = 0 then begin
|
|
result := Structs[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.FindBaseStruct(const iStructName: string): TRODLBaseStruct;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to Count-1 do begin
|
|
if (Items[i] is TRODLBaseStruct) and (CompareText(Items[i].Info.Name,iStructName) = 0) then begin
|
|
result := Items[i] as TRODLBaseStruct;
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TRODLLibrary.FindEnum(const iEnumName: string): TRODLEnum;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to EnumCount-1 do begin
|
|
if CompareText(Enums[i].Info.Name,iEnumName) = 0 then begin
|
|
result := Enums[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.FindArray(const iArrayName: string): TRODLArray;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to ArrayCount-1 do begin
|
|
if CompareText(Arrays[i].Info.Name,iArrayName) = 0 then begin
|
|
result := Arrays[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TRODLLibrary.FindGroup(const aID: TGUID): TRODLGroup;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to GroupCount-1 do begin
|
|
if IsEqualGUID(Groups[i].UID,aID) then begin
|
|
result := Groups[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TRODLLibrary.IsValidService(const iServiceName: string): boolean;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := false;
|
|
for i := 0 to ServiceCount-1 do begin
|
|
if CompareText(Services[i].Info.Name,iServiceName) = 0 then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.FindService(const iServiceName: string):TRODLService;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to ServiceCount-1 do begin
|
|
if CompareText(Services[i].Info.Name,iServiceName) = 0 then begin
|
|
result := Services[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.FindException(const iExceptionName: string):TRODLException;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to ExceptionCount-1 do begin
|
|
if CompareText(Exceptions[i].Info.Name,iExceptionName) = 0 then begin
|
|
result := Exceptions[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.FindUse(const iUseName: string):TRODLUse;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to fUseCount-1 do begin
|
|
if CompareText(Use[i].Info.Name,iUseName) = 0 then begin
|
|
result := Use[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.FindUseByFilename(const iUseRODLFile: string):TRODLUse;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := nil;
|
|
for i := 0 to fUseCount-1 do begin
|
|
if CompareText(Use[i].RodlFile, iUseRODLFile) = 0 then begin
|
|
result := Use[i];
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.IsValidException(const iTypeName:string):boolean;
|
|
var
|
|
i:integer;
|
|
begin
|
|
result := false;
|
|
for i := 0 to ExceptionCount-1 do begin
|
|
if CompareText(Exceptions[i].Info.Name,iTypeName) = 0 then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.CalcServiceOrder: IROStrings;
|
|
var
|
|
lEntities:IROStrings;
|
|
i:integer;
|
|
begin
|
|
lEntities := NewROStrings();
|
|
for i := ServiceCount-1 downto 0 do begin
|
|
if not Services[i].IsFromUsedRodl then
|
|
lEntities.AddObject(Services[i].Info.Name,Services[i])
|
|
end;
|
|
result := CalcOrder(lEntities);
|
|
end;
|
|
|
|
function TRODLLibrary.CalcEventSinkOrder: IROStrings;
|
|
var
|
|
lEntities:IROStrings;
|
|
i:integer;
|
|
begin
|
|
lEntities := NewROStrings();
|
|
for i := EventSinkCount-1 downto 0 do begin
|
|
if not EventSinks[i].IsFromUsedRodl then
|
|
lEntities.AddObject(EventSinks[i].Info.Name,EventSinks[i])
|
|
end;
|
|
result := CalcOrder(lEntities);
|
|
end;
|
|
|
|
function TRODLLibrary.CalcStructOrder: IROStrings;
|
|
var
|
|
lEntities:IROStrings;
|
|
i:integer;
|
|
begin
|
|
lEntities := NewROStrings();
|
|
for i := StructCount-1 downto 0 do begin
|
|
if not Structs[i].IsFromUsedRodl then
|
|
lEntities.AddObject(Structs[i].Info.Name,Structs[i])
|
|
end;
|
|
result := CalcOrder(lEntities);
|
|
end;
|
|
|
|
function TRODLLibrary.CalcExceptionOrder: IROStrings;
|
|
var
|
|
lEntities:IROStrings;
|
|
i:integer;
|
|
begin
|
|
lEntities := NewROStrings();
|
|
for i := ExceptionCount-1 downto 0 do begin
|
|
if not Exceptions[i].IsFromUsedRodl then
|
|
lEntities.AddObject(Exceptions[i].Info.Name,Exceptions[i])
|
|
end;
|
|
result := CalcOrder(lEntities);
|
|
end;
|
|
|
|
function TRODLLibrary.CalcOrder(const iObjects:IROStrings):IROStrings;
|
|
var
|
|
lAncestors:IROStrings;
|
|
i,lIndex:integer;
|
|
lEntity:TRODLEntity;
|
|
lWorked:boolean;
|
|
begin
|
|
lAncestors := NewROStrings();
|
|
result := NewROStrings();
|
|
|
|
for i := 0 to iObjects.Count-1 do begin
|
|
lEntity := iObjects.Objects[i] as TRODLEntity;
|
|
lAncestors.AddObject((lEntity as IRODLEntityWithAncestor).Ancestor,lEntity)
|
|
end;
|
|
|
|
for i := lAncestors.Count-1 downto 0 do begin
|
|
if lAncestors[i] <> '' then lIndex := iObjects.IndexOf(lAncestors[i]) else lIndex := -1; { else needed to keep the warning away only }
|
|
if (lAncestors[i] = '') or (lIndex = -1) then begin
|
|
result.AddObject((lAncestors.Objects[i] as TRODLEntity).Info.Name,lAncestors.Objects[i]);
|
|
lAncestors.Delete(i);
|
|
end;
|
|
end;
|
|
|
|
while lAncestors.Count > 0 do begin
|
|
lWorked := false;
|
|
for i := lAncestors.Count-1 downto 0 do begin
|
|
lIndex := result.IndexOf(lAncestors[i]);
|
|
if (lIndex > -1) then begin
|
|
result.InsertObject(lIndex+1,(lAncestors.Objects[i] as TRODLEntity).Info.Name,lAncestors.Objects[i]);
|
|
lAncestors.Delete(i);
|
|
lWorked := true;
|
|
end;
|
|
end;
|
|
if (not lWorked) and (lAncestors.Count > 0) then
|
|
RaiseError('Invalid or recursive inheritance for the following entities: '+lAncestors.Text);
|
|
end;
|
|
end;
|
|
|
|
function TRODLLibrary.GetService(const aServiceName: string): TRODLService;
|
|
begin
|
|
result := FindService(aServiceName);
|
|
if result=NIL then raise EROUnknownItem.CreateFmt('Cannot find service %s', [aServiceName])
|
|
end;
|
|
|
|
function TRODLLibrary.GetStruct(const aStructName: string): TRODLStruct;
|
|
begin
|
|
result := FindStruct(aStructName);
|
|
if result=NIL then raise EROUnknownItem.CreateFmt('Cannot find struct %s', [aStructName])
|
|
end;
|
|
|
|
procedure TRODLLibrary.ClearDuplicates;
|
|
var
|
|
lID: string;
|
|
lItem: TRODLEntity;
|
|
lIDs: TStringList;
|
|
i: Integer;
|
|
const
|
|
EMPTY_GUID = '{00000000-0000-0000-0000-000000000000}';
|
|
begin
|
|
lIDs := TStringList.Create();
|
|
try
|
|
lIDs.Duplicates := dupError;
|
|
lIDs.Sorted := true;
|
|
for i := Count-1 downto 0 do begin
|
|
lItem := Items[i];
|
|
|
|
if (lItem is TRODLUse) then continue; { removing duplicate uses would blow up the order; and they do no harm anyway }
|
|
lID := GUIDToString(lItem.UID);
|
|
if SameText(lID, EMPTY_GUID) then continue;
|
|
|
|
if (lIDs.IndexOf(lID) > -1) and (not SameText(lID, EMPTY_GUID)) then begin
|
|
{$IFDEF DEBUG_REMOBJECTS_RODL}
|
|
DebugServer.Write('Removing duplicate %s %s (%s)',[lItem.ReadableEntityTypeName, lItem.Name, lID]);
|
|
{$ENDIF}
|
|
Remove(lItem);
|
|
end
|
|
else begin
|
|
lIDs.Add(lID);
|
|
end;
|
|
end; { for }
|
|
finally
|
|
lIDs.Free();
|
|
end;
|
|
end;
|
|
|
|
procedure TRODLLibrary.GetArraysByElement(const aElementName: string;
|
|
AList: TList);
|
|
var
|
|
i: integer;
|
|
begin
|
|
AList.Clear;
|
|
for i := 0 to ArrayCount-1 do
|
|
if CompareText(Arrays[i].ElementType,aElementName) = 0 then
|
|
AList.Add(Arrays[i]);
|
|
end;
|
|
|
|
function TRODLLibrary.IsValidEventSink(
|
|
const iEventSink: string): boolean;
|
|
var
|
|
i: integer;
|
|
begin
|
|
result := false;
|
|
|
|
for i := 0 to EventSinkCount-1 do begin
|
|
if CompareText(EventSinks[i].Info.Name,iEventsink) = 0 then begin
|
|
result := true;
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TRODLArray }
|
|
|
|
procedure TRODLArray.SetElementType(const Value: string);
|
|
begin
|
|
fElementType := Trim(Value);
|
|
end;
|
|
|
|
procedure TRODLArray.Validate(iMessages:IRoPluginMessages);
|
|
//function TRODLArray.Validate(out FaultyEntity: TRODLEntity; out ErrorMessage: string): boolean;
|
|
begin
|
|
inherited;
|
|
if (ElementType = '') then
|
|
iMessages.AddMessage(rmtError,Info.Name,err_RodlNoDataTypeSpecified,-1,self);
|
|
|
|
if (ElementType <> '') and not OwnerLibrary.IsValidType(ElementType) then
|
|
iMessages.AddMessage(rmtError,Info.Name,Format(err_RodlInvalidDataType,[ElementType]),-1,Owner);
|
|
end;
|
|
|
|
{ TRODLConverter }
|
|
|
|
constructor TRODLConverter.Create(const aLibraryFile: string; const aTargetEntity: string = '');
|
|
var
|
|
lLibrary: TRODLLibrary;
|
|
begin
|
|
with TXMLToRODL.Create(nil) do try
|
|
lLibrary := ReadFromFile(aLibraryFile);
|
|
try
|
|
Self.Create(lLibrary, aTargetEntity);
|
|
finally
|
|
FreeAndNil(lLibrary);
|
|
end;
|
|
finally
|
|
Free;
|
|
end;
|
|
end;
|
|
|
|
constructor TRODLConverter.Create(const aLibrary: TRODLLibrary; const aTargetEntity: string = '');
|
|
begin
|
|
inherited Create;
|
|
|
|
fBuffer := TStringList.Create;
|
|
if (aLibrary <> nil) then Convert(aLibrary, aTargetEntity);
|
|
end;
|
|
|
|
destructor TRODLConverter.Destroy;
|
|
begin
|
|
fBuffer.Free;
|
|
inherited;
|
|
end;
|
|
|
|
procedure TRODLConverter.Convert(const aLibrary: TRODLLibrary; const aTargetEntity: string = '');
|
|
begin
|
|
if (aLibrary = nil) then
|
|
RaiseError(err_InvalidLibrary, [])
|
|
else if (aTargetEntity<>'') and not ValidateTargetEntity(aLibrary, aTargetEntity) then
|
|
RaiseError(err_InvalidTargetEntity, [aTargetEntity]);
|
|
|
|
fTargetEntity := aTargetEntity;
|
|
|
|
fBuffer.Clear;
|
|
IntConvert(aLibrary, aTargetEntity);
|
|
end;
|
|
|
|
function TRODLConverter.GetBuffer: TStrings;
|
|
begin
|
|
result := fBuffer as TStrings;
|
|
end;
|
|
|
|
function TRODLConverter.ValidateTargetEntity(const aLibrary: TRODLLibrary; const aTargetEntity: string): boolean;
|
|
begin
|
|
result := aLibrary.FindService(aTargetEntity)<>NIL;
|
|
end;
|
|
|
|
procedure TRODLConverter.Write(const someText: string; Indentation: integer = 0);
|
|
var
|
|
i: integer;
|
|
s: string;
|
|
begin
|
|
s := '';
|
|
|
|
for i := 1 to Indentation do
|
|
s := s + ' ';
|
|
s := s + someText;
|
|
|
|
fBuffer.Add(s)
|
|
end;
|
|
|
|
procedure TRODLConverter.WriteLines(const someText: string);
|
|
begin
|
|
fBuffer.Text := fBuffer.Text + someText;
|
|
end;
|
|
|
|
procedure TRODLConverter.WriteEmptyLine;
|
|
begin
|
|
fBuffer.Add('');
|
|
end;
|
|
|
|
class function TRODLConverter.GetTargetFileName(const aLibrary: TRODLLibrary;
|
|
const aTargetEntity: string): string;
|
|
begin
|
|
result := '';
|
|
end;
|
|
|
|
{ TRODLReader }
|
|
|
|
constructor TRODLReader.Create;
|
|
begin
|
|
end;
|
|
|
|
function TRODLReader.Read(aStream: TStream; const aFilename:string): TRODLLibrary;
|
|
begin
|
|
if (aStream = nil) then RaiseError(err_InvalidStream, []);
|
|
result := IntReadFromStream(aStream, aFilename)
|
|
end;
|
|
|
|
function TRODLReader.ReadFromFile(const aFileName: string): TRODLLibrary;
|
|
var
|
|
fs: TFileStream;
|
|
begin
|
|
fs := TFileStream.Create(aFileName, fmOpenRead);
|
|
try
|
|
result := Read(fs, aFilename)
|
|
finally
|
|
fs.Free;
|
|
end;
|
|
end;
|
|
|
|
{ TRODLException }
|
|
|
|
procedure TRODLException.Validate(iMessages: IRoPluginMessages);
|
|
begin
|
|
inherited;
|
|
|
|
if (Ancestor <> '') and not OwnerLibrary.IsValidException(Ancestor) then
|
|
iMessages.AddMessage(rmtError,Info.Name,Format(err_RodlInvalidAncestorType,[Ancestor]),-1,self);
|
|
end;
|
|
|
|
{ TRODLUse }
|
|
|
|
procedure TRODLUse.Validate(iMessages: IRoPluginMessages);
|
|
begin
|
|
inherited;
|
|
|
|
if not (FileExists(ExpandVariables(fRodlFile)) or FileExists(fAbsoluteRodlFile)) then
|
|
iMessages.AddMessage(rmtWarning,ExtractFileName(fRodlFile),Format(err_RodlUsedFileDoesNotExist,[ExpandVariables(fRodlFile)]),-1,self);
|
|
|
|
|
|
end;
|
|
|
|
end.
|
|
|