/*

  * Copyright (c) 2006 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd;

 import java.io.IOException;

 import java.util.Iterator;

 import java.util.List;

 import org.eclipse.xsd.XSDComplexTypeDefinition;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDSchema;

 import org.eclipse.xsd.XSDTypeDefinition;

 import uk.co.badgersinfoil.metaas.ActionScriptFactory;

 import uk.co.badgersinfoil.metaas.ActionScriptProject;

 public class MappingCodeGenerator {

         private TypeNameGenerator nameGen = new TypeNameGenerator();

         private UnmarshalBuilder unmarshalerBuilder;

         private MarshalBuilder marshalerBuilder;

         private TypeBuilder typeBuilder;

         private CodegenContext context;

         public MappingCodeGenerator(ActionScriptFactory factory, ActionScriptProject project) {

                 MappingRegistry reg = MappingRegistryFactory.createMappingRegistry();

                 BaseCodegenContext ctxt = new BaseCodegenContext(reg, factory, project);

                 typeBuilder = new TypeBuilder(ctxt, nameGen);

                 ctxt.setTypeBuilder(typeBuilder);

                 unmarshalerBuilder = new UnmarshalBuilder(project, ctxt);

                 ctxt.setUnmarshalBuilder(unmarshalerBuilder);

                 marshalerBuilder = new MarshalBuilder(project, ctxt);

                 ctxt.setMarshalBuilder(marshalerBuilder);

                 context = ctxt;

         }

         public void processSchema(XSDSchema schema) throws IOException {

                 processSchemaCreateTypes(schema);

                 unmarshalerBuilder.processSchema(schema);

                 marshalerBuilder.processSchema(schema);

         }

         private void processSchemaCreateTypes(XSDSchema schema) throws IOException {

                 List types = schema.getTypeDefinitions();

                 for (Iterator i = types.iterator(); i.hasNext(); ) {

                         XSDTypeDefinition typeDef = (XSDTypeDefinition)i.next();

                         if (typeDef instanceof XSDComplexTypeDefinition) {

                                 context.typeDescriptorFor(typeDef);

                         }

                 }

         }

         public UnmarshalBuilder getUnmarshalerBuilder() {

                 return unmarshalerBuilder;

         }

         public MarshalBuilder getMarshalerBuilder() {

                 return marshalerBuilder;

         }

         public MappingFunction marshalMethodFor(XSDConcreteComponent component) {

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.MARSHAL);

                 MappingFunction fn = context.functionFor(component);

                 context.popAttrScope();

                 return fn;

         }

         public MappingFunction unmarshalMethodFor(XSDConcreteComponent component) {

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.UNMARSHAL);

                 MappingFunction fn = context.functionFor(component);

                 context.popAttrScope();

                 return fn;

         }

         public TypeDescriptor typeDescriptorFor(XSDConcreteComponent component) {

                 return context.typeDescriptorFor(component);

         }

 }