1414 lines
40 KiB
ObjectPascal
1414 lines
40 KiB
ObjectPascal
unit XMLDataBindingGenerator;
|
|
|
|
// #ToDo1 (MvR) 7-3-2008: check if List items can be collapsed if an item is
|
|
// already a list parent
|
|
// #ToDo1 (MvR) 19-3-2008: attributes
|
|
interface
|
|
uses
|
|
Classes,
|
|
Contnrs,
|
|
XMLSchema;
|
|
|
|
type
|
|
TXMLDataBindingSchema = class;
|
|
TXMLDataBindingItem = class;
|
|
TXMLDataBindingInterface = class;
|
|
TXMLDataBindingCollection = class;
|
|
TXMLDataBindingEnumerationMember = class;
|
|
TXMLDataBindingEnumeration = class;
|
|
TXMLDataBindingProperty = class;
|
|
|
|
|
|
TXMLDataBindingOutputType = (otSingle, otMultiple);
|
|
TXMLDataBindingItemType = (itInterface, itCollection, itEnumeration,
|
|
itEnumerationMember, itProperty, itForward,
|
|
itComplexTypeElement);
|
|
TXMLDataBindingInterfaceType = (ifElement, ifComplexType);
|
|
TXMLDataBindingPropertyType = (ptSimple, ptItem);
|
|
|
|
|
|
TXMLDataBindingIterateItemsProc = procedure(AItem: TXMLDataBindingItem; AData: Pointer; var AAbort: Boolean) of object;
|
|
|
|
|
|
TXMLDataBindingGenerator = class(TObject)
|
|
private
|
|
FIncludePaths: TStrings;
|
|
FOutputPath: String;
|
|
FOutputType: TXMLDataBindingOutputType;
|
|
FSourceFileName: String;
|
|
|
|
FSchemas: TObjectList;
|
|
FMustResolve: Boolean;
|
|
|
|
function GetSchemaCount(): Integer;
|
|
function GetSchemas(Index: Integer): TXMLDataBindingSchema;
|
|
protected
|
|
function LoadSchema(const AStream: TStream; const ASchemaName: String): TXMLDataBindingSchema;
|
|
function GetSchemaData(const ALocation: String): TStream;
|
|
function FindSchema(const ALocation: String): TXMLDataBindingSchema;
|
|
|
|
procedure GenerateSchemaObjects(ASchema: TXMLDataBindingSchema; ARootDocument: Boolean);
|
|
procedure GenerateElementObjects(ASchema: TXMLDataBindingSchema; ARootDocument: Boolean);
|
|
procedure GenerateComplexTypeObjects(ASchema: TXMLDataBindingSchema);
|
|
|
|
function ProcessElement(ASchema: TXMLDataBindingSchema; AElement: IXMLElementDef): TXMLDataBindingItem;
|
|
procedure ProcessChildElement(ASchema: TXMLDataBindingSchema; AElement: IXMLElementDef; AInterface: TXMLDataBindingInterface);
|
|
|
|
function IterateSchemaItems(ASchema: TXMLDataBindingSchema; AIterateProc: TXMLDataBindingIterateItemsProc; AData: Pointer): TXMLDataBindingItem;
|
|
|
|
procedure FindInterfaceProc(AItem: TXMLDataBindingItem; AData: Pointer; var AAbort: Boolean);
|
|
function FindInterface(ASchema: TXMLDataBindingSchema; const AName: String; AType: TXMLDataBindingInterfaceType): TXMLDataBindingInterface;
|
|
|
|
procedure FindCollectionProc(AItem: TXMLDataBindingItem; AData: Pointer; var AAbort: Boolean);
|
|
function FindCollection(ASchema: TXMLDataBindingSchema; const AName: String): TXMLDataBindingCollection;
|
|
|
|
procedure FindEnumerationProc(AItem: TXMLDataBindingItem; AData: Pointer; var AAbort: Boolean);
|
|
function FindEnumeration(ASchema: TXMLDataBindingSchema; const AName: String): TXMLDataBindingEnumeration;
|
|
|
|
procedure ResolveSchema(ASchema: TXMLDataBindingSchema);
|
|
procedure ResolveItem(ASchema: TXMLDataBindingSchema; AItem: TXMLDataBindingItem);
|
|
procedure ResolveNameConflicts();
|
|
|
|
procedure TranslateSchema(ASchema: TXMLDataBindingSchema);
|
|
procedure TranslateItem(AItem: TXMLDataBindingItem);
|
|
function TranslateItemName(AItem: TXMLDataBindingItem): String; virtual;
|
|
|
|
procedure GenerateDataBinding(); virtual; abstract;
|
|
|
|
property SourceFileName: String read FSourceFileName write FSourceFileName;
|
|
property SchemaCount: Integer read GetSchemaCount;
|
|
property Schemas[Index: Integer]: TXMLDataBindingSchema read GetSchemas;
|
|
public
|
|
constructor Create();
|
|
destructor Destroy(); override;
|
|
|
|
procedure Execute(const AStream: TStream; const ASchemaName: String); overload;
|
|
procedure Execute(const AFileName: String); overload;
|
|
|
|
property IncludePaths: TStrings read FIncludePaths;
|
|
property OutputType: TXMLDataBindingOutputType read FOutputType write FOutputType;
|
|
property OutputPath: String read FOutputPath write FOutputPath;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingSchema = class(TObject)
|
|
private
|
|
FIncludes: TObjectList;
|
|
FItems: TObjectList;
|
|
FItemsGenerated: Boolean;
|
|
FSchemaDef: IXMLSchemaDef;
|
|
FSchemaName: String;
|
|
|
|
function GetItemCount(): Integer;
|
|
function GetItems(Index: Integer): TXMLDataBindingItem;
|
|
function GetIncludeCount(): Integer;
|
|
function GetIncludes(Index: Integer): TXMLDataBindingSchema;
|
|
protected
|
|
procedure AddInclude(ASchema: TXMLDataBindingSchema);
|
|
procedure AddItem(AItem: TXMLDataBindingItem);
|
|
|
|
property ItemsGenerated: Boolean read FItemsGenerated write FItemsGenerated;
|
|
public
|
|
constructor Create();
|
|
destructor Destroy(); override;
|
|
|
|
property IncludeCount: Integer read GetIncludeCount;
|
|
property Includes[Index: Integer]: TXMLDataBindingSchema read GetIncludes;
|
|
|
|
property SchemaDef: IXMLSchemaDef read FSchemaDef write FSchemaDef;
|
|
property SchemaName: String read FSchemaName write FSchemaName;
|
|
|
|
property ItemCount: Integer read GetItemCount;
|
|
property Items[Index: Integer]: TXMLDataBindingItem read GetItems;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingItem = class(TObject)
|
|
private
|
|
FDocumentElement: Boolean;
|
|
FName: String;
|
|
FSchemaItem: IXMLSchemaItem;
|
|
FTranslatedName: String;
|
|
|
|
function GetDocumentation(): String;
|
|
function GetHasDocumentation(): Boolean;
|
|
protected
|
|
function GetItemType(): TXMLDataBindingItemType; virtual; abstract;
|
|
procedure SetName(const Value: String);
|
|
procedure SetTranslatedName(const Value: string);
|
|
|
|
property SchemaItem: IXMLSchemaItem read FSchemaItem;
|
|
public
|
|
constructor Create(ASchemaItem: IXMLSchemaItem; const AName: String);
|
|
|
|
property DocumentElement: Boolean read FDocumentElement write FDocumentElement;
|
|
property Documentation: String read GetDocumentation;
|
|
property HasDocumentation: Boolean read GetHasDocumentation;
|
|
property ItemType: TXMLDataBindingItemType read GetItemType;
|
|
property Name: String read FName;
|
|
property TranslatedName: String read FTranslatedName;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingInterface = class(TXMLDataBindingItem)
|
|
private
|
|
FInterfaceType: TXMLDataBindingInterfaceType;
|
|
FProperties: TObjectList;
|
|
FBaseName: String;
|
|
FBaseItem: TXMLDataBindingInterface;
|
|
|
|
function GetProperties(Index: Integer): TXMLDataBindingProperty;
|
|
function GetPropertyCount: Integer;
|
|
protected
|
|
function GetItemType(): TXMLDataBindingItemType; override;
|
|
|
|
procedure AddProperty(AProperty: TXMLDataBindingProperty);
|
|
public
|
|
constructor Create(ASchemaItem: IXMLSchemaItem; const AName: String);
|
|
destructor Destroy; override;
|
|
|
|
property BaseName: String read FBaseName write FBaseName;
|
|
property BaseItem: TXMLDataBindingInterface read FBaseItem write FBaseItem;
|
|
|
|
property InterfaceType: TXMLDataBindingInterfaceType read FInterfaceType;
|
|
|
|
property PropertyCount: Integer read GetPropertyCount;
|
|
property Properties[Index: Integer]: TXMLDataBindingProperty read GetProperties;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingCollection = class(TXMLDataBindingItem)
|
|
private
|
|
FCollectionItem: TXMLDataBindingProperty;
|
|
|
|
function GetActualCollectionItem(): TXMLDataBindingItem;
|
|
function GetCollectionItemName(): String;
|
|
function GetCollectionItemTranslatedName(): String;
|
|
procedure SetCollectionItem(const Value: TXMLDataBindingProperty);
|
|
protected
|
|
function GetItemType(): TXMLDataBindingItemType; override;
|
|
public
|
|
property CollectionItem: TXMLDataBindingProperty read FCollectionItem;
|
|
property CollectionItemName: String read GetCollectionItemName;
|
|
property CollectionItemTranslatedName: String read GetCollectionItemTranslatedName;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingEnumerationMember = class(TXMLDataBindingItem)
|
|
private
|
|
FEnumeration: TXMLDataBindingEnumeration;
|
|
protected
|
|
function GetItemType(): TXMLDataBindingItemType; override;
|
|
public
|
|
constructor Create(AEnumeration: TXMLDataBindingEnumeration; const AName: String);
|
|
|
|
property Enumeration: TXMLDataBindingEnumeration read FEnumeration;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingEnumeration = class(TXMLDataBindingItem)
|
|
private
|
|
FDataType: IXMLTypeDef;
|
|
FMembers: TObjectList;
|
|
|
|
function GetMemberCount(): Integer;
|
|
function GetMembers(Index: Integer): TXMLDataBindingEnumerationMember;
|
|
protected
|
|
function GetItemType(): TXMLDataBindingItemType; override;
|
|
public
|
|
constructor Create(ASchemaItem: IXMLSchemaItem; ADataType: IXMLTypeDef; const AName: String);
|
|
destructor Destroy(); override;
|
|
|
|
property DataType: IXMLTypeDef read FDataType;
|
|
property MemberCount: Integer read GetMemberCount;
|
|
property Members[Index: Integer]: TXMLDataBindingEnumerationMember read GetMembers;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingProperty = class(TXMLDataBindingItem)
|
|
private
|
|
FIsOptional: Boolean;
|
|
protected
|
|
function GetIsReadOnly(): Boolean; virtual; abstract;
|
|
|
|
function GetItemType(): TXMLDataBindingItemType; override;
|
|
function GetPropertyType(): TXMLDataBindingPropertyType; virtual; abstract;
|
|
public
|
|
property IsOptional: Boolean read FIsOptional write FIsOptional;
|
|
property IsReadOnly: Boolean read GetIsReadOnly;
|
|
property PropertyType: TXMLDataBindingPropertyType read GetPropertyType;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingSimpleProperty = class(TXMLDataBindingProperty)
|
|
private
|
|
FDataType: IXMLTypeDef;
|
|
protected
|
|
function GetIsReadOnly(): Boolean; override;
|
|
function GetPropertyType(): TXMLDataBindingPropertyType; override;
|
|
public
|
|
constructor Create(ASchemaItem: IXMLSchemaItem; const AName: String; ADataType: IXMLTypeDef);
|
|
|
|
property DataType: IXMLTypeDef read FDataType;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingItemProperty = class(TXMLDataBindingProperty)
|
|
private
|
|
FItem: TXMLDataBindingItem;
|
|
|
|
function GetItem(): TXMLDataBindingItem;
|
|
protected
|
|
function GetIsReadOnly(): Boolean; override;
|
|
function GetPropertyType(): TXMLDataBindingPropertyType; override;
|
|
public
|
|
constructor Create(ASchemaItem: IXMLSchemaItem; const AName: String; AItem: TXMLDataBindingItem);
|
|
|
|
property Item: TXMLDataBindingItem read GetItem;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingForwardItem = class(TXMLDataBindingItem)
|
|
private
|
|
FItem: TXMLDataBindingItem;
|
|
FInterfaceType: TXMLDataBindingInterfaceType;
|
|
protected
|
|
function GetItemType(): TXMLDataBindingItemType; override;
|
|
public
|
|
constructor Create(ASchemaItem: IXMLSchemaItem; const AName: String; AInterfaceType: TXMLDataBindingInterfaceType);
|
|
|
|
property InterfaceType: TXMLDataBindingInterfaceType read FInterfaceType;
|
|
property Item: TXMLDataBindingItem read FItem write FItem;
|
|
end;
|
|
|
|
|
|
TXMLDataBindingComplexTypeElementItem = class(TXMLDataBindingItem)
|
|
private
|
|
FItem: TXMLDataBindingItem;
|
|
protected
|
|
function GetItemType(): TXMLDataBindingItemType; override;
|
|
public
|
|
property Item: TXMLDataBindingItem read FItem write FItem;
|
|
end;
|
|
|
|
|
|
implementation
|
|
uses
|
|
SysUtils,
|
|
Windows,
|
|
XMLDoc,
|
|
XMLIntf,
|
|
XMLSchemaTags,
|
|
|
|
X2UtHashes;
|
|
|
|
|
|
const
|
|
MaxOccursUnbounded = 'unbounded';
|
|
CollectionPostfix = 'List';
|
|
|
|
|
|
|
|
function GetInterfaceType(ASchemaItem: IXMLSchemaItem): TXMLDataBindingInterfaceType;
|
|
begin
|
|
if Supports(ASchemaItem, IXMLComplexTypeDef) then
|
|
Result := ifComplexType
|
|
else
|
|
Result := ifElement;
|
|
end;
|
|
|
|
|
|
function GetActualItem(AItem: TXMLDataBindingItem): TXMLDataBindingItem;
|
|
begin
|
|
Result := AItem;
|
|
|
|
while Assigned(Result) do
|
|
begin
|
|
case Result.ItemType of
|
|
itForward:
|
|
Result := TXMLDataBindingForwardItem(Result).Item;
|
|
|
|
itComplexTypeElement:
|
|
Result := TXMLDataBindingComplexTypeElementItem(Result).Item;
|
|
else
|
|
break;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingGenerator }
|
|
constructor TXMLDataBindingGenerator.Create();
|
|
begin
|
|
inherited;
|
|
|
|
FIncludePaths := TStringList.Create();
|
|
FSchemas := TObjectList.Create(True);
|
|
|
|
with TStringList(FIncludePaths) do
|
|
begin
|
|
CaseSensitive := False;
|
|
Duplicates := dupIgnore;
|
|
end;
|
|
end;
|
|
|
|
|
|
destructor TXMLDataBindingGenerator.Destroy();
|
|
begin
|
|
FreeAndNil(FSchemas);
|
|
FreeAndNil(FIncludePaths);
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.Execute(const AStream: TStream; const ASchemaName: String);
|
|
var
|
|
schemaIndex: Integer;
|
|
|
|
begin
|
|
FSchemas.Clear();
|
|
LoadSchema(AStream, ASchemaName);
|
|
|
|
if SchemaCount > 0 then
|
|
begin
|
|
{ Map schema elements to objects }
|
|
for schemaIndex := 0 to Pred(SchemaCount) do
|
|
GenerateSchemaObjects(Schemas[schemaIndex], (schemaIndex = 0));
|
|
|
|
|
|
{ Process unresolved references
|
|
- some references can't be resolved the first time (especially
|
|
ComplexTypeElement references). Fix this workaround some time. }
|
|
for schemaIndex := 0 to Pred(SchemaCount) do
|
|
ResolveSchema(Schemas[schemaIndex]);
|
|
|
|
for schemaIndex := 0 to Pred(SchemaCount) do
|
|
ResolveSchema(Schemas[schemaIndex]);
|
|
|
|
|
|
{ Collapse collections }
|
|
|
|
|
|
{ Resolve naming conflicts }
|
|
ResolveNameConflicts();
|
|
|
|
|
|
{ Perform output-specific translations }
|
|
for schemaIndex := 0 to Pred(SchemaCount) do
|
|
TranslateSchema(Schemas[schemaIndex]);
|
|
|
|
|
|
{ Output }
|
|
GenerateDataBinding();
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.Execute(const AFileName: String);
|
|
var
|
|
currentDir: String;
|
|
fileStream: TFileStream;
|
|
|
|
begin
|
|
currentDir := GetCurrentDir();
|
|
try
|
|
ChDir(ExtractFilePath(AFileName));
|
|
|
|
fileStream := TFileStream.Create(AFileName, fmOpenRead or fmShareDenyNone);
|
|
try
|
|
FSourceFileName := AFileName;
|
|
IncludePaths.Add(ExtractFilePath(AFileName));
|
|
|
|
Execute(fileStream, ChangeFileExt(ExtractFileName(AFileName), ''));
|
|
finally
|
|
FreeAndNil(fileStream);
|
|
end;
|
|
finally
|
|
ChDir(currentDir);
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
function TXMLDataBindingGenerator.LoadSchema(const AStream: TStream; const ASchemaName: String): TXMLDataBindingSchema;
|
|
|
|
procedure HandleDocRefs(const ADocRefs: IXMLSchemaDocRefs; ASchema: TXMLDataBindingSchema);
|
|
var
|
|
location: String;
|
|
schemaName: String;
|
|
refSchema: TXMLDataBindingSchema;
|
|
refIndex: Integer;
|
|
refStream: TStream;
|
|
|
|
begin
|
|
for refIndex := 0 to Pred(ADocRefs.Count) do
|
|
begin
|
|
location := ADocRefs[refIndex].SchemaLocation;
|
|
schemaName := ChangeFileExt(ExtractFileName(location), '');
|
|
refSchema := FindSchema(schemaName);
|
|
|
|
if not Assigned(refSchema) then
|
|
begin
|
|
refStream := GetSchemaData(location);
|
|
|
|
if Assigned(refStream) then
|
|
try
|
|
refSchema := LoadSchema(refStream, schemaName);
|
|
finally
|
|
FreeAndNil(refStream);
|
|
end;
|
|
end;
|
|
|
|
if Assigned(refSchema) then
|
|
ASchema.AddInclude(refSchema);
|
|
end;
|
|
end;
|
|
|
|
|
|
var
|
|
schemaDoc: IXMLSchemaDoc;
|
|
schemaDef: IXMLSchemaDef;
|
|
|
|
begin
|
|
schemaDoc := TXMLSchemaDoc.Create(nil);
|
|
schemaDoc.LoadFromStream(AStream);
|
|
schemaDef := schemaDoc.SchemaDef;
|
|
|
|
Result := TXMLDataBindingSchema.Create();
|
|
Result.SchemaDef := schemaDef;
|
|
Result.SchemaName := ASchemaName;
|
|
FSchemas.Add(Result);
|
|
|
|
{ Handle imports / includes }
|
|
HandleDocRefs(schemaDef.SchemaImports, Result);
|
|
HandleDocRefs(schemaDef.SchemaIncludes, Result);
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.GetSchemaData(const ALocation: String): TStream;
|
|
var
|
|
includeIndex: Integer;
|
|
includePath: String;
|
|
|
|
begin
|
|
Result := nil;
|
|
|
|
// #ToDo3 (MvR) 31-1-2007: support more locations than just a filename ?
|
|
|
|
for includeIndex := 0 to Pred(IncludePaths.Count) do
|
|
begin
|
|
includePath := IncludeTrailingPathDelimiter(IncludePaths[includeIndex]);
|
|
|
|
if FileExists(includePath + ALocation) then
|
|
begin
|
|
Result := TFileStream.Create(includePath + ALocation, fmOpenRead or fmShareDenyNone);
|
|
break;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.FindSchema(const ALocation: String): TXMLDataBindingSchema;
|
|
var
|
|
schemaIndex: Integer;
|
|
|
|
begin
|
|
Result := nil;
|
|
|
|
for schemaIndex := 0 to Pred(SchemaCount) do
|
|
if Schemas[schemaIndex].SchemaName = ALocation then
|
|
begin
|
|
Result := Schemas[schemaIndex];
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.GenerateSchemaObjects(ASchema: TXMLDataBindingSchema; ARootDocument: Boolean);
|
|
var
|
|
includeIndex: Integer;
|
|
|
|
begin
|
|
if ASchema.ItemsGenerated then
|
|
exit;
|
|
|
|
ASchema.ItemsGenerated := True;
|
|
|
|
{ First generate the objects for all includes and imports, so we can get
|
|
proper references. }
|
|
for includeIndex := 0 to Pred(ASchema.IncludeCount) do
|
|
GenerateSchemaObjects(ASchema.Includes[includeIndex], False);
|
|
|
|
|
|
GenerateElementObjects(ASchema, ARootDocument);
|
|
GenerateComplexTypeObjects(ASchema);
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.GenerateElementObjects(ASchema: TXMLDataBindingSchema; ARootDocument: Boolean);
|
|
var
|
|
schemaDef: IXMLSchemaDef;
|
|
elementIndex: Integer;
|
|
item: TXMLDataBindingItem;
|
|
|
|
begin
|
|
schemaDef := ASchema.SchemaDef;
|
|
|
|
for elementIndex := 0 to Pred(schemaDef.ElementDefs.Count) do
|
|
begin
|
|
item := ProcessElement(ASchema, schemaDef.ElementDefs[elementIndex]);
|
|
|
|
if Assigned(item) and ARootDocument then
|
|
item.DocumentElement := True;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.GenerateComplexTypeObjects(ASchema: TXMLDataBindingSchema);
|
|
var
|
|
schemaDef: IXMLSchemaDef;
|
|
complexTypeIndex: Integer;
|
|
complexType: IXMLComplexTypeDef;
|
|
interfaceItem: TXMLDataBindingInterface;
|
|
elementIndex: Integer;
|
|
|
|
begin
|
|
schemaDef := ASchema.SchemaDef;
|
|
|
|
for complexTypeIndex := 0 to Pred(schemaDef.ComplexTypes.Count) do
|
|
begin
|
|
complexType := schemaDef.ComplexTypes[complexTypeIndex];
|
|
interfaceItem := TXMLDataBindingInterface.Create(complexType, complexType.Name);
|
|
ASchema.AddItem(interfaceItem);
|
|
|
|
for elementIndex := 0 to Pred(complexType.ElementDefs.Count) do
|
|
ProcessChildElement(ASchema, complexType.ElementDefs[elementIndex], interfaceItem);
|
|
end;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.ProcessElement(ASchema: TXMLDataBindingSchema; AElement: IXMLElementDef): TXMLDataBindingItem;
|
|
var
|
|
elementIndex: Integer;
|
|
enumerationObject: TXMLDataBindingEnumeration;
|
|
interfaceObject: TXMLDataBindingInterface;
|
|
complexTypeElement: TXMLDataBindingComplexTypeElementItem;
|
|
|
|
begin
|
|
Result := nil;
|
|
interfaceObject := nil;
|
|
|
|
if Assigned(AElement.Ref) then
|
|
begin
|
|
{ Find reference. If not found, mark as "resolve later". }
|
|
Result := FindInterface(ASchema, AElement.Ref.Name, ifElement);
|
|
|
|
if not Assigned(Result) then
|
|
begin
|
|
Result := TXMLDataBindingForwardItem.Create(AElement, AElement.Ref.Name, ifElement);
|
|
ASchema.AddItem(Result);
|
|
end;
|
|
end else
|
|
begin
|
|
if (not AElement.DataType.IsAnonymous) and
|
|
AElement.DataType.IsComplex then
|
|
begin
|
|
{ Find data type. If not found, mark as "resolve later". }
|
|
Result := FindInterface(ASchema, AElement.DataTypeName, ifComplexType);
|
|
|
|
if not Assigned(Result) then
|
|
begin
|
|
Result := TXMLDataBindingForwardItem.Create(AElement, AElement.DataTypeName, ifComplexType);
|
|
ASchema.AddItem(Result);
|
|
end;
|
|
|
|
if AElement.IsGlobal then
|
|
begin
|
|
{ The element is global, but only references a complex type. Keep track
|
|
to properly resolve references to the element. }
|
|
complexTypeElement := TXMLDataBindingComplexTypeElementItem.Create(AElement, AElement.Name);
|
|
complexTypeElement.Item := Result;
|
|
ASchema.AddItem(complexTypeElement);
|
|
end;
|
|
end;
|
|
|
|
if not Assigned(Result) then
|
|
begin
|
|
if AElement.DataType.Enumerations.Count > 0 then
|
|
begin
|
|
{ Enumeration }
|
|
enumerationObject := TXMLDataBindingEnumeration.Create(AElement, AElement.DataType, AElement.Name);
|
|
ASchema.AddItem(enumerationObject);
|
|
Result := enumerationObject;
|
|
end else if AElement.DataType.IsComplex then
|
|
begin
|
|
{ Interface }
|
|
interfaceObject := TXMLDataBindingInterface.Create(AElement, AElement.Name);
|
|
if Assigned(AElement.DataType.BaseType) then
|
|
interfaceObject.BaseName := AElement.DataType.BaseTypeName;
|
|
|
|
ASchema.AddItem(interfaceObject);
|
|
Result := interfaceObject;
|
|
end;
|
|
|
|
|
|
if Assigned(interfaceObject) then
|
|
for elementIndex := 0 to Pred(AElement.ChildElements.Count) do
|
|
ProcessChildElement(ASchema, AElement.ChildElements[elementIndex], interfaceObject);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.ProcessChildElement(ASchema: TXMLDataBindingSchema; AElement: IXMLElementDef; AInterface: TXMLDataBindingInterface);
|
|
var
|
|
collectionObject: TXMLDataBindingCollection;
|
|
propertyType: TXMLDataBindingItem;
|
|
propertyItem: TXMLDataBindingProperty;
|
|
|
|
begin
|
|
collectionObject := nil;
|
|
|
|
|
|
if Assigned(AInterface) then
|
|
begin
|
|
if (AElement.MaxOccurs = MaxOccursUnbounded) or
|
|
(AElement.MaxOccurs > 1) then
|
|
begin
|
|
{ Collection }
|
|
collectionObject := FindCollection(ASchema, AElement.Name);
|
|
|
|
if not Assigned(collectionObject) then
|
|
begin
|
|
collectionObject := TXMLDataBindingCollection.Create(AElement, AElement.Name + CollectionPostfix);
|
|
ASchema.AddItem(collectionObject);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
propertyType := ProcessElement(ASchema, AElement);
|
|
|
|
if Assigned(collectionObject) then
|
|
begin
|
|
{ Create intermediate object for collections }
|
|
if Assigned(propertyType) then
|
|
propertyItem := TXMLDataBindingItemProperty.Create(AElement,
|
|
propertyType.Name,
|
|
propertyType)
|
|
else
|
|
propertyItem := TXMLDataBindingSimpleProperty.Create(AElement,
|
|
AElement.Name,
|
|
AElement.DataType);
|
|
|
|
|
|
collectionObject.SetCollectionItem(propertyItem);
|
|
propertyType := collectionObject;
|
|
end;
|
|
|
|
|
|
if Assigned(AInterface) then
|
|
begin
|
|
if Assigned(propertyType) then
|
|
propertyItem := TXMLDataBindingItemProperty.Create(AElement,
|
|
AElement.Name,
|
|
propertyType)
|
|
else
|
|
propertyItem := TXMLDataBindingSimpleProperty.Create(AElement,
|
|
AElement.Name,
|
|
AElement.DataType);
|
|
|
|
propertyItem.IsOptional := (AElement.MinOccurs = 0);
|
|
AInterface.AddProperty(propertyItem);
|
|
end;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.IterateSchemaItems(ASchema: TXMLDataBindingSchema; AIterateProc: TXMLDataBindingIterateItemsProc; AData: Pointer): TXMLDataBindingItem;
|
|
var
|
|
abort: Boolean;
|
|
itemIndex: Integer;
|
|
schemaItem: TXMLDataBindingItem;
|
|
includeIndex: Integer;
|
|
|
|
begin
|
|
Result := nil;
|
|
abort := False;
|
|
|
|
for itemIndex := 0 to Pred(ASchema.ItemCount) do
|
|
begin
|
|
schemaItem := ASchema.Items[itemIndex];
|
|
|
|
AIterateProc(schemaItem, AData, abort);
|
|
if abort then
|
|
begin
|
|
Result := schemaItem;
|
|
Break;
|
|
end;
|
|
end;
|
|
|
|
if not Assigned(Result) then
|
|
begin
|
|
for includeIndex := 0 to Pred(ASchema.IncludeCount) do
|
|
begin
|
|
Result := IterateSchemaItems(ASchema.Includes[includeIndex], AIterateProc, AData);
|
|
if Assigned(Result) then
|
|
break;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
type
|
|
PFindInterfaceInfo = ^TFindInterfaceInfo;
|
|
TFindInterfaceInfo = record
|
|
InterfaceType: TXMLDataBindingInterfaceType;
|
|
Name: String;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.FindInterfaceProc(AItem: TXMLDataBindingItem; AData: Pointer; var AAbort: Boolean);
|
|
var
|
|
findInfo: PFindInterfaceInfo;
|
|
|
|
begin
|
|
AAbort := False;
|
|
findInfo := PFindInterfaceInfo(AData);
|
|
|
|
|
|
if AItem.Name = findInfo^.Name then
|
|
begin
|
|
case AItem.ItemType of
|
|
itInterface:
|
|
AAbort := (TXMLDataBindingInterface(AItem).InterfaceType = findInfo^.InterfaceType);
|
|
|
|
itComplexTypeElement:
|
|
AAbort := (findInfo^.InterfaceType = ifElement);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.FindInterface(ASchema: TXMLDataBindingSchema; const AName: String; AType: TXMLDataBindingInterfaceType): TXMLDataBindingInterface;
|
|
var
|
|
findInfo: TFindInterfaceInfo;
|
|
|
|
begin
|
|
findInfo.InterfaceType := AType;
|
|
findInfo.Name := AName;
|
|
Result := TXMLDataBindingInterface(GetActualItem(IterateSchemaItems(ASchema, FindInterfaceProc, @findInfo)));
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.FindEnumerationProc(AItem: TXMLDataBindingItem; AData: Pointer; var AAbort: Boolean);
|
|
begin
|
|
AAbort := (AItem.ItemType = itEnumeration) and
|
|
(AItem.Name = PChar(AData));
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.FindEnumeration(ASchema: TXMLDataBindingSchema; const AName: String): TXMLDataBindingEnumeration;
|
|
begin
|
|
Result := TXMLDataBindingEnumeration(IterateSchemaItems(ASchema, FindEnumerationProc, PChar(AName)));
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.FindCollectionProc(AItem: TXMLDataBindingItem; AData: Pointer; var AAbort: Boolean);
|
|
var
|
|
collection: TXMLDataBindingCollection;
|
|
|
|
begin
|
|
if AItem.ItemType = itCollection then
|
|
begin
|
|
collection := TXMLDataBindingCollection(AItem);
|
|
AAbort := Assigned(collection.CollectionItem) and
|
|
(collection.CollectionItem.Name = PChar(AData));
|
|
end;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.FindCollection(ASchema: TXMLDataBindingSchema; const AName: String): TXMLDataBindingCollection;
|
|
begin
|
|
Result := TXMLDataBindingCollection(IterateSchemaItems(ASchema, FindCollectionProc, PChar(AName)));
|
|
end;
|
|
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.ResolveSchema(ASchema: TXMLDataBindingSchema);
|
|
var
|
|
itemIndex: Integer;
|
|
item: TXMLDataBindingItem;
|
|
interfaceItem: TXMLDataBindingInterface;
|
|
|
|
begin
|
|
for itemIndex := 0 to Pred(ASchema.ItemCount) do
|
|
begin
|
|
item := ASchema.Items[itemIndex];
|
|
|
|
case item.ItemType of
|
|
itInterface:
|
|
begin
|
|
{ Resolve base interface }
|
|
interfaceItem := TXMLDataBindingInterface(item);
|
|
|
|
if (not Assigned(interfaceItem.BaseItem)) and
|
|
(Length(interfaceItem.BaseName) > 0) then
|
|
interfaceItem.BaseItem := FindInterface(ASchema, interfaceItem.BaseName, ifComplexType);
|
|
end;
|
|
|
|
itForward:
|
|
ResolveItem(ASchema, item);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.ResolveItem(ASchema: TXMLDataBindingSchema; AItem: TXMLDataBindingItem);
|
|
var
|
|
forwardItem: TXMLDataBindingForwardItem;
|
|
referenceItem: TXMLDataBindingItem;
|
|
|
|
begin
|
|
if (not Assigned(AItem)) or (AItem.ItemType <> itForward) then
|
|
Exit;
|
|
|
|
{ Resolve forwarded item }
|
|
forwardItem := TXMLDataBindingForwardItem(AItem);
|
|
if not Assigned(forwardItem.Item) then
|
|
begin
|
|
referenceItem := FindInterface(ASchema, AItem.Name, forwardItem.InterfaceType);
|
|
|
|
if (not Assigned(referenceItem)) and
|
|
(forwardItem.InterfaceType = ifElement) then
|
|
referenceItem := FindEnumeration(ASchema, AItem.Name);
|
|
|
|
if Assigned(referenceItem) then
|
|
forwardItem.Item := referenceItem;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.ResolveNameConflicts();
|
|
var
|
|
itemNames: TX2SOHash;
|
|
|
|
|
|
procedure AddItem(AItem: TXMLDataBindingItem);
|
|
var
|
|
hashName: String;
|
|
items: TObjectList;
|
|
|
|
begin
|
|
{ Collections use the same Name as their items, differentiate
|
|
between them while determining conflicts. }
|
|
hashName := AItem.Name;
|
|
if AItem.ItemType = itCollection then
|
|
hashName := hashName + #1;
|
|
|
|
if not itemNames.Exists(hashName) then
|
|
begin
|
|
items := TObjectList.Create(False);
|
|
itemNames[hashName] := items;
|
|
end else
|
|
items := TObjectList(itemNames[hashName]);
|
|
|
|
items.Add(AItem);
|
|
end;
|
|
|
|
|
|
function ResolveItemNameConflict(AItem: TXMLDataBindingItem; ADepth: Integer; out ANewName: String): Boolean;
|
|
var
|
|
currentDepth: Integer;
|
|
parentNode: IXMLNode;
|
|
schemaItem: IXMLSchemaItem;
|
|
|
|
begin
|
|
Result := False;
|
|
currentDepth := 0;
|
|
parentNode := AItem.SchemaItem;
|
|
ANewName := AItem.Name;
|
|
|
|
while Assigned(parentNode) do
|
|
begin
|
|
parentNode := parentNode.ParentNode;
|
|
|
|
if Assigned(parentNode) and
|
|
Supports(parentNode, IXMLSchemaItem, schemaItem) and
|
|
(Length(schemaItem.Name) > 0) then
|
|
begin
|
|
ANewName := schemaItem.Name + ANewName;
|
|
|
|
Inc(currentDepth);
|
|
if currentDepth = ADepth then
|
|
begin
|
|
Result := True;
|
|
break;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
var
|
|
schemaIndex: Integer;
|
|
schema: TXMLDataBindingSchema;
|
|
itemIndex: Integer;
|
|
items: TObjectList;
|
|
item: TXMLDataBindingItem;
|
|
depth: Integer;
|
|
newName: String;
|
|
resolved: Boolean;
|
|
|
|
begin
|
|
itemNames := TX2SOHash.Create(True);
|
|
try
|
|
{ Gather names }
|
|
for schemaIndex := 0 to Pred(SchemaCount) do
|
|
begin
|
|
schema := Schemas[schemaIndex];
|
|
|
|
for itemIndex := 0 to Pred(schema.ItemCount) do
|
|
begin
|
|
item := schema.Items[itemIndex];
|
|
|
|
if item.ItemType in [itInterface, itCollection, itEnumeration] then
|
|
AddItem(item);
|
|
end;
|
|
end;
|
|
|
|
|
|
{ Find conflicts }
|
|
itemNames.First();
|
|
|
|
while itemNames.Next() do
|
|
begin
|
|
items := TObjectList(itemNames.CurrentValue);
|
|
|
|
if items.Count > 1 then
|
|
begin
|
|
{ Attempt to rename items }
|
|
for itemIndex := Pred(items.Count) downto 0 do
|
|
begin
|
|
item := TXMLDataBindingItem(items[itemIndex]);
|
|
newName := item.Name;
|
|
resolved := False;
|
|
depth := 1;
|
|
|
|
while ResolveItemNameConflict(item, depth, newName) do
|
|
begin
|
|
if not itemNames.Exists(newName) then
|
|
begin
|
|
resolved := True;
|
|
break;
|
|
end else
|
|
Inc(depth);
|
|
end;
|
|
|
|
if resolved then
|
|
begin
|
|
items.Delete(itemIndex);
|
|
|
|
item.SetName(newName);
|
|
AddItem(item);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
finally
|
|
FreeAndNil(itemNames);
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.TranslateSchema(ASchema: TXMLDataBindingSchema);
|
|
var
|
|
itemIndex: Integer;
|
|
|
|
begin
|
|
for itemIndex := 0 to Pred(ASchema.ItemCount) do
|
|
TranslateItem(ASchema.Items[itemIndex]);
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingGenerator.TranslateItem(AItem: TXMLDataBindingItem);
|
|
var
|
|
interfaceItem: TXMLDataBindingInterface;
|
|
propertyIndex: Integer;
|
|
enumerationItem: TXMLDataBindingEnumeration;
|
|
memberIndex: Integer;
|
|
|
|
begin
|
|
AItem.SetTranslatedName(TranslateItemName(AItem));
|
|
|
|
case AItem.ItemType of
|
|
itInterface:
|
|
begin
|
|
interfaceItem := TXMLDataBindingInterface(AItem);
|
|
|
|
for propertyIndex := 0 to Pred(interfaceItem.PropertyCount) do
|
|
TranslateItem(interfaceItem.Properties[propertyIndex]);
|
|
end;
|
|
itEnumeration:
|
|
begin
|
|
enumerationItem := TXMLDataBindingEnumeration(AItem);
|
|
|
|
for memberIndex := 0 to Pred(enumerationItem.MemberCount) do
|
|
TranslateItem(enumerationItem.Members[memberIndex]);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.TranslateItemName(AItem: TXMLDataBindingItem): String;
|
|
begin
|
|
Result := AItem.Name;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.GetSchemaCount(): Integer;
|
|
begin
|
|
Result := FSchemas.Count;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingGenerator.GetSchemas(Index: Integer): TXMLDataBindingSchema;
|
|
begin
|
|
Result := TXMLDataBindingSchema(FSchemas[Index]);
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingSchema }
|
|
constructor TXMLDataBindingSchema.Create();
|
|
begin
|
|
inherited;
|
|
|
|
FIncludes := TObjectList.Create(False);
|
|
FItems := TObjectList.Create(True);
|
|
end;
|
|
|
|
|
|
destructor TXMLDataBindingSchema.Destroy();
|
|
begin
|
|
FreeAndNil(FItems);
|
|
FreeAndNil(FIncludes);
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingSchema.AddInclude(ASchema: TXMLDataBindingSchema);
|
|
begin
|
|
if FIncludes.IndexOf(ASchema) = -1 then
|
|
FIncludes.Add(ASchema);
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingSchema.AddItem(AItem: TXMLDataBindingItem);
|
|
begin
|
|
if FItems.IndexOf(AItem) = -1 then
|
|
FItems.Add(AItem);
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingSchema.GetIncludeCount(): Integer;
|
|
begin
|
|
Result := FIncludes.Count;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingSchema.GetIncludes(Index: Integer): TXMLDataBindingSchema;
|
|
begin
|
|
Result := TXMLDataBindingSchema(FIncludes[Index]);
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingSchema.GetItemCount(): Integer;
|
|
begin
|
|
Result := FItems.Count;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingSchema.GetItems(Index: Integer): TXMLDataBindingItem;
|
|
begin
|
|
Result := TXMLDataBindingItem(FItems[Index]);
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingItem }
|
|
constructor TXMLDataBindingItem.Create(ASchemaItem: IXMLSchemaItem; const AName: String);
|
|
begin
|
|
inherited Create();
|
|
|
|
FName := AName;
|
|
FSchemaItem := ASchemaItem;
|
|
FTranslatedName := AName;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingItem.GetDocumentation(): String;
|
|
var
|
|
documentationIndex: Integer;
|
|
|
|
begin
|
|
Result := '';
|
|
if HasDocumentation then
|
|
begin
|
|
for documentationIndex := 0 to Pred(SchemaItem.Documentation.Count) do
|
|
Result := Result + SchemaItem.Documentation[documentationIndex].Text + #13#10;
|
|
|
|
Result := Trim(Result);
|
|
end;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingItem.GetHasDocumentation: Boolean;
|
|
begin
|
|
Result := Assigned(SchemaItem) and
|
|
(SchemaItem.Documentation.Count > 0);
|
|
end;
|
|
|
|
procedure TXMLDataBindingItem.SetName(const Value: String);
|
|
begin
|
|
FName := Value;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingItem.SetTranslatedName(const Value: string);
|
|
begin
|
|
FTranslatedName := Value;
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingInterface }
|
|
constructor TXMLDataBindingInterface.Create(ASchemaItem: IXMLSchemaItem; const AName: String);
|
|
begin
|
|
inherited Create(ASchemaItem, AName);
|
|
|
|
FProperties := TObjectList.Create(True);
|
|
FInterfaceType := GetInterfaceType(SchemaItem);
|
|
end;
|
|
|
|
|
|
destructor TXMLDataBindingInterface.Destroy;
|
|
begin
|
|
FreeAndNil(FProperties);
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingInterface.AddProperty(AProperty: TXMLDataBindingProperty);
|
|
begin
|
|
FProperties.Add(AProperty);
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingInterface.GetItemType(): TXMLDataBindingItemType;
|
|
begin
|
|
Result := itInterface;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingInterface.GetPropertyCount(): Integer;
|
|
begin
|
|
Result := FProperties.Count;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingInterface.GetProperties(Index: Integer): TXMLDataBindingProperty;
|
|
begin
|
|
Result := TXMLDataBindingProperty(FProperties[Index]);
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingCollection }
|
|
function TXMLDataBindingCollection.GetItemType(): TXMLDataBindingItemType;
|
|
begin
|
|
Result := itCollection;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingCollection.GetActualCollectionItem(): TXMLDataBindingItem;
|
|
begin
|
|
Result := nil;
|
|
|
|
if Assigned(CollectionItem) then
|
|
begin
|
|
case CollectionItem.PropertyType of
|
|
ptSimple: Result := CollectionItem;
|
|
ptItem: Result := TXMLDataBindingItemProperty(CollectionItem).Item;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TXMLDataBindingCollection.GetCollectionItemName(): String;
|
|
var
|
|
item: TXMLDataBindingItem;
|
|
|
|
begin
|
|
Result := '';
|
|
item := GetActualCollectionItem();
|
|
if Assigned(item) then
|
|
Result := item.Name;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingCollection.GetCollectionItemTranslatedName(): String;
|
|
var
|
|
item: TXMLDataBindingItem;
|
|
|
|
begin
|
|
Result := '';
|
|
item := GetActualCollectionItem();
|
|
if Assigned(item) then
|
|
Result := item.Name;
|
|
end;
|
|
|
|
|
|
procedure TXMLDataBindingCollection.SetCollectionItem(const Value: TXMLDataBindingProperty);
|
|
begin
|
|
FCollectionItem := Value;
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingEnumerationMember }
|
|
constructor TXMLDataBindingEnumerationMember.Create(AEnumeration: TXMLDataBindingEnumeration; const AName: String);
|
|
begin
|
|
inherited Create(nil, AName);
|
|
|
|
FEnumeration := AEnumeration;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingEnumerationMember.GetItemType(): TXMLDataBindingItemType;
|
|
begin
|
|
Result := itEnumerationMember;
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingEnumeration }
|
|
constructor TXMLDataBindingEnumeration.Create(ASchemaItem: IXMLSchemaItem; ADataType: IXMLTypeDef; const AName: String);
|
|
var
|
|
memberIndex: Integer;
|
|
|
|
begin
|
|
inherited Create(ASchemaItem, AName);
|
|
|
|
FDataType := ADataType;
|
|
FMembers := TObjectList.Create();
|
|
|
|
for memberIndex := 0 to Pred(ADataType.Enumerations.Count) do
|
|
FMembers.Add(TXMLDataBindingEnumerationMember.Create(Self, ADataType.Enumerations.Items[memberIndex].Value));
|
|
end;
|
|
|
|
|
|
destructor TXMLDataBindingEnumeration.Destroy();
|
|
begin
|
|
FreeAndNil(FMembers);
|
|
|
|
inherited;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingEnumeration.GetItemType(): TXMLDataBindingItemType;
|
|
begin
|
|
Result := itEnumeration;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingEnumeration.GetMemberCount(): Integer;
|
|
begin
|
|
Result := FMembers.Count;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingEnumeration.GetMembers(Index: Integer): TXMLDataBindingEnumerationMember;
|
|
begin
|
|
Result := TXMLDataBindingEnumerationMember(FMembers[Index]);
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingProperty }
|
|
function TXMLDataBindingProperty.GetItemType(): TXMLDataBindingItemType;
|
|
begin
|
|
Result := itProperty;
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingSimpleProperty }
|
|
constructor TXMLDataBindingSimpleProperty.Create(ASchemaItem: IXMLSchemaItem; const AName: String; ADataType: IXMLTypeDef);
|
|
begin
|
|
inherited Create(ASchemaItem, AName);
|
|
|
|
FDataType := ADataType;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingSimpleProperty.GetIsReadOnly(): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingSimpleProperty.GetPropertyType(): TXMLDataBindingPropertyType;
|
|
begin
|
|
Result := ptSimple;
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingItemProperty }
|
|
constructor TXMLDataBindingItemProperty.Create(ASchemaItem: IXMLSchemaItem; const AName: String; AItem: TXMLDataBindingItem);
|
|
begin
|
|
inherited Create(ASchemaItem, AName);
|
|
|
|
FItem := AItem;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingItemProperty.GetIsReadOnly(): Boolean;
|
|
begin
|
|
Result := Assigned(Item) and (Item.ItemType <> itEnumeration);
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingItemProperty.GetPropertyType(): TXMLDataBindingPropertyType;
|
|
begin
|
|
Result := ptItem;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingItemProperty.GetItem(): TXMLDataBindingItem;
|
|
begin
|
|
Result := GetActualItem(FItem);
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingForwardItem }
|
|
constructor TXMLDataBindingForwardItem.Create(ASchemaItem: IXMLSchemaItem; const AName: String; AInterfaceType: TXMLDataBindingInterfaceType);
|
|
begin
|
|
inherited Create(ASchemaItem, AName);
|
|
|
|
FInterfaceType := AInterfaceType;
|
|
end;
|
|
|
|
|
|
function TXMLDataBindingForwardItem.GetItemType(): TXMLDataBindingItemType;
|
|
begin
|
|
Result := itForward;
|
|
end;
|
|
|
|
|
|
{ TXMLDataBindingComplexTypeElementItem }
|
|
function TXMLDataBindingComplexTypeElementItem.GetItemType(): TXMLDataBindingItemType;
|
|
begin
|
|
Result := itComplexTypeElement;
|
|
end;
|
|
|
|
end.
|
|
|
|
|
|
|
|
|