moosetechnology / Famix-Value / 11854370139

FamixValueHelperObjectExportStrategy >> addToHelper: helperClass [

        "Must be called when building the helper class to add the generated helper declarations."

        declarations valuesDo: [ :declaration |

                helperClass addDeclaration: declaration ]

]

FamixValueHelperObjectExportStrategy >> buildMethodFor: object withParametersFor: attributes on: visitor [

        "Build the helper method to construct objects of the same type as the one given in argument.

        Use only the relevant attributes that are given, rather than all attributes."

        | model oldStatementBlock helper |

        object type isPublic ifFalse: [

                FamixValueExporterError signal:

                        'Cannot (yet) recreate object of non-public class: '

                        , object type name ].

        model := visitor model.

        "swap visitor context: the 'sheet' on which the visitor writes"

        oldStatementBlock := visitor statementBlock.

        visitor statementBlock: model newStatementBlock.

        visitor builder processType: object type.

        "make the method entity"

        helper := self

                          makeMethodFor: object type

                          withParametersFor: attributes

                          on: visitor.

        "make the method body: instantiate object, set attributes and return it"

        visitor constructObject: object.

        self

                makeSetterInvocationsFor:

                (visitor filterAttributesToSet: attributes for: object type)

                on: visitor.

        visitor statementBlock addStatement:

                (model newReturnStatement expression:

                         (model newVariableExpression name: (visitor varNameFor: object))).

        "restore original visitor context"

        visitor statementBlock: oldStatementBlock.

        ^ helper

]

FamixValueHelperObjectExportStrategy >> declarations [

        ^ declarations

]

FamixValueHelperObjectExportStrategy >> dependencyImportsOn: aFASTModel [

        ^ { ((aFASTModel newImportDeclaration qualifiedName:

                            (aFASTModel newQualifiedName name:

                                             'fr.evref.modest.ModestHelper'))

                   isStatic: true;

                   isOnDemand: true) }

]

FamixValueHelperObjectExportStrategy >> export: object on: visitor [

        "Use a helper method to instantiate the object and set its attributes."

        | attributes helper model |

        "ensure all relevant attributes are set up"

        (attributes := object relevantAttributes) do: [ :attribute |

                visitor ensureVisited: attribute value ].

        "check if the object was not set up in the previous step"

        (visitor varNameDict includesKey: object) ifTrue: [ ^ self ].

        "get the helper method, or build it if it does not exist"

        helper := declarations

                          at: object constructorSignature

                          ifAbsentPut: [

                                  self

                                          buildMethodFor: object

                                          withParametersFor: attributes

                                          on: visitor ].

        "call the helper method to build the object and store it in a variable"

        model := visitor model.

        visitor statementBlock addStatement: (model newVarDeclStatement

                         type: (object asFASTJavaTypeExpressionOn: visitor);

                         addDeclarator: (model newVariableDeclarator

                                          variable:

                                                  (model newVariableExpression name:

                                                                   (visitor varNameFor: object));

                                          expression:

                                                  (self

                                                           makeHelperInvocation: helper

                                                           arguments: attributes

                                                           on: visitor));

                         yourself)

]

FamixValueHelperObjectExportStrategy >> initialize [

        declarations := Dictionary new

]

FamixValueHelperObjectExportStrategy >> makeHelperInvocation: helper arguments: arguments on: visitor [

        | model |

        model := visitor model.

        ^ model newMethodInvocation

                  name: helper name;

                  arguments: (arguments

                                   with: helper parameters

                                   collect: [ :argument :parameter | "reference the value with a variable"

                                           | ref |

                                           ref := visitor makeVariableExpression: argument value.

                                           ((argument value type name sameAs: 'long') not and: [

                                                            (FASTJavaExportVisitor new export: parameter type) sameAs:

                                                                            'long' ])

                                                   ifTrue: [ "try casting"

                                                           model newCastExpression

                                                                   type: (model newClassTypeExpression typeName:

                                                                                            (model newTypeName name: 'long'));

                                                                   expression: ref ]

                                                   ifFalse: [ ref ] ])

]

FamixValueHelperObjectExportStrategy >> makeMethodFor: aFamixType withParametersFor: attributes on: visitor [

        "Make the method entity, handles its signature and modifiers."

        | model |

        model := visitor model.

        ^ model newMethodEntity

                  name: 'new' , aFamixType baseName;

                  addModifier: (model newModifier token: 'public');

                  addModifier: (model newModifier token: 'static');

                  type: (aFamixType asFASTJavaTypeExpressionOn: visitor);

                  parameters: (attributes collect: [ :attribute |

                                           model newParameter

                                                   type: (attribute attribute declaredType

                                                                    ifNotNil: [ :declaredType |

                                                                            attribute value type

                                                                                    decorate: declaredType

                                                                                    asFASTJavaTypeExpressionOn: visitor ]

                                                                    ifNil: [

                                                                            model newClassTypeExpression typeName:

                                                                                            (model newTypeName name: 'Object') ]);

                                                   variable:

                                                           (model newVariableExpression name: attribute varName) ]);

                  statementBlock: visitor statementBlock

]

FamixValueHelperObjectExportStrategy >> makeSetterInvocationsFor: attributes on: visitor [

        "Build the helper method's body: set the value of each argument to the corresponding attribute using setters or reflection."

        attributes do: [ :attribute |

                attribute attribute declaredType ifNotNil: [ :declaredType |

                        visitor builder processType: declaredType ].

                (attribute object type findSetterOf: attribute attribute)

                        ifNotNil: [ :setter |

                                visitor

                                        makeSetterInvocation: setter

                                        for: attribute

                                        named: attribute varName.

                                "handle setters that can throw exceptions to rethrow an unchecked exception"

                                setter thrownExceptions ifNotEmpty: [ :exceptions |

                                        visitor statementBlock addStatement: (visitor

                                                         makeTry: visitor statementBlock statements last

                                                         catch: exceptions) ] ]

                        ifNil: [ visitor makeReflectionSetterInvocation: attribute ] ]

]

FamixValueHelperObjectExportStrategy >> makeVariableExpression: value on: visitor [

        "Used when constructing an object to correctly name the argument variable.

        For helpers, the var name is the same as the helper method parameter."

        ^ visitor model newVariableExpression name: value varName

]