/*

  * 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 org.eclipse.xsd.XSDSimpleTypeDefinition;

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

 import uk.co.badgersinfoil.asxsd.UnmarshalBuilder;

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

 public class SinglyOccuringParticleComponent extends AbstractParticleComponent {

         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() == 1

                     && particle.getContent() instanceof XSDElementDeclaration;

         }

         protected void generateCodeFor(CodegenContext context,

                                        XSDParticle particle)

         {

                 CodegenRole role = context.getCurrentRole();

                 if (role == CodegenRole.UNMARSHAL) {

                         XSDElementDeclaration elementDecl = (XSDElementDeclaration)particle.getContent();

                         StatementContainer block = context.getCurrentMethodCode();

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

                         String accessExpr = UnmarshalBuilder.getCurrentSourceExpr(context);

                         if (elementDecl.getResolvedElementDeclaration().getTypeDefinition() instanceof XSDSimpleTypeDefinition) {

                                 accessExpr += ".text()";

                         }

                         MappingFunction unmarshaler = context.functionFor(particle.getContent());

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

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

                         XSDElementDeclaration elementDecl = (XSDElementDeclaration)particle.getContent();

                         String propertyName = context.variableNameFor(elementDecl);

                         String sourceExpr = MarshalBuilder.getCurrentSourceExpr(context);

                         String accessExpr = sourceExpr+"."+propertyName;

                         context.pushAttrScope();

                         MarshalBuilder.setCurrentSourceExpr(context, accessExpr);

                         context.generateCode(elementDecl);

                         context.popAttrScope();

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

                         context.generateCode(particle.getContent());

                 } else {

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

                 }

         }

 }