-- @atlcompiler atl2006

-- Generated by: $Id: EModelCopyGenerator.atl 7689 2009-02-13 15:20:37Z dwagelaa $
module EModelCopy;

create OUT : JAVA from IN : JAVA;

helper def : inElements : Set(JAVA!"ecore::EObject") = JAVA!"ecore::EObject".allInstancesFrom('IN');

entrypoint rule count() {
	do {
		thisModule.inElements->size().debug('SIZE');
	}
	
}

rule AnonymousClassDeclaration {
    from s : JAVA!"j2se5::AnonymousClassDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::AnonymousClassDeclaration" (
        __xmiID__ <- s.__xmiID__,
        comments <- s.comments,
        bodyDeclarations <- s.bodyDeclarations)
}

rule ArrayAccess {
    from s : JAVA!"j2se5::ArrayAccess" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ArrayAccess" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        array <- s.array,
        index <- s.index)
}

rule ArrayCreation {
    from s : JAVA!"j2se5::ArrayCreation" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ArrayCreation" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        type <- s.type,
        dimensions <- s.dimensions,
        initializer <- s.initializer)
}

rule ArrayInitializer {
    from s : JAVA!"j2se5::ArrayInitializer" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ArrayInitializer" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expressions <- s.expressions)
}

rule AssertStatement {
    from s : JAVA!"j2se5::AssertStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::AssertStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        message <- s.message,
        expression <- s.expression)
}

rule Assignment {
    from s : JAVA!"j2se5::Assignment" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::Assignment" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        operator <- s.operator,
        comments <- s.comments,
        leftHandSide <- s.leftHandSide,
        rightHandSide <- s.rightHandSide)
}

rule Block {
    from s : JAVA!"j2se5::Block" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::Block" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        statements <- s.statements)
}

rule BooleanLiteral {
    from s : JAVA!"j2se5::BooleanLiteral" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::BooleanLiteral" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        value <- s.value,
        comments <- s.comments)
}

rule BreakStatement {
    from s : JAVA!"j2se5::BreakStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::BreakStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        label <- s.label)
}

rule CastExpression {
    from s : JAVA!"j2se5::CastExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::CastExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        type <- s.type,
        expression <- s.expression)
}

rule CatchClause {
    from s : JAVA!"j2se5::CatchClause" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::CatchClause" (
        __xmiID__ <- s.__xmiID__,
        comments <- s.comments,
        exception <- s.exception,
        body <- s.body)
}

rule CharacterLiteral {
    from s : JAVA!"j2se5::CharacterLiteral" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::CharacterLiteral" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        escapedValue <- s.escapedValue,
        comments <- s.comments)
}

rule ClassInstanceCreation {
    from s : JAVA!"j2se5::ClassInstanceCreation" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ClassInstanceCreation" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        anonymousClassDeclaration <- s.anonymousClassDeclaration,
        arguments <- s.arguments,
        expression <- s.expression,
        type <- s.type,
        method <- s.method)
}

rule ConditionalExpression {
    from s : JAVA!"j2se5::ConditionalExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ConditionalExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        elseExpression <- s.elseExpression,
        expression <- s.expression,
        thenExpression <- s.thenExpression)
}

rule ConstructorInvocation {
    from s : JAVA!"j2se5::ConstructorInvocation" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ConstructorInvocation" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        arguments <- s.arguments,
        method <- s.method)
}

rule ContinueStatement {
    from s : JAVA!"j2se5::ContinueStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ContinueStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        label <- s.label)
}

rule DoStatement {
    from s : JAVA!"j2se5::DoStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::DoStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression,
        body <- s.body)
}

rule EmptyStatement {
    from s : JAVA!"j2se5::EmptyStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::EmptyStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments)
}

rule ExpressionStatement {
    from s : JAVA!"j2se5::ExpressionStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ExpressionStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression)
}

rule FieldAccess {
    from s : JAVA!"j2se5::FieldAccess" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::FieldAccess" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        field <- s.field,
        expression <- s.expression)
}

rule FieldDeclaration {
    from s : JAVA!"j2se5::FieldDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::FieldDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        type <- s.type,
        fragments <- s.fragments)
}

rule ForStatement {
    from s : JAVA!"j2se5::ForStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ForStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression,
        updaters <- s.updaters,
        initializers <- s.initializers,
        body <- s.body)
}

rule IfStatement {
    from s : JAVA!"j2se5::IfStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::IfStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression,
        thenStatement <- s.thenStatement,
        elseStatement <- s.elseStatement)
}

rule ImportDeclaration {
    from s : JAVA!"j2se5::ImportDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ImportDeclaration" (
        __xmiID__ <- s.__xmiID__,
        static <- s.static,
        originalRank <- s.originalRank,
        comments <- s.comments,
        importedElement <- s.importedElement)
}

rule InfixExpression {
    from s : JAVA!"j2se5::InfixExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::InfixExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        operator <- s.operator,
        comments <- s.comments,
        rightOperand <- s.rightOperand,
        leftOperand <- s.leftOperand,
        extendedOperands <- s.extendedOperands)
}

rule Initializer {
    from s : JAVA!"j2se5::Initializer" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::Initializer" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        body <- s.body)
}

rule InstanceofExpression {
    from s : JAVA!"j2se5::InstanceofExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::InstanceofExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        rightOperand <- s.rightOperand,
        leftOperand <- s.leftOperand)
}

rule Javadoc {
    from s : JAVA!"j2se5::Javadoc" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::Javadoc" (
        __xmiID__ <- s.__xmiID__,
        content <- s.content,
        isEnclosedByParent <- s.isEnclosedByParent,
        isPrefixOfParent <- s.isPrefixOfParent,
        comments <- s.comments,
        tags <- s.tags)
}

rule LabeledStatement {
    from s : JAVA!"j2se5::LabeledStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::LabeledStatement" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        comments <- s.comments,
        body <- s.body)
}

rule MethodDeclaration {
    from s : JAVA!"j2se5::MethodDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::MethodDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        extraArrayDimensions <- s.extraArrayDimensions,
        constructor <- s.constructor,
        varargs <- s.varargs,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        body <- s.body,
        thrownExceptions <- s.thrownExceptions,
        returnType <- s.returnType,
        typeParameters <- s.typeParameters,
        redefinedMethodDeclaration <- s.redefinedMethodDeclaration,
        redefinitions <- s.redefinitions,
        parameters <- s.parameters)
}

rule MethodInvocation {
    from s : JAVA!"j2se5::MethodInvocation" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::MethodInvocation" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        method <- s.method,
        arguments <- s.arguments,
        expression <- s.expression)
}

rule NullLiteral {
    from s : JAVA!"j2se5::NullLiteral" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::NullLiteral" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments)
}

rule NumberLiteral {
    from s : JAVA!"j2se5::NumberLiteral" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::NumberLiteral" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        tokenValue <- s.tokenValue,
        comments <- s.comments)
}

rule PackageDeclaration {
    from s : JAVA!"j2se5::PackageDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PackageDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments,
        ownedElements <- s.ownedElements,
        ownedPackages <- s.ownedPackages)
}

rule ParenthesizedExpression {
    from s : JAVA!"j2se5::ParenthesizedExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ParenthesizedExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression)
}

rule PostfixExpression {
    from s : JAVA!"j2se5::PostfixExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PostfixExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        operator <- s.operator,
        comments <- s.comments,
        operand <- s.operand)
}

rule PrefixExpression {
    from s : JAVA!"j2se5::PrefixExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrefixExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        operator <- s.operator,
        comments <- s.comments,
        operand <- s.operand)
}

rule PrimitiveType {
    from s : JAVA!"j2se5::PrimitiveType" (
		if thisModule.inElements->includes(s) then
			s.oclIsTypeOf(JAVA!"j2se5::PrimitiveType")
		else false endif)
    to t : JAVA!"j2se5::PrimitiveType" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule NamedElementRef {
    from s : JAVA!"j2se5::NamedElementRef" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::NamedElementRef" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        qualifier <- s.qualifier,
        element <- s.element)
}

rule ReturnStatement {
    from s : JAVA!"j2se5::ReturnStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ReturnStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression)
}

rule SingleVariableDeclaration {
    from s : JAVA!"j2se5::SingleVariableDeclaration" (
		if thisModule.inElements->includes(s) then
			s.oclIsTypeOf(JAVA!"j2se5::SingleVariableDeclaration")
		else false endif)
    to t : JAVA!"j2se5::SingleVariableDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        extraArrayDimensions <- s.extraArrayDimensions,
        comments <- s.comments,
        initializer <- s.initializer,
        modifier <- s.modifier)
}

rule StringLiteral {
    from s : JAVA!"j2se5::StringLiteral" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::StringLiteral" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        escapedValue <- s.escapedValue,
        comments <- s.comments)
}

rule SuperConstructorInvocation {
    from s : JAVA!"j2se5::SuperConstructorInvocation" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::SuperConstructorInvocation" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression,
        arguments <- s.arguments,
        method <- s.method)
}

rule SuperFieldAccess {
    from s : JAVA!"j2se5::SuperFieldAccess" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::SuperFieldAccess" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        field <- s.field,
        qualifier <- s.qualifier)
}

rule SuperMethodInvocation {
    from s : JAVA!"j2se5::SuperMethodInvocation" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::SuperMethodInvocation" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        qualifier <- s.qualifier,
        arguments <- s.arguments,
        method <- s.method)
}

rule SwitchCase {
    from s : JAVA!"j2se5::SwitchCase" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::SwitchCase" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        expressionInitialized <- s.expressionInitialized,
        comments <- s.comments,
        expression <- s.expression)
}

rule SwitchStatement {
    from s : JAVA!"j2se5::SwitchStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::SwitchStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression,
        statements <- s.statements)
}

rule SynchronizedStatement {
    from s : JAVA!"j2se5::SynchronizedStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::SynchronizedStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        body <- s.body,
        expression <- s.expression)
}

rule ThisExpression {
    from s : JAVA!"j2se5::ThisExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ThisExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        qualifier <- s.qualifier)
}

rule ThrowStatement {
    from s : JAVA!"j2se5::ThrowStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ThrowStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression)
}

rule TryStatement {
    from s : JAVA!"j2se5::TryStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::TryStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        body <- s.body,
        finally <- s.finally,
        catchClauses <- s.catchClauses)
}

rule TypeDeclarationStatement {
    from s : JAVA!"j2se5::TypeDeclarationStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::TypeDeclarationStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        declaration <- s.declaration)
}

rule TypeLiteral {
    from s : JAVA!"j2se5::TypeLiteral" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::TypeLiteral" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        type <- s.type)
}

rule VariableDeclarationExpression {
    from s : JAVA!"j2se5::VariableDeclarationExpression" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::VariableDeclarationExpression" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        type <- s.type,
        fragments <- s.fragments,
        modifier <- s.modifier)
}

rule VariableDeclarationStatement {
    from s : JAVA!"j2se5::VariableDeclarationStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::VariableDeclarationStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        extraArrayDimensions <- s.extraArrayDimensions,
        comments <- s.comments,
        type <- s.type,
        fragments <- s.fragments,
        modifier <- s.modifier)
}

rule WhileStatement {
    from s : JAVA!"j2se5::WhileStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::WhileStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        expression <- s.expression,
        body <- s.body)
}

rule BlockComment {
    from s : JAVA!"j2se5::BlockComment" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::BlockComment" (
        __xmiID__ <- s.__xmiID__,
        content <- s.content,
        isEnclosedByParent <- s.isEnclosedByParent,
        isPrefixOfParent <- s.isPrefixOfParent,
        comments <- s.comments)
}

rule LineComment {
    from s : JAVA!"j2se5::LineComment" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::LineComment" (
        __xmiID__ <- s.__xmiID__,
        content <- s.content,
        isEnclosedByParent <- s.isEnclosedByParent,
        isPrefixOfParent <- s.isPrefixOfParent,
        comments <- s.comments)
}

rule EnumDeclaration {
    from s : JAVA!"j2se5::EnumDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::EnumDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        originalFileContent <- s.originalFileContent,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        imports <- s.imports,
        bodyDeclarations <- s.bodyDeclarations,
        superInterfaces <- s.superInterfaces,
        commentsBeforeBody <- s.commentsBeforeBody,
        commentsAfterBody <- s.commentsAfterBody,
        enumConstants <- s.enumConstants)
}

rule EnumConstantDeclaration {
    from s : JAVA!"j2se5::EnumConstantDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::EnumConstantDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        anonymousClassDeclaration <- s.anonymousClassDeclaration,
        arguments <- s.arguments)
}

rule Model {
    from s : JAVA!"j2se5::Model" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::Model" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        ownedElements <- s.ownedElements,
        orphanTypes <- s.orphanTypes,
        unresolvedItems <- s.unresolvedItems)
}

rule ArrayLengthAccess {
    from s : JAVA!"j2se5::ArrayLengthAccess" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ArrayLengthAccess" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        array <- s.array)
}

rule TagElement {
    from s : JAVA!"j2se5::TagElement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::TagElement" (
        __xmiID__ <- s.__xmiID__,
        tagName <- s.tagName,
        comments <- s.comments,
        fragments <- s.fragments)
}

rule TextElement {
    from s : JAVA!"j2se5::TextElement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::TextElement" (
        __xmiID__ <- s.__xmiID__,
        text <- s.text,
        comments <- s.comments)
}

rule MethodRef {
    from s : JAVA!"j2se5::MethodRef" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::MethodRef" (
        __xmiID__ <- s.__xmiID__,
        comments <- s.comments,
        method <- s.method,
        qualifier <- s.qualifier,
        parameters <- s.parameters)
}

rule MemberRef {
    from s : JAVA!"j2se5::MemberRef" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::MemberRef" (
        __xmiID__ <- s.__xmiID__,
        comments <- s.comments,
        member <- s.member,
        qualifier <- s.qualifier)
}

rule UnresolvedItem {
    from s : JAVA!"j2se5::UnresolvedItem" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::UnresolvedItem" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule Annotation {
    from s : JAVA!"j2se5::Annotation" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::Annotation" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        values <- s.values,
        type <- s.type)
}

rule AnnotationMemberValuePair {
    from s : JAVA!"j2se5::AnnotationMemberValuePair" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::AnnotationMemberValuePair" (
        __xmiID__ <- s.__xmiID__,
        comments <- s.comments,
        value <- s.value,
        member <- s.member)
}

rule AnnotationTypeDeclaration {
    from s : JAVA!"j2se5::AnnotationTypeDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::AnnotationTypeDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        originalFileContent <- s.originalFileContent,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        imports <- s.imports,
        bodyDeclarations <- s.bodyDeclarations,
        superInterfaces <- s.superInterfaces,
        commentsBeforeBody <- s.commentsBeforeBody,
        commentsAfterBody <- s.commentsAfterBody)
}

rule AnnotationTypeMemberDeclaration {
    from s : JAVA!"j2se5::AnnotationTypeMemberDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::AnnotationTypeMemberDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        type <- s.type,
        default <- s.default)
}

rule EnhancedForStatement {
    from s : JAVA!"j2se5::EnhancedForStatement" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::EnhancedForStatement" (
        __xmiID__ <- s.__xmiID__,
        originalRank <- s.originalRank,
        comments <- s.comments,
        body <- s.body,
        expression <- s.expression,
        parameter <- s.parameter)
}

rule TypeParameter {
    from s : JAVA!"j2se5::TypeParameter" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::TypeParameter" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments,
        bounds <- s.bounds)
}

rule ParameterizedType {
    from s : JAVA!"j2se5::ParameterizedType" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ParameterizedType" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments,
        type <- s.type,
        typeArguments <- s.typeArguments)
}

rule WildCardType {
    from s : JAVA!"j2se5::WildCardType" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::WildCardType" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        isUpperBound <- s.isUpperBound,
        comments <- s.comments,
        bound <- s.bound)
}

rule OrphanType {
    from s : JAVA!"j2se5::OrphanType" (
		if thisModule.inElements->includes(s) then
			s.oclIsTypeOf(JAVA!"j2se5::OrphanType")
		else false endif)
    to t : JAVA!"j2se5::OrphanType" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule ArrayType {
    from s : JAVA!"j2se5::ArrayType" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ArrayType" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        dimensions <- s.dimensions,
        comments <- s.comments,
        elementType <- s.elementType)
}

rule MethodRefParameter {
    from s : JAVA!"j2se5::MethodRefParameter" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::MethodRefParameter" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        isVarargs <- s.isVarargs,
        comments <- s.comments,
        type <- s.type)
}

rule ParameterDeclaration {
    from s : JAVA!"j2se5::ParameterDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ParameterDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        extraArrayDimensions <- s.extraArrayDimensions,
        isVarargs <- s.isVarargs,
        originalRank <- s.originalRank,
        comments <- s.comments,
        initializer <- s.initializer,
        modifier <- s.modifier,
        type <- s.type)
}

rule SingleMemberDeclaration {
    from s : JAVA!"j2se5::SingleMemberDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::SingleMemberDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        extraArrayDimensions <- s.extraArrayDimensions,
        comments <- s.comments,
        initializer <- s.initializer,
        modifier <- s.modifier)
}

rule ClassDeclaration {
    from s : JAVA!"j2se5::ClassDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::ClassDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        originalFileContent <- s.originalFileContent,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        imports <- s.imports,
        bodyDeclarations <- s.bodyDeclarations,
        superInterfaces <- s.superInterfaces,
        commentsBeforeBody <- s.commentsBeforeBody,
        commentsAfterBody <- s.commentsAfterBody,
        typeParameters <- s.typeParameters,
        superclass <- s.superclass)
}

rule InterfaceDeclaration {
    from s : JAVA!"j2se5::InterfaceDeclaration" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::InterfaceDeclaration" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        originalRank <- s.originalRank,
        originalFileContent <- s.originalFileContent,
        comments <- s.comments,
        annotations <- s.annotations,
        modifier <- s.modifier,
        imports <- s.imports,
        bodyDeclarations <- s.bodyDeclarations,
        superInterfaces <- s.superInterfaces,
        commentsBeforeBody <- s.commentsBeforeBody,
        commentsAfterBody <- s.commentsAfterBody,
        typeParameters <- s.typeParameters)
}

rule Modifier {
    from s : JAVA!"j2se5::Modifier" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::Modifier" (
        __xmiID__ <- s.__xmiID__,
        visibility <- s.visibility,
        inheritance <- s.inheritance,
        isStatic <- s.isStatic,
        isTransient <- s.isTransient,
        isVolatile <- s.isVolatile,
        isNative <- s.isNative,
        isStrictfp <- s.isStrictfp,
        isSynchronized <- s.isSynchronized,
        comments <- s.comments)
}

rule PrimitiveTypeChar {
    from s : JAVA!"j2se5::PrimitiveTypeChar" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeChar" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeByte {
    from s : JAVA!"j2se5::PrimitiveTypeByte" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeByte" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeShort {
    from s : JAVA!"j2se5::PrimitiveTypeShort" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeShort" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeInt {
    from s : JAVA!"j2se5::PrimitiveTypeInt" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeInt" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeLong {
    from s : JAVA!"j2se5::PrimitiveTypeLong" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeLong" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeFloat {
    from s : JAVA!"j2se5::PrimitiveTypeFloat" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeFloat" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeDouble {
    from s : JAVA!"j2se5::PrimitiveTypeDouble" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeDouble" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeBoolean {
    from s : JAVA!"j2se5::PrimitiveTypeBoolean" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeBoolean" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}

rule PrimitiveTypeVoid {
    from s : JAVA!"j2se5::PrimitiveTypeVoid" (thisModule.inElements->includes(s))
    to t : JAVA!"j2se5::PrimitiveTypeVoid" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        proxy <- s.proxy,
        comments <- s.comments)
}