/**
  *
  *                      OOAS Compiler
  *
  *       Copyright 2015, AIT Austrian Institute of Technology.
  * This code is based on the C# Version of the OOAS Compiler, which is
  * copyright 2015 by the Institute of Software Technology, Graz University
  * of Technology with portions copyright by the AIT Austrian Institute of
  * Technology. All rights reserved.
  *
  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.
  *
  * If you modify the file please update the list of contributors below to in-
  * clude your name. Please also stick to the coding convention of using TABs
  * to do the basic (block-level) indentation and spaces for anything after
  * that. (Enable the display of special chars and it should be pretty obvious
  * what this means.) Also, remove all trailing whitespace.
  *
  * Contributors:
  *               Willibald Krenn (AIT)
  *               Stephan Zimmerer (AIT)
  *               Markus Demetz (AIT)
  *               Christoph Czurda (AIT)
  *
  */


package org.momut.ooas.ast;

import org.momut.ooas.ast.expressions.AccessExpression;
import org.momut.ooas.ast.expressions.BinaryOperator;
import org.momut.ooas.ast.expressions.CallExpression;
import org.momut.ooas.ast.expressions.ExistsQuantifier;
import org.momut.ooas.ast.expressions.ForallQuantifier;
import org.momut.ooas.ast.expressions.IdentifierExpression;
import org.momut.ooas.ast.expressions.ListConstructor;
import org.momut.ooas.ast.expressions.MapConstructor;
import org.momut.ooas.ast.expressions.ObjectConstructor;
import org.momut.ooas.ast.expressions.SetConstructor;
import org.momut.ooas.ast.expressions.TernaryOperator;
import org.momut.ooas.ast.expressions.TupleConstructor;
import org.momut.ooas.ast.expressions.TupleMapAccessExpression;
import org.momut.ooas.ast.expressions.TypeExpression;
import org.momut.ooas.ast.expressions.UnaryOperator;
import org.momut.ooas.ast.expressions.UnresolvedIdentifierExpression;
import org.momut.ooas.ast.expressions.ValueExpression;
import org.momut.ooas.ast.identifiers.AttributeIdentifier;
import org.momut.ooas.ast.identifiers.ConstantIdentifier;
import org.momut.ooas.ast.identifiers.EnumIdentifier;
import org.momut.ooas.ast.identifiers.ExpressionVariableIdentifier;
import org.momut.ooas.ast.identifiers.LocalVariableIdentifier;
import org.momut.ooas.ast.identifiers.MainModule;
import org.momut.ooas.ast.identifiers.MethodIdentifier;
import org.momut.ooas.ast.identifiers.Module;
import org.momut.ooas.ast.identifiers.NamedActionIdentifier;
import org.momut.ooas.ast.identifiers.NondetIdentifierList;
import org.momut.ooas.ast.identifiers.ParameterIdentifier;
import org.momut.ooas.ast.identifiers.PrioIdentifierList;
import org.momut.ooas.ast.identifiers.SelfTypeIdentifier;
import org.momut.ooas.ast.identifiers.SeqIdentifierList;
import org.momut.ooas.ast.identifiers.TypeIdentifier;
import org.momut.ooas.ast.identifiers.UnspecIdentifierList;
import org.momut.ooas.ast.statements.AbortStatement;
import org.momut.ooas.ast.statements.Assignment;
import org.momut.ooas.ast.statements.BreakStatement;
import org.momut.ooas.ast.statements.Call;
import org.momut.ooas.ast.statements.GuardedCommand;
import org.momut.ooas.ast.statements.KillStatement;
import org.momut.ooas.ast.statements.NondetBlock;
import org.momut.ooas.ast.statements.PrioBlock;
import org.momut.ooas.ast.statements.SeqBlock;
import org.momut.ooas.ast.statements.SkipStatement;
import org.momut.ooas.ast.types.AnyType;
import org.momut.ooas.ast.types.BoolType;
import org.momut.ooas.ast.types.CharType;
import org.momut.ooas.ast.types.EnumType;
import org.momut.ooas.ast.types.FloatType;
import org.momut.ooas.ast.types.FunctionType;
import org.momut.ooas.ast.types.IntType;
import org.momut.ooas.ast.types.ListType;
import org.momut.ooas.ast.types.MapType;
import org.momut.ooas.ast.types.MetaType;
import org.momut.ooas.ast.types.NullType;
import org.momut.ooas.ast.types.OoActionSystemType;
import org.momut.ooas.ast.types.OpaqueType;
import org.momut.ooas.ast.types.TupleType;

/*Notice: The visitor must implement the traversal!*/
public interface IAstVisitor
{
	String returnVisitorName();
	void done();

	/*Identifiers*/
	void visit(EnumIdentifier enumIdentifier);
	void visit(AttributeIdentifier attributeIdentifier);
	void visit(ExpressionVariableIdentifier expressionVariableIdentifier);
	void visit(ParameterIdentifier parameterIdentifier);
	void visit(LocalVariableIdentifier localVariableIdentifier);
	void visit(TypeIdentifier typeIdentifier);
	void visit(SelfTypeIdentifier typeIdentifier);
	void visit(MethodIdentifier methodIdentifier);
	void visit(NamedActionIdentifier namedActionIdentifier);
	void visit(MainModule mainModule);
	void visit(Module module);
	void visit(NondetIdentifierList nondetIdentifierList);
	void visit(SeqIdentifierList seqIdentifierList);
	void visit(PrioIdentifierList prioIdentifierList);
	void visit(UnspecIdentifierList unspecIdentifierList);
	void visit(ConstantIdentifier constantIdentifier);


	/*Statements*/
	void visit(NondetBlock nondetBlock);
	void visit(SeqBlock seqBlock);
	void visit(PrioBlock prioBlock);
	void visit(GuardedCommand guardedCommand);
	void visit(Assignment assignment);
	void visit(Call call);
	void visit(SkipStatement skipStatement);
	void visit(AbortStatement abortStatement);
	void visit(KillStatement killStatement);


	/*Expressions*/
	<T> void visit(ValueExpression<T> valueExpression);
	void visit(UnresolvedIdentifierExpression unresolvedIdentifierExpression);
	void visit(IdentifierExpression identifierExpression);
	void visit(ListConstructor listConstructor);
	void visit(SetConstructor setConstructor);
	void visit(MapConstructor mapConstructor);
	void visit(TupleConstructor tupleConstructor);
	void visit(ObjectConstructor objectConstructor);
	void visit(AccessExpression accessExpression);
	void visit(BinaryOperator binaryOperator);
	void visit(TernaryOperator ternaryOperator);
	void visit(TupleMapAccessExpression tupleMapAccessExpression);
	void visit(CallExpression callExpression);
	void visit(ForallQuantifier quantifier);
	void visit(ExistsQuantifier quantifier);
	void visit(UnaryOperator unaryOperator);
	void visit(TypeExpression typeExpression);

	/*Types*/
	void visit(CharType charType);
	void visit(IntType intType);
	void visit(BoolType boolType);
	void visit(FloatType floatType);
	void visit(EnumType enumType);
	void visit(ListType listType);
	void visit(MapType mapType);
	void visit(TupleType tupleType);
	void visit(FunctionType functionType);
	void visit(OoActionSystemType ooActionSystemType);
	void visit(OpaqueType opaqueType);
	void visit(AnyType anyType);
	void visit(NullType nullType);
	void visit(MetaType metaType);

	void visit(BreakStatement breakStatement);
}