CPD Results

The following document contains the results of PMD's CPD 5.3.2.

Duplications

File Line
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 1166
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 1305
	private void acceptVisitorInAstTypePartial(final Type astType,
			final GenInterfaceClass visitor,
			final GenJavaOperation accept,
			final boolean isVoid,
			final boolean hasException) throws TaskException {
		astType.accept(new TypeVisitorException<TaskException>() {
			
			@Override
			public void handle(final AtomicType s) throws TaskException {
				s.accept(new AtomicTypeVisitorException<TaskException>() {
					
					@Override
					public void handle(final BaseType b) throws TaskException {
						VisitorTypeTransformer.this.addAcceptOperationToBaseType(b, accept);
						final GenType genType = VisitorTypeTransformer.this.getGeneratorModel().getGenTypeForType(b);
						VisitorTypeTransformer.this.addHandleOperation(visitor, genType, isVoid, hasException);
					}
					
					@Override
					public void handle(final ClassType c) throws TaskException {
						final GenClass genType =
								(GenClass) VisitorTypeTransformer.this.getGeneratorModel().getGenTypeForType(c);
						
						genType.accept(new GenClassVisitorException<TaskException>() {
							@Override
							public void handle(final GenClassClass classClass) throws TaskException {
								// TODO Irgendwo an dieser Stelle muss die Generierung der PartialVisitorAcceptoren für
								// Klassen
								// die von Mehrfachvererbung betroffen sind, angepasst werden.
								if (!classClass.getModifieres().contains(GenClassModifier.ABSTRACT)) {
									if (!VisitorTypeTransformer.this.hasTypeHandled(visitor, genType)) {
										VisitorTypeTransformer.this.addHandledType(visitor, genType);
										classClass.addOperation(accept);
										VisitorTypeTransformer.this.addHandleOperation(
												visitor,
												genType,
												isVoid,
												hasException);
									}
								} else {
File Line
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 462
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 603
			final Generic generic,
			final boolean full) {
		final Iterator<ClassType> i = subTypes.iterator();
		while (i.hasNext()) {
			final ClassType current = i.next();
			if (!current.isAbstract()) {
				final Vector<GenParameter> params = new Vector<>();
				final GenParameter param =
						GenParameter.create(current.getTypeName().getLastAddedName().toString().toLowerCase()
								.substring(0, 1), this.getGeneratorModel().getClassMapping().get(current));
				params.add(param);
				final Vector<GenException> exceptions = new Vector<>();
				exceptions.add(this.getCurrentException());
				final GenComment comment =
						GenComment.createFromPlainText(UtilVisitorTransformer.DEFAULT_HANDLE_COMMENT, true);
				final Vector<GenOperationModifier> modifiers = new Vector<>();
				final GenJavaOperation handleOperationClass =
						GenJavaOperation.create(
								UtilVisitorTransformer.HANDLE_OPNAME,
								GenVisibility.PUBLIC,
								params,
								exceptions,
								"",
File Line
de/fhdw/wtf/generator/writer/writer/ClassFileWriter.java 395
de/fhdw/wtf/generator/writer/writer/FileHeaderWriter.java 75
		context.put(NON_GERNATION_PART_KEY, c.getNonGeneratedPart());
	}
	
	/**
	 * Creates the Path {@link File} for c.
	 * 
	 * @param c
	 */
	private File createPath(final GenClass c, final File rootDir) {
		String path = c.getPackag().toString();
		path = path.replace(PACKAGE_PATH_SEP, FILE_PATH_SEP);
		path = path.replace(JAVA_LINE_END, FILE_PATH_SEP);
		return new File(rootDir.getAbsolutePath() + FILE_PATH_SEP + path);
	}
	
	/**
	 * Creates the {@link File} for class c.
	 * 
	 * @param path
	 * @param c
	 */
	private File createFile(final File path, final GenClass c) {
		final String file = path.getAbsolutePath() + FILE_PATH_SEP + c.getName() + c.getFileEnding();
		return new File(file);
	}
	
	/**
	 * Writes the given result into the file.
	 * 
	 * @param result
	 * @param path
	 * @param file
	 */
	private void writeFile(final String result, final File path, final File file) {
		try {
			System.out.println("  -->  " + file.getAbsolutePath());
			FileUtils.overrideToFile(result, path, file);
		} catch (final IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * Merges the context into the classtemplate.
	 * 
	 * @param context
	 */
	private String generateFileContent(final Context context) {
File Line
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 462
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 536
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 603
			final Generic generic,
			final boolean full) {
		final Iterator<ClassType> i = subTypes.iterator();
		while (i.hasNext()) {
			final ClassType current = i.next();
			if (!current.isAbstract()) {
				final Vector<GenParameter> params = new Vector<>();
				final GenParameter param =
						GenParameter.create(current.getTypeName().getLastAddedName().toString().toLowerCase()
								.substring(0, 1), this.getGeneratorModel().getClassMapping().get(current));
				params.add(param);
				final Vector<GenException> exceptions = new Vector<>();
File Line
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 947
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 1099
		sumVisitorPartialReturnException.getGenerics().add(genericException);
		paramReturnException.getGenerics().add(genericReturn2);
		paramReturnException.getGenerics().add(genericException);
		paramsReturnException.add(paramReturnException);
		final GenJavaOperation acceptReturnException =
				GenJavaOperation.create(
						UtilVisitorTransformer.ACCEPT_OPNAME,
						GenVisibility.PUBLIC,
						paramsReturnException,
						new ArrayList<GenException>(),
						UtilVisitorTransformer.ACCEPT_METHOD_RETURN,
						genericReturn2,
						new ArrayList<GenOperationModifier>(),
						GenComment.createFromPlainText(UtilVisitorTransformer.DEFAULT_ACCEPT_COMMENT, true));
		acceptReturnException.getGenerics().add(genericReturn2);
		acceptReturnException.getGenerics().add(genericException);
		this.addException(acceptReturnException, this.getCurrentException());
		this.setCurrentReturnType(genericReturn2);
File Line
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 910
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 1061
				GenParameter.create(UtilVisitorTransformer.ACCEPT_PARAMETER_NAME, sumVisitorPartialException);
		paramException.getGenerics().add(genericException);
		paramsException.add(paramException);
		final GenJavaOperation acceptException =
				GenJavaOperation.create(
						UtilVisitorTransformer.ACCEPT_OPNAME,
						GenVisibility.PUBLIC,
						paramsException,
						new ArrayList<GenException>(),
						UtilVisitorTransformer.ACCEPT_METHOD_WITHOUT_RETURN,
						GenVoidType.getInstance(),
						new ArrayList<GenOperationModifier>(),
						GenComment.createFromPlainText(UtilVisitorTransformer.DEFAULT_ACCEPT_COMMENT, true));
		acceptException.getGenerics().add(genericException);
		this.addException(acceptException, this.getGeneratorModelException(genericException));
		// construct
		this.assumeClassAndAddOperation(sumType, acceptException);
		this.acceptVisitorInSum(s, sumVisitorPartialException, acceptException, true, true, true);
File Line
de/fhdw/wtf/generator/java/generatorModel/GenFullParsedOperationState.java 184
de/fhdw/wtf/generator/java/generatorModel/GenSimpleOperationState.java 43
	}
	
	@Override
	public void accept(final GenOperationStateVisitor visitor) {
		visitor.handle(this);
	}
	
	@Override
	public <X> X accept(final GenOperationStateVisitorReturn<X> visitor) {
		return visitor.handle(this);
	}
	
	@Override
	public <Y extends Exception> void accept(final GenOperationStateVisitorException<Y> visitor) throws Y {
		visitor.handle(this);
	}
	
	@Override
	public <X, Y extends Exception> X accept(final GenOperationStateVisitorReturnException<X, Y> visitor) throws Y {
		return visitor.handle(this);
	}
File Line
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 754
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 786
	private void addVoidHandleToVisitor(final GenInterfaceClass visitor, final GenType toHandle) {
		final List<GenParameter> params = new ArrayList<>();
		params.add(GenParameter.create(toHandle.getName().toLowerCase().substring(0, 1), toHandle));
		final GenJavaOperation handle =
				GenJavaOperation.create(
						UtilVisitorTransformer.HANDLE_OPNAME,
						GenVisibility.PUBLIC,
						params,
						new ArrayList<GenException>(),
						"",
						GenVoidType.getInstance(),
						new ArrayList<GenOperationModifier>(),
						GenComment.createFromPlainText(UtilVisitorTransformer.DEFAULT_HANDLE_COMMENT, true));
File Line
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 770
de/fhdw/wtf/generator/transformer/visitorTransformation/VisitorTypeTransformer.java 803
	private void addReturnHandleToVisitor(final GenInterfaceClass visitor, final GenType toHandle) {
		final List<GenParameter> params = new ArrayList<>();
		params.add(GenParameter.create(toHandle.getName().toLowerCase().substring(0, 1), toHandle));
		final GenJavaOperation handle =
				GenJavaOperation.create(
						UtilVisitorTransformer.HANDLE_OPNAME,
						GenVisibility.PUBLIC,
						params,
						new ArrayList<GenException>(),
						"",
						this.getCurrentReturnType(),
						new ArrayList<GenOperationModifier>(),
						GenComment.createFromPlainText(UtilVisitorTransformer.DEFAULT_HANDLE_COMMENT, true));