/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd.components;

 import org.eclipse.xsd.XSDConcreteComponent;

 import org.eclipse.xsd.XSDParticle;

 import org.eclipse.xsd.XSDParticleContent;

 import uk.co.badgersinfoil.asxsd.CodegenContext;

 import uk.co.badgersinfoil.asxsd.CodegenRole;

 import uk.co.badgersinfoil.asxsd.MappingFunction;

 import uk.co.badgersinfoil.asxsd.MarshalBuilder;

 import uk.co.badgersinfoil.asxsd.TypeBuilder;

 import uk.co.badgersinfoil.asxsd.TypeDescriptor;

 import uk.co.badgersinfoil.asxsd.UnmarshalBuilder;

 import uk.co.badgersinfoil.metaas.ActionScriptFactory;

 import uk.co.badgersinfoil.metaas.dom.ASClassType;

 import uk.co.badgersinfoil.metaas.dom.ASCompilationUnit;

 import uk.co.badgersinfoil.metaas.dom.ASConstants;

 import uk.co.badgersinfoil.metaas.dom.ASExpression;

 import uk.co.badgersinfoil.metaas.dom.ASField;

 import uk.co.badgersinfoil.metaas.dom.StatementContainer;

 import uk.co.badgersinfoil.metaas.dom.Visibility;

 public class MultiplyOccuringParticleComponent extends AbstractParticleComponent {

         protected TypeDescriptor createTypeDescriptor(CodegenContext context, XSDParticle particle) {

                 TypeDescriptor elementType = context.typeDescriptorFor(particle.getContent());

                 String doc = "Elements of type {@link " + elementType.getTypeName() + "}";

                 if (particle.getMinOccurs()!=0 || particle.getMaxOccurs()!=-1) {

                         doc += " (minimum "+describeMultiplicity(particle.getMinOccurs())+", maximum "+describeMultiplicity(particle.getMaxOccurs())+")";

                 }

                 return new TypeDescriptor(ASConstants.TYPE_ARRAY, true, doc, particle);

         }

         public ASCompilationUnit createType(CodegenContext context,

                                          XSDConcreteComponent component)

         {

                 return null;

         }

         /**

          * returns a text string with either the value "unbounded" if the

          * given integer is -1, or the decimal representation of the given

          * integer otherwise.

          */

         private static String describeMultiplicity(int occurs) {

                 if (occurs == -1) {

                         return "unbounded";

                 } else {

                         return String.valueOf(occurs);

                 }

         }

         protected boolean willAcceptParticle(XSDParticle particle) {

                 return particle.getMaxOccurs() != 1;

         }

         protected void generateCodeFor(CodegenContext context,

                                        XSDParticle particle)

         {

                 CodegenRole role = context.getCurrentRole();

                 XSDParticleContent content = particle.getContent();

                 if (role == CodegenRole.UNMARSHAL) {

                         StatementContainer block = context.getCurrentMethodCode();

                         String fieldAccess = "_result." + context.variableNameFor(content);

                         String accessExpr = UnmarshalBuilder.getCurrentSourceExpr(context);

                         MappingFunction unmarshaler = context.functionFor(content);

                         block.addStmt(fieldAccess + "= new Array()");

                         ActionScriptFactory fact = context.getFactory();

                         ASExpression childLimit = fact.newExpression("_seq<_children.length()");

                         ASExpression detect = detect(context, content);

                         ASExpression conditional = fact.newAndExpression(childLimit, detect);

                         block = block.newWhile(conditional);

                         block.addStmt(fieldAccess + ".push(" + unmarshaler.appliedTo(accessExpr) + ")");

                 } else if (role == CodegenRole.MARSHAL) {

                         StatementContainer containingBlock = context.getCurrentMethodCode();

                         String propertyName = context.variableNameFor(content);

                         String childVarName = propertyName + "_child";

                         String sourceExpr = MarshalBuilder.getCurrentSourceExpr(context);

                         String accessExpr = sourceExpr+"."+propertyName;

                         TypeDescriptor typeDesc = context.typeDescriptorFor(content);

                         String typeName = typeDesc.getTypeName();

                         StatementContainer forEachBlock = containingBlock.newForEachIn("var "+childVarName+":"+typeName, accessExpr);

                         context.pushAttrScope();

                         context.setCurrentMethodCode(forEachBlock);

                         MarshalBuilder.setCurrentSourceExpr(context, childVarName);

                         context.generateCode(content);

                         // switch back to the original block,

                         context.popAttrScope();

                 } else if (role == CodegenRole.TYPE) {

                         ASCompilationUnit unit = TypeBuilder.getCurrentTypeCompilationUnit(context);

                         ASClassType clazz = (ASClassType)unit.getType();

                         TypeDescriptor typeDesc = context.typeDescriptorFor(particle);

                         ASField field = clazz.newField(context.variableNameFor(content), Visibility.PUBLIC, typeDesc.getTypeName());

                         field.setDescription(typeDesc.getDocumentation());                        

                 } else {

                         throw new RuntimeException(getClass().getName()+" does not suppport operation generateCodeFor(role="+role+")");

                 }

         }

         private ASExpression detect(CodegenContext context,

                                     XSDParticleContent content)

         {

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.UNMARSHAL_DETECT);

                 ASExpression detect = context.createExpression(content);

                 context.popAttrScope();

                 return detect;

         }

 }