Java Code Examples for org.eclipse.jdt.core.dom.TypeDeclaration#getSuperclassType()

@Override
public boolean visit(TypeDeclaration node) {
	AbstractClass clazz = new AbstractClass();
	if (node.getSuperclassType() != null) {
		ITypeBinding bind = node.getSuperclassType().resolveBinding();
		clazz.setSuperClass(bind.getQualifiedName());
	}

	clazz.setInterface(node.isInterface());
	if (packageName != null) {
		clazz.setName(packageName+'.'+node.getName().getFullyQualifiedName());
	} else {
		clazz.setName(node.getName().getFullyQualifiedName());
	}

	TypeVisitor visitor = new TypeVisitor();
	node.accept(visitor);

	clazz.setMethods(visitor.getMethods());
	clazz.setStartPosition(node.getStartPosition());
	clazz.setEndPosition(node.getStartPosition() + node.getLength() - 1);
	clazz.setFields(visitor.getFields());
	
	types.add(clazz);
	return true;
}
 

public static TypeDeclaration findDeclaringTypeDeclaration(IMethodBinding methodBinding, TypeDeclaration typeDeclaration) {
	if(typeDeclaration.resolveBinding().isEqualTo(methodBinding.getDeclaringClass())) {
		return typeDeclaration;
	}
	//method was not found in typeDeclaration
	Type superclassType = typeDeclaration.getSuperclassType();
	if(superclassType != null) {
		String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
		SystemObject system = ASTReader.getSystemObject();
		ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
		if(superclassObject != null) {
			AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
			if(superclassTypeDeclaration instanceof TypeDeclaration) {
				return findDeclaringTypeDeclaration(methodBinding, (TypeDeclaration)superclassTypeDeclaration);
			}
		}
	}
	return null;
}
 

public static TypeDeclaration findDeclaringTypeDeclaration(IVariableBinding variableBinding, TypeDeclaration typeDeclaration) {
	if(typeDeclaration.resolveBinding().isEqualTo(variableBinding.getDeclaringClass())) {
		return typeDeclaration;
	}
	//fragment was not found in typeDeclaration
	Type superclassType = typeDeclaration.getSuperclassType();
	if(superclassType != null) {
		String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
		SystemObject system = ASTReader.getSystemObject();
		ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
		if(superclassObject != null) {
			AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
			if(superclassTypeDeclaration instanceof TypeDeclaration) {
				return findDeclaringTypeDeclaration(variableBinding, (TypeDeclaration)superclassTypeDeclaration);
			}
		}
	}
	return null;
}
 

@Override
public boolean visit(TypeDeclaration decl) {
	if (decl.getName().toString().equals(seqDiagramName)) {
		superClass = null;
		Type sc = decl.getSuperclassType();

		if (sc != null) {
			String scName = sc.resolveBinding().getQualifiedName().toString();

			if (!scName.equals("hu.elte.txtuml.api.model.seqdiag.Interaction")
					&& !scName.equals("hu.elte.txtuml.api.model.seqdiag.SequenceDiagram")) {
				superClass = sc;
			}
		}
		return true;
	}
	return false;
}
 

public static MethodDeclaration findGetterDeclarationForField(VariableDeclaration variableDeclaration, TypeDeclaration typeDeclaration) {
	for(MethodDeclaration methodDeclaration : typeDeclaration.getMethods()) {
		SimpleName simpleName = MethodDeclarationUtility.isGetter(methodDeclaration);
		if(simpleName != null && variableDeclaration.resolveBinding().isEqualTo(simpleName.resolveBinding())) {
			return methodDeclaration;
		}
	}
	//fragment was not found in typeDeclaration
	Type superclassType = typeDeclaration.getSuperclassType();
	if(superclassType != null) {
		String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
		SystemObject system = ASTReader.getSystemObject();
		ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
		if(superclassObject != null) {
			AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
			if(superclassTypeDeclaration instanceof TypeDeclaration) {
				return findGetterDeclarationForField(variableDeclaration, (TypeDeclaration)superclassTypeDeclaration);
			}
		}
	}
	return null;
}
 

public static VariableDeclaration findFieldDeclaration(AbstractVariable variable, TypeDeclaration typeDeclaration) {
	for(FieldDeclaration fieldDeclaration : typeDeclaration.getFields()) {
		List<VariableDeclarationFragment> fragments = fieldDeclaration.fragments();
		for(VariableDeclarationFragment fragment : fragments) {
			if(variable.getVariableBindingKey().equals(fragment.resolveBinding().getKey())) {
				return fragment;
			}
		}
	}
	//fragment was not found in typeDeclaration
	Type superclassType = typeDeclaration.getSuperclassType();
	if(superclassType != null) {
		String superclassQualifiedName = superclassType.resolveBinding().getQualifiedName();
		SystemObject system = ASTReader.getSystemObject();
		ClassObject superclassObject = system.getClassObject(superclassQualifiedName);
		if(superclassObject != null) {
			AbstractTypeDeclaration superclassTypeDeclaration = superclassObject.getAbstractTypeDeclaration();
			if(superclassTypeDeclaration instanceof TypeDeclaration) {
				return findFieldDeclaration(variable, (TypeDeclaration)superclassTypeDeclaration);
			}
		}
	}
	return null;
}
 

private boolean visitClass(TypeDeclaration node) {

        ClassInfo classInfo = new ClassInfo();
        classInfo.name = node.getName().getFullyQualifiedName();
        classInfo.fullName = NameResolver.getFullName(node);
        classInfo.visibility = getVisibility(node);
        classInfo.isAbstract = isAbstract(node);
        classInfo.isFinal = isFinal(node);
        classInfo.superClassType = node.getSuperclassType() == null ? "java.lang.Object" : NameResolver.getFullName(node.getSuperclassType());
        List<Type> superInterfaceList = node.superInterfaceTypes();
        for (Type superInterface : superInterfaceList)
            classInfo.superInterfaceTypeList.add(NameResolver.getFullName(superInterface));
        if (node.getJavadoc() != null)
            classInfo.comment = sourceContent.substring(node.getJavadoc().getStartPosition(), node.getJavadoc().getStartPosition() + node.getJavadoc().getLength());
        classInfo.content = sourceContent.substring(node.getStartPosition(), node.getStartPosition() + node.getLength());
        elementInfoPool.classInfoMap.put(classInfo.fullName, classInfo);

        MethodDeclaration[] methodDeclarations = node.getMethods();
        for (MethodDeclaration methodDeclaration : methodDeclarations) {
            MethodInfo methodInfo = createMethodInfo(methodDeclaration, classInfo.fullName);
            elementInfoPool.methodInfoMap.put(methodInfo.hashName(), methodInfo);
        }

        FieldDeclaration[] fieldDeclarations = node.getFields();
        for (FieldDeclaration fieldDeclaration : fieldDeclarations) {
            List<FieldInfo> fieldInfos = createFieldInfos(fieldDeclaration, classInfo.fullName);
            for (FieldInfo fieldInfo : fieldInfos)
                elementInfoPool.fieldInfoMap.put(fieldInfo.hashName(), fieldInfo);
        }
        return true;
    }
 

public boolean visit(TypeDeclaration node) {
	Pair<String, String> clazzAndMethodName = NodeUtils.getTypeDecAndMethodDec(node.getName());
	String clazz = clazzAndMethodName.getFirst();
	AST ast = AST.newAST(AST.JLS8);
	Type type = ast.newSimpleType(ast.newSimpleName(clazz));
	ProjectInfo.addFieldType(clazz, "THIS", type);
	Type suType = node.getSuperclassType();
	if(suType != null){
		ProjectInfo.addFieldType(clazz, "SUPER", suType);
		ProjectInfo.addSuperClass(clazz, suType.toString());
	}
	
	List<Object> sInterfaces = node.superInterfaceTypes();
	if(sInterfaces != null){
		for(Object object : sInterfaces){
			if(object instanceof Type){
				Type interfaceType = (Type) object;
				ProjectInfo.addSuperInterface(clazz, interfaceType.toString());
			}
		}
	}
	
	FieldDeclaration fields[] = node.getFields();
	for (FieldDeclaration f : fields) {
		for (Object o : f.fragments()) {
			VariableDeclarationFragment vdf = (VariableDeclarationFragment) o;
			Type tmpType = f.getType();
			if(vdf.getExtraDimensions() > 0){
				tmpType = ast.newArrayType((Type) ASTNode.copySubtree(ast, tmpType), vdf.getExtraDimensions());
			}
			ProjectInfo.addFieldType(clazz, vdf.getName().toString(), tmpType);
		}
	}
	return true;
}
 

/**
 * Creates a new type signature of a subtype.
 *
 * @param subRewrite
 *            the compilation unit rewrite of a subtype
 * @param declaration
 *            the type declaration of a subtype
 * @param extractedType
 *            the extracted super type
 * @param extractedBinding
 *            the binding of the extracted super type
 * @param monitor
 *            the progress monitor to use
 * @throws JavaModelException
 *             if the type parameters cannot be retrieved
 */
protected final void createTypeSignature(final CompilationUnitRewrite subRewrite, final AbstractTypeDeclaration declaration, final IType extractedType, final ITypeBinding extractedBinding, final IProgressMonitor monitor) throws JavaModelException {
	Assert.isNotNull(subRewrite);
	Assert.isNotNull(declaration);
	Assert.isNotNull(extractedType);
	Assert.isNotNull(monitor);
	try {
		monitor.beginTask(RefactoringCoreMessages.ExtractSupertypeProcessor_preparing, 10);
		final AST ast= subRewrite.getAST();
		Type type= null;
		if (extractedBinding != null) {
			type= subRewrite.getImportRewrite().addImport(extractedBinding, ast);
		} else {
			subRewrite.getImportRewrite().addImport(extractedType.getFullyQualifiedName('.'));
			type= ast.newSimpleType(ast.newSimpleName(extractedType.getElementName()));
		}
		subRewrite.getImportRemover().registerAddedImport(extractedType.getFullyQualifiedName('.'));
		if (type != null) {
			final ITypeParameter[] parameters= extractedType.getTypeParameters();
			if (parameters.length > 0) {
				final ParameterizedType parameterized= ast.newParameterizedType(type);
				for (int index= 0; index < parameters.length; index++)
					parameterized.typeArguments().add(ast.newSimpleType(ast.newSimpleName(parameters[index].getElementName())));
				type= parameterized;
			}
		}
		final ASTRewrite rewriter= subRewrite.getASTRewrite();
		if (type != null && declaration instanceof TypeDeclaration) {
			final TypeDeclaration extended= (TypeDeclaration) declaration;
			final Type superClass= extended.getSuperclassType();
			if (superClass != null) {
				rewriter.replace(superClass, type, subRewrite.createCategorizedGroupDescription(RefactoringCoreMessages.ExtractSupertypeProcessor_add_supertype, SET_EXTRACT_SUPERTYPE));
				subRewrite.getImportRemover().registerRemovedNode(superClass);
			} else
				rewriter.set(extended, TypeDeclaration.SUPERCLASS_TYPE_PROPERTY, type, subRewrite.createCategorizedGroupDescription(RefactoringCoreMessages.ExtractSupertypeProcessor_add_supertype, SET_EXTRACT_SUPERTYPE));
		}
	} finally {
		monitor.done();
	}
}
 

/**
 * Creates the type signature of the extracted supertype.
 *
 * @param targetRewrite
 *            the target compilation unit rewrite
 * @param superType
 *            the super type, or <code>null</code> if no super type (ie.
 *            <code>java.lang.Object</code>) is available
 * @param declaringDeclaration
 *            the declaration of the declaring type
 * @param targetDeclaration
 *            the type declaration of the target type
 */
protected final void createTypeSignature(final CompilationUnitRewrite targetRewrite, final IType superType, final AbstractTypeDeclaration declaringDeclaration, final AbstractTypeDeclaration targetDeclaration) {
	Assert.isNotNull(targetRewrite);
	Assert.isNotNull(declaringDeclaration);
	Assert.isNotNull(targetDeclaration);
	if (declaringDeclaration instanceof TypeDeclaration) {
		final TypeDeclaration declaration= (TypeDeclaration) declaringDeclaration;
		final Type superclassType= declaration.getSuperclassType();
		if (superclassType != null) {
			Type type= null;
			final ITypeBinding binding= superclassType.resolveBinding();
			if (binding != null) {
				type= targetRewrite.getImportRewrite().addImport(binding, targetRewrite.getAST());
				targetRewrite.getImportRemover().registerAddedImports(type);
			}
			if (type != null && targetDeclaration instanceof TypeDeclaration) {
				final TypeDeclaration extended= (TypeDeclaration) targetDeclaration;
				final Type targetSuperType= extended.getSuperclassType();
				if (targetSuperType != null) {
					targetRewrite.getASTRewrite().replace(targetSuperType, type, null);
				} else {
					targetRewrite.getASTRewrite().set(extended, TypeDeclaration.SUPERCLASS_TYPE_PROPERTY, type, null);
				}
			}
		}
	}
}
 

@Override
public boolean visit(final TypeDeclaration node) {
	for (final Object supType : node.superInterfaceTypes()) {
		Type superType = (Type) supType;
		if (superType.isParameterizedType()) {
			superType = ((ParameterizedType) superType).getType();
		}
		final String qName = superType.resolveBinding().getErasure()
				.getQualifiedName();
		if (className.isEmpty()) {
			addTypes(qName, currentPackageName + "." + node.getName());
		} else {
			addTypes(qName, className.peek() + "." + node.getName());
		}
	}

	Type superclassType = node.getSuperclassType();
	if (superclassType != null) {
		if (superclassType.isParameterizedType()) {
			superclassType = ((ParameterizedType) superclassType)
					.getType();
		}
		addTypes(superclassType.resolveBinding().getQualifiedName(),
				currentPackageName + "." + node.getName());
	}

	if (className.isEmpty()) {
		className.push(currentPackageName + "."
				+ node.getName().getIdentifier());
		importedNames.put(node.getName().getIdentifier(),
				currentPackageName + "."
						+ node.getName().getIdentifier());
	} else {
		className.push(className.peek() + "."
				+ node.getName().getIdentifier());
		importedNames
				.put(node.getName().getIdentifier(), className.peek()
						+ "." + node.getName().getIdentifier());
	}
	return true;
}
 

@Override
public boolean visit(final TypeDeclaration node) {
	for (final Object supType : node.superInterfaceTypes()) {
		Type superType = (Type) supType;
		if (superType.isParameterizedType()) {
			superType = ((ParameterizedType) superType).getType();
		}
		final String qName = superType.resolveBinding().getErasure()
				.getQualifiedName();
		if (className.isEmpty()) {
			addTypes(qName, currentPackageName + "." + node.getName());
		} else {
			addTypes(qName, className.peek() + "." + node.getName());
		}
	}

	Type superclassType = node.getSuperclassType();
	if (superclassType != null) {
		if (superclassType.isParameterizedType()) {
			superclassType = ((ParameterizedType) superclassType)
					.getType();
		}
		addTypes(superclassType.resolveBinding().getQualifiedName(),
				currentPackageName + "." + node.getName());
	}

	if (className.isEmpty()) {
		className.push(currentPackageName + "."
				+ node.getName().getIdentifier());
		importedNames.put(node.getName().getIdentifier(),
				currentPackageName + "."
						+ node.getName().getIdentifier());
	} else {
		className.push(className.peek() + "."
				+ node.getName().getIdentifier());
		importedNames
				.put(node.getName().getIdentifier(), className.peek()
						+ "." + node.getName().getIdentifier());
	}
	return true;
}
 

@SuppressWarnings("unchecked")
@Override
public boolean visit(TypeDeclaration node) {
	ITypeBinding binding = node.resolveBinding();
	if (binding == null) {
		logNullBinding("type declaration", node.getName(),
				((CompilationUnit) node.getRoot()).getLineNumber(node.getStartPosition()));
		return false;
	}
	Type type = importer.ensureTypeFromTypeBinding(binding);

	org.eclipse.jdt.core.dom.Type superclassType = node.getSuperclassType();
	/*
	 * This is an ugly patch. When the binding to the superclass or super interfaces
	 * cannot be resolved, we try to recover as much info as possible We do it here
	 * because it is hard to pass around the dom type
	 */
	if (binding.getSuperclass() == null && superclassType != null)
		importer.createInheritanceFromSubtypeToSuperDomType(type, superclassType);

	if (superclassType != null)
		type.getSuperInheritances().stream().filter(inheritance -> (inheritance.getSuperclass() instanceof Class
				&& !((Class) inheritance.getSuperclass()).getIsInterface())
				|| (inheritance.getSuperclass() instanceof ParameterizedType
						&& ((ParameterizedType) inheritance.getSuperclass()).getParameterizableClass() != null
						&& !((ParameterizedType) inheritance.getSuperclass()).getParameterizableClass()
								.getIsInterface()))
				.findFirst().ifPresent(in -> importer.createLightweightSourceAnchor(in, superclassType));

	if (binding.getInterfaces().length == 0 && !node.superInterfaceTypes().isEmpty())
		node.superInterfaceTypes().stream().forEach(t -> {
			importer.createInheritanceFromSubtypeToSuperDomType(type, (org.eclipse.jdt.core.dom.Type) t);
		});

	// create source anchors for implemented interfaces references
	createSourceAnchorsForInterfaceInheritance(node, type);

	type.setIsStub(false);
	importer.createSourceAnchor(type, node);
	importer.createLightweightSourceAnchor(type, node.getName());
	importer.ensureCommentFromBodyDeclaration(type, node);
	importer.pushOnContainerStack(type);
	return true;
}
 

@Override
public boolean visit(final TypeDeclaration node) {
	for (final Object supType : node.superInterfaceTypes()) {
		Type superType = (Type) supType;
		if (superType.isParameterizedType()) {
			superType = ((ParameterizedType) superType).getType();
		}
		final String qName = superType.resolveBinding().getErasure()
				.getQualifiedName();
		if (className.isEmpty()) {
			addTypes(qName, currentPackageName + "." + node.getName());
		} else {
			addTypes(qName, className.peek() + "." + node.getName());
		}
	}

	Type superclassType = node.getSuperclassType();
	if (superclassType != null) {
		if (superclassType.isParameterizedType()) {
			superclassType = ((ParameterizedType) superclassType)
					.getType();
		}
		addTypes(superclassType.resolveBinding().getQualifiedName(),
				currentPackageName + "." + node.getName());
	}

	if (className.isEmpty()) {
		className.push(currentPackageName + "."
				+ node.getName().getIdentifier());
		importedNames.put(node.getName().getIdentifier(),
				currentPackageName + "."
						+ node.getName().getIdentifier());
	} else {
		className.push(className.peek() + "."
				+ node.getName().getIdentifier());
		importedNames
				.put(node.getName().getIdentifier(), className.peek()
						+ "." + node.getName().getIdentifier());
	}
	return true;
}
 

@Override
public boolean visit(final TypeDeclaration it) {
  boolean _isDummyType = this._aSTFlattenerUtils.isDummyType(it);
  if (_isDummyType) {
    this.visitAll(it.bodyDeclarations(), this.nl());
    return false;
  }
  boolean _isNotSupportedInnerType = this._aSTFlattenerUtils.isNotSupportedInnerType(it);
  if (_isNotSupportedInnerType) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("/* FIXME Non-static inner classes are not supported.*/");
    this.appendToBuffer(_builder.toString());
    this.addProblem(it, "Non-static inner classes are not supported.");
  }
  Javadoc _javadoc = it.getJavadoc();
  boolean _tripleNotEquals = (_javadoc != null);
  if (_tripleNotEquals) {
    it.getJavadoc().accept(this);
  }
  this.appendModifiers(it, it.modifiers());
  boolean _isInterface = it.isInterface();
  if (_isInterface) {
    this.appendToBuffer("interface ");
  } else {
    boolean _isPackageVisibility = this._aSTFlattenerUtils.isPackageVisibility(Iterables.<Modifier>filter(it.modifiers(), Modifier.class));
    if (_isPackageVisibility) {
      this.appendToBuffer("package ");
    }
    this.appendToBuffer("class ");
  }
  it.getName().accept(this);
  boolean _isEmpty = it.typeParameters().isEmpty();
  boolean _not = (!_isEmpty);
  if (_not) {
    this.appendTypeParameters(it.typeParameters());
  }
  this.appendSpaceToBuffer();
  Type _superclassType = it.getSuperclassType();
  boolean _tripleNotEquals_1 = (_superclassType != null);
  if (_tripleNotEquals_1) {
    this.appendToBuffer("extends ");
    it.getSuperclassType().accept(this);
    this.appendSpaceToBuffer();
  }
  boolean _isEmpty_1 = it.superInterfaceTypes().isEmpty();
  boolean _not_1 = (!_isEmpty_1);
  if (_not_1) {
    boolean _isInterface_1 = it.isInterface();
    if (_isInterface_1) {
      this.appendToBuffer("extends ");
    } else {
      this.appendToBuffer("implements ");
    }
    this.visitAllSeparatedByComma(it.superInterfaceTypes());
  }
  this.appendToBuffer("{");
  this.increaseIndent();
  BodyDeclaration prev = null;
  List _bodyDeclarations = it.bodyDeclarations();
  for (final BodyDeclaration body : ((Iterable<BodyDeclaration>) _bodyDeclarations)) {
    {
      if ((prev instanceof EnumConstantDeclaration)) {
        if ((body instanceof EnumConstantDeclaration)) {
          this.appendToBuffer(", ");
        } else {
          this.appendToBuffer("; ");
        }
      }
      this.appendLineWrapToBuffer();
      body.accept(this);
      prev = body;
    }
  }
  ASTNode _root = it.getRoot();
  if ((_root instanceof CompilationUnit)) {
    ASTNode _root_1 = it.getRoot();
    final CompilationUnit cu = ((CompilationUnit) _root_1);
    final Consumer<Comment> _function = (Comment it_1) -> {
      it_1.accept(this);
      this.assignedComments.add(it_1);
    };
    this.unAssignedComments(cu).forEach(_function);
  }
  this.decreaseIndent();
  this.appendLineWrapToBuffer();
  this.appendToBuffer("}");
  return false;
}
 

public static ClassBean parse(TypeDeclaration pClassNode, String belongingPackage, List<String> imports) {
    int numberOfGetterOrSetter = 0;

    // Instantiate the bean
    ClassBean classBean = new ClassBean();

    if (pClassNode.getSuperclassType() != null) {
        classBean.setSuperclass(pClassNode.getSuperclassType().toString());
    } else {
        classBean.setSuperclass(null);
    }

    // Set the name
    classBean.setName(pClassNode.getName().toString());
    classBean.setImports(imports);
    classBean.setBelongingPackage(belongingPackage);

    // Get the instance variable nodes 
    Collection<FieldDeclaration> instanceVariableNodes = new ArrayList<>();
    pClassNode.accept(new InstanceVariableVisitor(instanceVariableNodes));

    classBean.setTextContent(pClassNode.toString());

    Pattern newLine = Pattern.compile("\n");
    String[] lines = newLine.split(pClassNode.toString());

    classBean.setLOC(lines.length);

    // Get the instance variable beans from the instance variable nodes
    Collection<InstanceVariableBean> instanceVariableBeans = new ArrayList<>();
    for (FieldDeclaration instanceVariableNode : instanceVariableNodes) {
        instanceVariableBeans.add(InstanceVariableParser.parse(instanceVariableNode));
    }

    // Set the collection of instance variables
    classBean.setInstanceVariables(instanceVariableBeans);

    // Get the method nodes
    Collection<MethodDeclaration> methodNodes = new ArrayList<>();
    pClassNode.accept(new MethodVisitor(methodNodes));

    // Get the method beans from the method nodes
    Collection<MethodBean> methodBeans = new ArrayList<>();
    for (MethodDeclaration methodNode : methodNodes) {

        if ((methodNode.getName().toString().contains("get") || (methodNode.getName().toString().contains("set")))) {
            if (methodNode.parameters().isEmpty()) {
                numberOfGetterOrSetter++;
            }
        }

        methodBeans.add(MethodParser.parse(methodNode, instanceVariableBeans));
    }

    classBean.setNumberOfGetterAndSetter(numberOfGetterOrSetter);

    // Iterate over the collection of methods
    for (MethodBean classMethod : methodBeans) {

        // Instantiate a collection of class-defined invocations
        Collection<MethodBean> definedInvocations = new ArrayList<>();

        // Get the method invocations
        Collection<MethodBean> classMethodInvocations = classMethod.getMethodCalls();

        // Iterate over the collection of method invocations
        for (MethodBean classMethodInvocation : classMethodInvocations) {
            definedInvocations.add(classMethodInvocation);
        }

        // Set the class-defined invocations
        classMethod.setMethodCalls(definedInvocations);
    }

    // Set the collection of methods
    classBean.setMethods(methodBeans);

    return classBean;

}
 

public static ClassBean parse(TypeDeclaration pClassNode) {
    int numberOfGetterOrSetter = 0;

    // Instantiate the bean
    ClassBean classBean = new ClassBean();

    if (pClassNode.getSuperclassType() != null) {
        classBean.setSuperclass(pClassNode.getSuperclassType().toString());
    } else {
        classBean.setSuperclass(null);
    }

    // Set the name
    classBean.setName(pClassNode.getName().toString());

    // Get the instance variable nodes 
    Collection<FieldDeclaration> instanceVariableNodes = new ArrayList<>();
    pClassNode.accept(new InstanceVariableVisitor(instanceVariableNodes));

    classBean.setTextContent(pClassNode.toString());

    Pattern newLine = Pattern.compile("\n");
    String[] lines = newLine.split(pClassNode.toString());

    classBean.setLOC(lines.length);

    // Get the instance variable beans from the instance variable nodes
    Collection<InstanceVariableBean> instanceVariableBeans = new ArrayList<>();
    for (FieldDeclaration instanceVariableNode : instanceVariableNodes) {
        instanceVariableBeans.add(InstanceVariableParser.parse(instanceVariableNode));
    }

    // Set the collection of instance variables
    classBean.setInstanceVariables(instanceVariableBeans);

    // Get the method nodes
    Collection<MethodDeclaration> methodNodes = new ArrayList<>();
    pClassNode.accept(new MethodVisitor(methodNodes));

    // Get the method beans from the method nodes
    Collection<MethodBean> methodBeans = new ArrayList<>();
    for (MethodDeclaration methodNode : methodNodes) {

        if ((methodNode.getName().toString().contains("get") || (methodNode.getName().toString().contains("set")))) {
            if (methodNode.parameters().isEmpty()) {
                numberOfGetterOrSetter++;
            }
        }

        methodBeans.add(MethodParser.parse(methodNode, instanceVariableBeans));
    }

    classBean.setNumberOfGetterAndSetter(numberOfGetterOrSetter);

    // Iterate over the collection of methods
    for (MethodBean classMethod : methodBeans) {

        // Instantiate a collection of class-defined invocations
        Collection<MethodBean> definedInvocations = new ArrayList<>();

        // Get the method invocations
        Collection<MethodBean> classMethodInvocations = classMethod.getMethodCalls();

        // Iterate over the collection of method invocations
        for (MethodBean classMethodInvocation : classMethodInvocations) {
            definedInvocations.add(classMethodInvocation);
        }

        // Set the class-defined invocations
        classMethod.setMethodCalls(definedInvocations);
    }

    // Set the collection of methods
    classBean.setMethods(methodBeans);

    return classBean;

}