delphi2.sct

c#设计模式WithCla

CLASS_USER1
unit CLASS_NAME;

interface
CLASS_USER2
CLASS_USER3
uses SysUtils, Messages, Classes [, BASE_CLASS ] [, ASSOCIATION_ONE_CLASS ][, AGGREGATION_ONE_CLASS ][, ASSOCIATION_MANY_CLASS ][, AGGREGATION_MANY_CLASS ][, INCLUDE_FILE ] ;

type
    T$CLASS_NAME = CLASS_OR_INTERFACE [(T$BASE_CLASS)]

private
SELECT_WHEN ATTRIBUTE_ACCESS == private [COLUMN_TAB(4) F$ATTRIBUTE_NAME : ATTRIBUTE_TYPE ; ]
[COLUMN_TAB(4) ASSOCIATION_ONE_NAME : T$ASSOCIATION_ONE_CLASS ; {1:1 Association Field }]
[COLUMN_TAB(4) AGGREGATION_ONE_NAME : T$AGGREGATION_ONE_CLASS ; {1:1 Aggregation Part Field}]
[COLUMN_TAB(4) ASSOCIATION_MANY_NAME : TList ; {1:Many Association Field} ]
[COLUMN_TAB(4) AGGREGATION_MANY_NAME : TList ; {1:Many Aggregation Part Field} ]

[   procedure Set$AGGREGATION_ONE_CLASS ( a$AGGREGATION_ONE_CLASS : T$AGGREGATION_ONE_CLASS ) ; {Set Accessor Procedure for 1:1 Aggregation}]

[   function Get$AGGREGATION_ONE_CLASS : T$AGGREGATION_ONE_CLASS ; {Get Assessor Function for 1:1 Aggregation} ]

[   procedure Set$AGGREGATION_MANY_CLASS$List ( a$AGGREGATION_MANY_CLASS$List : TList ) ; {Set Accessor Procedure for 1:Many Aggregation}]

[   function Get$AGGREGATION_MANY_CLASS$List : TList ;{Get Assessor Function for 1:Many Association} ]

[   procedure Add$AGGREGATION_MANY_CLASS ( a$AGGREGATION_MANY_CLASS : T$AGGREGATION_MANY_CLASS ) ;]

[   function Get$AGGREGATION_MANY_CLASS ( Index : Integer ) : T$AGGREGATION_MANY_CLASS ;{Get Assessor Function for 1:Many Aggregation}]

[   function Get$AGGREGATION_MANY_CLASS$Count : Integer ;]

[   procedure Remove$AGGREGATION_MANY_CLASS ( a$AGGREGATION_MANY_CLASS : T$AGGREGATION_MANY_CLASS ) ;]

[   procedure RemoveAll$AGGREGATION_MANY_CLASS;]

[  function Contains$AGGREGATION_MANY_CLASS ( a$AGGREGATION_MANY_CLASS : T$AGGREGATION_MANY_CLASS ): Boolean; ]


SELECT_WHEN OPERATION_ACCESS == private LOGICAL_AND OPERATION_IS_PROCEDURE [
    PASCAL_OPERATION_STATIC procedure OPERATION_NAME PASCAL_OPERATION_PARAMETERS_WITH_VAR ; PASCAL_OPERATION_VIRTUAL PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE PASCAL_OPERATION_MESSAGE]

SELECT_WHEN OPERATION_ACCESS == private LOGICAL_AND OPERATION_IS_FUNCTION [
    PASCAL_OPERATION_STATIC function OPERATION_NAME PASCAL_OPERATION_PARAMETERS_PAREN PASCAL_OPERATION_RETURN_TYPE ; PASCAL_OPERATION_VIRTUAL  PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE]

protected
SELECT_WHEN ATTRIBUTE_ACCESS == protected 
[COLUMN_TAB(4) F$ATTRIBUTE_NAME : ATTRIBUTE_TYPE ; ]

SELECT_WHEN OPERATION_ACCESS == protected LOGICAL_AND OPERATION_IS_PROCEDURE [
    PASCAL_OPERATION_STATIC procedure OPERATION_NAME PASCAL_OPERATION_PARAMETERS_WITH_VAR ; PASCAL_OPERATION_VIRTUAL PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE PASCAL_OPERATION_MESSAGE]

SELECT_WHEN OPERATION_ACCESS == protected LOGICAL_AND OPERATION_IS_FUNCTION [
    PASCAL_OPERATION_STATIC function OPERATION_NAME PASCAL_OPERATION_PARAMETERS_PAREN PASCAL_OPERATION_RETURN_TYPE ; PASCAL_OPERATION_VIRTUAL  PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE]

SELECT_WHEN ATTRIBUTE_IS_WRITE_PROPERTY 
[    procedure Set$ATTRIBUTE_NAME ( const a$ATTRIBUTE_NAME : ATTRIBUTE_TYPE ); {Set Accessor Procedure }]

published
SELECT_WHEN ATTRIBUTE_ACCESS == published [COLUMN_TAB(4) F$ATTRIBUTE_NAME : ATTRIBUTE_TYPE ; ] 

SELECT_WHEN OPERATION_ACCESS == published LOGICAL_AND OPERATION_IS_PROCEDURE [
    PASCAL_OPERATION_STATIC procedure OPERATION_NAME PASCAL_OPERATION_PARAMETERS_WITH_VAR ; PASCAL_OPERATION_VIRTUAL PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE PASCAL_OPERATION_MESSAGE]

SELECT_WHEN OPERATION_ACCESS == published LOGICAL_AND OPERATION_IS_FUNCTION [
    PASCAL_OPERATION_STATIC function OPERATION_NAME PASCAL_OPERATION_PARAMETERS_PAREN PASCAL_OPERATION_RETURN_TYPE ; PASCAL_OPERATION_VIRTUAL  PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE]

public
SELECT_WHEN ATTRIBUTE_ACCESS == public [COLUMN_TAB(4) F$ATTRIBUTE_NAME : ATTRIBUTE_TYPE ; ] 

SELECT_WHEN OPERATION_ACCESS == public LOGICAL_AND OPERATION_IS_PROCEDURE [
    PASCAL_OPERATION_STATIC procedure OPERATION_NAME PASCAL_OPERATION_PARAMETERS_WITH_VAR ; PASCAL_OPERATION_VIRTUAL PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE PASCAL_OPERATION_MESSAGE]

SELECT_WHEN OPERATION_ACCESS == public LOGICAL_AND OPERATION_IS_FUNCTION [
    PASCAL_OPERATION_STATIC function OPERATION_NAME PASCAL_OPERATION_PARAMETERS_PAREN PASCAL_OPERATION_RETURN_TYPE ; PASCAL_OPERATION_VIRTUAL  PASCAL_OPERATION_ABSTRACT PASCAL_OPERATION_OVERRIDE]
                  
    constructor Create; virtual; { override;  replace virtual with override in derived classes }

			{Update to initialize ancestor fields.}
    constructor Initialize ( [const a$ATTRIBUTE_NAME : ATTRIBUTE_TYPE DELETE_LAST_SYMBOL;] NO_RETURN);

    constructor Copy (const a$CLASS_NAME : T$CLASS_NAME); {Copy Constructor}

    destructor Destroy ; override;

    function EqualTo ( const a$CLASS_NAME : T$CLASS_NAME ) : Boolean ;

SELECT_WHEN ATTRIBUTE_IS_READ_PROPERTY LOGICAL_AND ATTRIBUTE_IS_WRITE_PROPERTY [
    property ATTRIBUTE_NAME : ATTRIBUTE_TYPE read F$ATTRIBUTE_NAME write Set$ATTRIBUTE_NAME ;]

SELECT_WHEN ATTRIBUTE_IS_READ_PROPERTY LOGICAL_AND LOGICAL_NOT ATTRIBUTE_IS_WRITE_PROPERTY [
    property ATTRIBUTE_NAME : ATTRIBUTE_TYPE read F$ATTRIBUTE_NAME;]

SELECT_WHEN ATTRIBUTE_IS_WRITE_PROPERTY LOGICAL_AND LOGICAL_NOT ATTRIBUTE_IS_READ_PROPERTY [
    property ATTRIBUTE_NAME : ATTRIBUTE_TYPE write Set$ATTRIBUTE_NAME ;]

[   procedure Set$ASSOCIATION_ONE_CLASS ( a$ASSOCIATION_ONE_CLASS : T$ASSOCIATION_ONE_CLASS ) ; {Set Accessor Procedure for 1:1 Association}]

[   function Get$ASSOCIATION_ONE_CLASS : T$ASSOCIATION_ONE_CLASS ; {Get Assessor Function for 1:1 Association} ]

[   procedure Remove$ASSOCIATION_ONE_CLASS ;]

[   procedure Set$ASSOCIATION_MANY_CLASS$List ( a$ASSOCIATION_MANY_CLASS$List : TList ) ; {Set Accessor Procedure for 1:Many Association}]

[   function Get$ASSOCIATION_MANY_CLASS$List : TList ;{Get Assessor Function for 1:Many Association} ]

[   procedure Add$ASSOCIATION_MANY_CLASS ( a$ASSOCIATION_MANY_CLASS : T$ASSOCIATION_MANY_CLASS ) ;]

[   function Get$ASSOCIATION_MANY_CLASS ( Index : Integer ) : T$ASSOCIATION_MANY_CLASS ;{Get Assessor Function for 1:Many Association}]

[   function Get$ASSOCIATION_MANY_CLASS$Count : Integer ;]

[   procedure Remove$ASSOCIATION_MANY_CLASS ( a$ASSOCIATION_MANY_CLASS : T$ASSOCIATION_MANY_CLASS ) ;]

[   procedure RemoveAll$ASSOCIATION_MANY_CLASS;]

[  function Contains$ASSOCIATION_MANY_CLASS ( a$$ASSOCIATION_MANY_CLASS : T$$ASSOCIATION_MANY_CLASS ): Boolean; ]

end;

implementation

{-----------------------------------------------------------------------------------------------}
constructor T$CLASS_NAME$.Create; {Association Objects Must be Created by Caller}
[NO_REPEAT var
  AGGREGATION_MANY_NAME$Index : Integer;]
begin
  inherited Create ;
  [ F$ATTRIBUTE_NAME := ATTRIBUTE_INITIAL_VALUE; ]
  [ ASSOCIATION_ONE_NAME := nil; {Caller must create ASSOCIATION_ONE_CLASS } ]
  [ AGGREGATION_ONE_NAME := T$AGGREGATION_ONE_CLASS$.Create;{Create 1:1 Aggregation Part Object}]
  [ ASSOCIATION_MANY_NAME := TList$.Create;{Create List Object for 1:M Association Objects} ]
  [ AGGREGATION_MANY_NAME := TList$.Create; {Create List Object for 1:M Aggregation Part Objects}
  for AGGREGATION_MANY_NAME$Index := 1 to 2 do  {Update 2 with the number of AGGREGATION_MANY_CLASS$'s }
    AGGREGATION_MANY_NAME.Add (T$AGGREGATION_MANY_CLASS$.Create);{Create AGGREGATION_MANY_CLASS objects}]
end;

{-----------------------------------------------------------------------------------------------}
			{Update to initialize ancestor fields.}
constructor T$CLASS_NAME$.Initialize ( [const a$ATTRIBUTE_NAME : ATTRIBUTE_TYPE  DELETE_LAST_SYMBOL;] NO_RETURN);
[NO_REPEAT var
  AGGREGATION_MANY_NAME$Index : Integer;]
begin
  inherited Create; {Update for inherited Initialize with Arguments}
  [ F$ATTRIBUTE_NAME := a$ATTRIBUTE_NAME;]
  [ ASSOCIATION_ONE_NAME := nil; {Caller must create ASSOCIATION_ONE_CLASS } ]
  [ AGGREGATION_ONE_NAME := T$AGGREGATION_ONE_CLASS$.Create;{Create 1:1 Aggregation Part Object}]
  [ ASSOCIATION_MANY_NAME := TList$.Create;{Create List Object for 1:M Association Objects} ]
  [ AGGREGATION_MANY_NAME := TList$.Create; {Create List Object for 1:M Aggregation Part Objects}
  for AGGREGATION_MANY_NAME$Index := 1 to 2 do  {Update 2 with the number of AGGREGATION_MANY_CLASS$'s }
    AGGREGATION_MANY_NAME.Add (T$AGGREGATION_MANY_CLASS$.Create);{Create AGGREGATION_MANY_CLASS objects}]
end;
{-----------------------------------------------------------------------------------------------}
constructor T$CLASS_NAME$.Copy (const a$CLASS_NAME : T$CLASS_NAME ); {Copy Constructor}
begin
  Self := a$CLASS_NAME;
end;
{-----------------------------------------------------------------------------------------------}
destructor T$CLASS_NAME$.Destroy ;
[NO_REPEAT var
  AGGREGATION_MANY_NAME$Index : Integer;
  Temp$AGGREGATION_MANY_NAME : T$AGGREGATION_MANY_CLASS ; ]
begin 
  [ AGGREGATION_ONE_NAME$.Free; {Frees 1:1 Aggregation Part Object} ]
  [ ASSOCIATION_MANY_NAME$.Free; {Frees 1:Many Association List-caller must free Association objects} ]
  [ for AGGREGATION_MANY_NAME$Index := 1 to AGGREGATION_MANY_NAME$.Count do
    begin
      Temp$AGGREGATION_MANY_NAME := AGGREGATION_MANY_NAME$.Items LITERAL_SYMBOL[ AGGREGATION_MANY_NAME$Index LITERAL_SYMBOL] ;
      Temp$AGGREGATION_MANY_NAME.Free; {Frees 1:Many Aggregation Part Objects}
    end; 
   AGGREGATION_MANY_NAME$.Free;{Frees 1:Many Aggregation List Object} ]
  inherited Destroy;
end;

{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME.EqualTo ( const a$CLASS_NAME : T$CLASS_NAME ) : Boolean; 
begin  { Does a field by field comparison - update to compare ancestor fields }
  Result := true;
  [if (F$ATTRIBUTE_NAME <> a$CLASS_NAME.F$ATTRIBUTE_NAME) then Result := false;]