core/plugins/org.eclipse.dltk.core/model/org/eclipse/dltk/core/caching/StructureModelProcessor.java

package org.eclipse.dltk.core.caching;

import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;

import org.eclipse.dltk.compiler.IElementRequestor.ElementInfo;
import org.eclipse.dltk.compiler.IElementRequestor.FieldInfo;
import org.eclipse.dltk.compiler.IElementRequestor.ImportInfo;
import org.eclipse.dltk.compiler.IElementRequestor.MethodInfo;
import org.eclipse.dltk.compiler.IElementRequestor.TypeInfo;
import org.eclipse.dltk.compiler.ISourceElementRequestor;

public class StructureModelProcessor extends AbstractDataLoader implements
		IStructureConstants {

	private ISourceElementRequestor requestor;

	public StructureModelProcessor(InputStream stream,
			ISourceElementRequestor requestor) {
		super(stream);
		this.requestor = requestor;
	}

	public void perform() throws IOException {
		readStrings();
		readData();
	}

	private void readData() {
		while (true) {
			try {
				int tag = in.readInt();
				switch (tag) {
				case TAG_FIELD_REFERENCE:
					acceptFieldReference();
					break;
				case TAG_METHOD_REF1:
					acceptMethodReference();
					break;
				case TAG_PACKAGE:
					acceptPackage();
					break;
				case TAG_TYPE_REFERENCE1:
					acceptTypeReference1();
					break;
				case TAG_TYPE_REFERENCE2:
					acceptTypeReference2();
					break;
				case TAG_ENTER_FIELD:
					enterField();
					break;
				case TAG_ENTER_FIELD_DUPL:
					enterFieldCheckDuplicates();
					break;
				case TAG_ENTER_FIELD_WITH_PARENT:
					enterFieldWithParentType();
					break;
				case TAG_ENTER_METHOD:
					enterMethod();
					break;
				case TAG_ENTER_METHOD_REMOVE_SAME:
					enterMethodRemoveSame();
					break;
				case TAG_ENTER_METHOD_WITH_PARENT:
					enterMethodWithParentType();
					break;
				case TAG_ENTER_MODULE:
					enterModule();
					break;
				case TAG_ENTER_MODULE_ROOT:
					enterModuleRoot();
					break;
				case TAG_ENTER_TYPE:
					enterType();
					break;
				case TAG_ENTER_TYPE_APPEND:
					enterTypeAppend();
					break;
				case TAG_EXIT_FIELD:
					exitField();
					break;
				case TAG_EXIT_METHOD:
					exitMethod();
					break;
				case TAG_EXIT_MODULE:
					exitModule();
					break;
				case TAG_EXIT_MODULE_ROOT:
					exitModuleRoot();
					break;
				case TAG_EXIT_TYPE:
					exitType();
					break;
				case TAG_ACCEPT_IMPORT:
					acceptImport();
					break;
				}
			} catch (EOFException e) {
				break;

			} catch (IOException e) {
				break;
			}
		}

	}

	private char[] readDataString() throws IOException {
		String text = readString();
		if (text == null) {
			return null;
		}
		return text.toCharArray();
	}

	private char[][] readDataStrings() throws IOException {
		int size = in.readInt();
		if (size == 0) {
			return null;
		}

		char[][] result = new char[size][];
		for (int i = 0; i < size; ++i) {
			result[i] = readDataString();
		}
		return result;
	}

	private String[] readDataStringsStr() throws IOException {
		int size = in.readInt();
		if (size == 0) {
			return null;
		}

		String[] result = new String[size];
		for (int i = 0; i < size; ++i) {
			result[i] = readString();
		}
		return result;
	}

	public void acceptFieldReference() {
		try {
			String fieldName = readString();
			int sourcePosition = in.readInt();
			this.requestor.acceptFieldReference(fieldName, sourcePosition);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void acceptMethodReference() {
		try {
			String methodName = readString();
			int argCount = in.readInt();
			int sourcePosition = in.readInt();
			int sourceEndPosition = in.readInt();
			this.requestor.acceptMethodReference(methodName, argCount,
					sourcePosition, sourceEndPosition);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void acceptPackage() {
		try {
			String name = readString();
			int declarationStart = in.readInt();
			int declarationEnd = in.readInt();
			this.requestor
					.acceptPackage(declarationStart, declarationEnd, name);

		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void acceptTypeReference1() {
		try {
			/* char[][] typeName = */readDataStrings();
			/* int sourceStart = */in.readInt();
			/* int sourceEnd = */in.readInt();
			// this.requestor.acceptTypeReference(typeName, sourceStart,
			// sourceEnd);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void acceptTypeReference2() {
		try {
			String typeName = readString();
			int sourcePosition = in.readInt();
			this.requestor.acceptTypeReference(typeName, sourcePosition);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void enterField() {
		try {
			FieldInfo info = new FieldInfo();
			readFieldInfo(info);
			this.requestor.enterField(info);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void readFieldInfo(FieldInfo info) throws IOException {
		readElementInfo(info);
	}

	private void readMethodInfo(MethodInfo info) throws IOException {
		readElementInfo(info);
		info.parameterNames = readDataStringsStr();
		info.parameterInitializers = readDataStringsStr();
		info.exceptionTypes = readDataStringsStr();
		info.isConstructor = in.readBoolean();
	}

	private void readTypeInfo(TypeInfo info) throws IOException {
		readElementInfo(info);
		info.superclasses = readDataStringsStr();
	}

	private void readElementInfo(ElementInfo info) throws IOException {
		info.name = readString();
		info.modifiers = in.readInt();
		info.nameSourceStart = in.readInt();
		info.nameSourceEnd = in.readInt();
		info.declarationStart = in.readInt();
	}

	public boolean enterFieldCheckDuplicates() {
		try {
			FieldInfo info = new FieldInfo();
			readFieldInfo(info);
			boolean result = in.readBoolean();
			this.requestor.enterFieldCheckDuplicates(info);
			return result;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}

	private boolean enterFieldWithParentType() {
		boolean result = false;
		try {
			FieldInfo info = new FieldInfo();
			readFieldInfo(info);
			/* String parentName = */readString();
			/* String delimiter = */readString();
			in.readBoolean();
			// requestor.enterFieldWithParentType(info, parentName, delimiter);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

	public void enterMethod() {
		try {
			MethodInfo info = new MethodInfo();
			readMethodInfo(info);
			this.requestor.enterMethod(info);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void enterMethodRemoveSame() {
		try {
			MethodInfo info = new MethodInfo();
			readMethodInfo(info);
			this.requestor.enterMethodRemoveSame(info);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private boolean enterMethodWithParentType() {
		boolean result = false;
		try {
			MethodInfo info = new MethodInfo();
			readMethodInfo(info);
			/* String parentName = */readString();
			/* String delimiter = */readString();
			// result = this.requestor.enterMethodWithParentType(info,
			// parentName,
			// delimiter);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

	public void enterModule() {
		this.requestor.enterModule();
	}

	public void enterModuleRoot() {
		this.requestor.enterModuleRoot();
	}

	public void enterType() {
		try {
			TypeInfo info = new TypeInfo();
			readTypeInfo(info);
			this.requestor.enterType(info);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public boolean enterTypeAppend() {
		try {
			String fullName = readString();
			String delimiter = readString();
			return this.requestor.enterTypeAppend(fullName, delimiter);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}

	public void exitField() {
		try {
			this.requestor.exitField(in.readInt());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void exitMethod() {
		try {
			this.requestor.exitMethod(in.readInt());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void exitModule() {
		try {
			this.requestor.exitModule(in.readInt());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void exitModuleRoot() {
		this.requestor.exitModuleRoot();
	}

	public void exitType() {
		try {
			this.requestor.exitType(in.readInt());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void acceptImport() {
		try {
			ImportInfo importInfo = new ImportInfo();
			importInfo.sourceStart = in.readInt();
			importInfo.sourceEnd = in.readInt();
			importInfo.containerName = readString();
			importInfo.name = readString();
			importInfo.version = readString();
			this.requestor.acceptImport(importInfo);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}