delphi2.sct

c#设计模式WithCla

  {uncomment to compare 1:1 part objects }
  [//if (not(AGGREGATION_ONE_NAME.EqualTo (a$CLASS_NAME.$AGGREGATION_ONE_NAME)) ) then Result := false ; ] 
end;

SELECT_WHEN OPERATION_IS_PROCEDURE       
[{-----------------------------------------------------------------------------------------------}
PASCAL_OPERATION_STATIC procedure T$CLASS_NAME.OPERATION_NAME PASCAL_OPERATION_PARAMETERS_WITH_VAR ; 
begin
{ Place code here  }
  OPERATION_CODE
end;    
]
SELECT_WHEN OPERATION_IS_FUNCTION 
[{-----------------------------------------------------------------------------------------------}
PASCAL_OPERATION_STATIC function T$CLASS_NAME.OPERATION_NAME PASCAL_OPERATION_PARAMETERS_PAREN PASCAL_OPERATION_RETURN_TYPE ; 
begin
{ Place code here and return an object }
  OPERATION_CODE
end;    
]
SELECT_WHEN ATTRIBUTE_IS_WRITE_PROPERTY 
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME.Set$ATTRIBUTE_NAME ( const a$ATTRIBUTE_NAME : ATTRIBUTE_TYPE ); {Accessor Set Procedure }
begin
  F$ATTRIBUTE_NAME := a$ATTRIBUTE_NAME;
end; 
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Set$AGGREGATION_ONE_CLASS ( a$AGGREGATION_ONE_CLASS : T$AGGREGATION_ONE_CLASS );
begin
  AGGREGATION_ONE_NAME := a$AGGREGATION_ONE_CLASS ;
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$AGGREGATION_ONE_CLASS ( ) : T$AGGREGATION_ONE_CLASS ; 
begin
  Result := AGGREGATION_ONE_NAME;
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Set$ASSOCIATION_ONE_CLASS ( a$ASSOCIATION_ONE_CLASS : T$ASSOCIATION_ONE_CLASS );
begin
  ASSOCIATION_ONE_NAME := a$ASSOCIATION_ONE_CLASS ;
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$ASSOCIATION_ONE_CLASS ( ) : T$ASSOCIATION_ONE_CLASS ; 
begin
  Result := ASSOCIATION_ONE_NAME;
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Remove$ASSOCIATION_ONE_CLASS ; 
begin
  ASSOCIATION_ONE_NAME := nil;
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Set$AGGREGATION_MANY_CLASS$List ( a$AGGREGATION_MANY_CLASS$List : TList );
begin   {1st free objects in the current list }
  AGGREGATION_MANY_NAME := a$AGGREGATION_MANY_CLASS$List ;
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$AGGREGATION_MANY_CLASS$List ( ) : TList ; 
begin
  Result := AGGREGATION_MANY_NAME;
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Add$AGGREGATION_MANY_CLASS ( a$AGGREGATION_MANY_CLASS : T$AGGREGATION_MANY_CLASS );
begin                
  AGGREGATION_MANY_NAME.Add (a$AGGREGATION_MANY_CLASS) ;
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$AGGREGATION_MANY_CLASS ( Index : Integer ) : T$AGGREGATION_MANY_CLASS ; 
begin
  Result := AGGREGATION_MANY_NAME.Items LITERAL_SYMBOL[Index LITERAL_SYMBOL];
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$AGGREGATION_MANY_CLASS$Count : Integer ; 
begin
  Result := AGGREGATION_MANY_NAME.Count;
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Remove$AGGREGATION_MANY_CLASS (a$AGGREGATION_MANY_CLASS : T$AGGREGATION_MANY_CLASS );
begin   
  AGGREGATION_MANY_NAME.Remove (a$AGGREGATION_MANY_CLASS) ; { 1st remove a$AGGREGATION_MANY_CLASS objects in the list  }
  a$AGGREGATION_MANY_CLASS.free; { 2nd free a$AGGREGATION_MANY_CLASS }
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.RemoveAll$AGGREGATION_MANY_CLASS ; 
var
  AGGREGATION_MANY_NAME$Index : Integer;
  Temp$AGGREGATION_MANY_NAME : T$AGGREGATION_MANY_CLASS ; 
begin 
  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] ;
      AGGREGATION_MANY_NAME$.Remove ( Temp$AGGREGATION_MANY_NAME );
      Temp$AGGREGATION_MANY_NAME.Free; {Frees 1:Many Aggregation Part Objects}
    end; 
end;
]
[ {-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Contains$AGGREGATION_MANY_CLASS ( a$AGGREGATION_MANY_CLASS : T$AGGREGATION_MANY_CLASS ): Boolean;
var
  AGGREGATION_MANY_NAME$Index : Integer;
begin 
  Result := false;
  for AGGREGATION_MANY_NAME$Index := 1 to AGGREGATION_MANY_NAME$.Count do
    begin
      if (a$AGGREGATION_MANY_CLASS = AGGREGATION_MANY_NAME$.Items LITERAL_SYMBOL[ AGGREGATION_MANY_NAME$index LITERAL_SYMBOL]) then Result := true;
    end; 
end;
]

[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Set$ASSOCIATION_MANY_CLASS$List ( a$ASSOCIATION_MANY_CLASS$List : TList );
begin
  ASSOCIATION_MANY_NAME := a$ASSOCIATION_MANY_CLASS$List ;
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$ASSOCIATION_MANY_CLASS$List ( ) : TList ; 
begin
  Result := ASSOCIATION_MANY_NAME;
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Add$ASSOCIATION_MANY_CLASS ( a$ASSOCIATION_MANY_CLASS : T$ASSOCIATION_MANY_CLASS );
begin                {Caller must create a$ASSOCIATION_MANY_CLASS  }
  ASSOCIATION_MANY_NAME.Add (a$ASSOCIATION_MANY_CLASS) ;
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$ASSOCIATION_MANY_CLASS ( Index : Integer ) : T$ASSOCIATION_MANY_CLASS ; 
begin
  Result := ASSOCIATION_MANY_NAME.Items LITERAL_SYMBOL[Index LITERAL_SYMBOL];
end;
]
[{-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Get$ASSOCIATION_MANY_CLASS$Count : Integer ; 
begin
  Result := ASSOCIATION_MANY_NAME.Count;
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.Remove$ASSOCIATION_MANY_CLASS ( a$ASSOCIATION_MANY_CLASS : T$ASSOCIATION_MANY_CLASS );
begin   { Caller must free a$ASSOCIATION_MANY_CLASS  }
  ASSOCIATION_MANY_NAME.Remove (a$ASSOCIATION_MANY_CLASS) ; {Caller must free a$ASSOCIATION_MANY_CLASS }
end;
]
[{-----------------------------------------------------------------------------------------------}
procedure T$CLASS_NAME$.RemoveAll$ASSOCIATION_MANY_CLASS ; 
begin   { Caller must free ASSOCIATION_MANY_CLASS$'s  }
  ASSOCIATION_MANY_NAME.Clear;
end;
]
[ {-----------------------------------------------------------------------------------------------}
function T$CLASS_NAME$.Contains$ASSOCIATION_MANY_CLASS ( a$$ASSOCIATION_MANY_CLASS : T$$ASSOCIATION_MANY_CLASS ): Boolean;
var
  ASSOCIATION_MANY_NAME$Index : Integer;
begin 
  Result := false;
  for ASSOCIATION_MANY_NAME$Index := 1 to ASSOCIATION_MANY_NAME$.Count do
    begin
      if (a$ASSOCIATION_MANY_CLASS = ASSOCIATION_MANY_NAME$.Items LITERAL_SYMBOL[ ASSOCIATION_MANY_NAME$index LITERAL_SYMBOL]) then Result := true;
    end; 
end;
]
end.