/*

  * Copyright (c) 2007 David Holroyd

  */

 package uk.co.badgersinfoil.asxsd.components;

 import org.eclipse.xsd.XSDElementDeclaration;

 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.MarshalBuilder;

 import uk.co.badgersinfoil.asxsd.TypeDescriptor;

 import uk.co.badgersinfoil.metaas.ActionScriptFactory;

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

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

 public class OptionallyOccuringParticleComponent extends AbstractParticleComponent {

         protected void generateCodeFor(CodegenContext context,

                                        XSDParticle particle)

         {

                 CodegenRole role = context.getCurrentRole();

                 XSDParticleContent content = particle.getContent();

                 if (role == CodegenRole.UNMARSHAL) {

                         StatementContainer block = context.getCurrentMethodCode();

                         block = unmarshalDetectStmt(context, content, block);

                         context.pushAttrScope();

                         context.setCurrentMethodCode(block);

                         context.generateCode(content);

                         context.popAttrScope();

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

                         StatementContainer containingBlock = context.getCurrentMethodCode();

                         ASExpression detectExpr= marshalDetectExpr(context, content);

                         StatementContainer ifBlock = containingBlock.newIf(detectExpr);

                         context.pushAttrScope();

                         String src = MarshalBuilder.getCurrentSourceExpr(context);

                         String access;

                         if (content instanceof XSDElementDeclaration) {

                                 access = src + "." + context.variableNameFor(content);

                         } else {

                                 access = src;

                         }

                         MarshalBuilder.setCurrentSourceExpr(context, access);

                         context.setCurrentMethodCode(ifBlock);

                         context.generateCode(content);

                         // switch back to the original block,

                         context.popAttrScope();

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

                         context.generateCode(content);

                 } else {

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

                 }

         }

         private StatementContainer unmarshalDetectStmt(CodegenContext context,

                                                        XSDParticleContent content,

                                                        StatementContainer block)

         {

                 ActionScriptFactory fact = context.getFactory();

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

                 ASExpression detect = unmarshalDetectExpr(context, content);

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

                 // TODO: don't strictly need to test that there are remaining elements if we know there should be mandatory elements following this optional one,

                 return block.newIf(conditional);

         }

         private ASExpression unmarshalDetectExpr(CodegenContext context,

                                     XSDParticleContent content)

         {

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.UNMARSHAL_DETECT);

                 ASExpression detect = context.createExpression(content);

                 context.popAttrScope();

                 return detect;

         }

         private ASExpression marshalDetectExpr(CodegenContext context,

                                     XSDParticleContent content)

         {

                 context.pushAttrScope();

                 context.setCurrentRole(CodegenRole.MARSHAL_DETECT);

                 ASExpression detect = context.createExpression(content);

                 context.popAttrScope();

                 return detect;

         }

         protected TypeDescriptor typeDescriptorFor(CodegenContext context,

                         XSDParticle particle) {

                 // just return the type-desc for the particle's content

                 XSDParticleContent partContent = particle.getContent();

                 return context.typeDescriptorFor(partContent);

         }

         protected boolean willAcceptParticle(XSDParticle particle) {

                 return particle.getMaxOccurs()==1

                     && particle.getMinOccurs()==0;

         }

 }