/*Copyright (c) 2003-2005, Dennis M. SosnoskiAll rights reserved.Redistribution and use in source and binary forms, with or without modification,are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this   list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice,   this list of conditions and the following disclaimer in the documentation   and/or other materials provided with the distribution. * Neither the name of JiBX nor the names of its contributors may be used   to endorse or promote products derived from this software without specific   prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ANDANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIEDWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AREDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FORANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ONANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THISSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.*/package org.jibx.binding.def;import java.util.ArrayList;import org.jibx.binding.classes.*;import org.jibx.runtime.JiBXException;/** * Structure binding definition. This handles one or more child components, * which may be ordered or unordered. * * @author Dennis M. Sosnoski * @version 1.0 */public class NestedStructure extends NestedBase{    //    // Method definitions used in code generation        private static final String CHECK_ISSTART_NAME =        "org.jibx.runtime.impl.UnmarshallingContext.isStart";    private static final String CHECK_ISSTART_SIGNATURE = "()Z";    private static final String SKIP_ELEMENT_NAME =        "org.jibx.runtime.impl.UnmarshallingContext.skipElement";    private static final String SKIP_ELEMENT_SIGNATURE = "()V";    private static final String THROW_EXCEPTION_NAME =        "org.jibx.runtime.impl.UnmarshallingContext.throwNameException";    private static final String THROW_EXCEPTION_SIGNATURE =        "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V";        //    // Instance data        /** Child supplying ID for bound class. */    private IComponent m_idChild;    /** Flag for choice of child content (used by subclasses). */    protected final boolean m_isChoice;        /** Flag for duplicate values allowed when unmarshalling unordered group. */    private final boolean m_allowDuplicates;        /** Flag for structure has associated object. */    private boolean m_hasObject;        /** Flag for already linked (to avoid multiple passes). */    private boolean m_isLinked;    /**     * Constructor.     *     * @param parent containing binding definition context     * @param objc current object context     * @param ord ordered content flag     * @param choice choice content flag     * @param flex flexible element handling flag     * @param ctx define context for structure flag     * @param hasobj has associated object flag     * @param dupl allow duplicates in unordered group flag     */    public NestedStructure(IContainer parent, IContextObj objc,        boolean ord, boolean choice, boolean flex, boolean ctx,        boolean hasobj, boolean dupl) {        super(parent, objc, ord, flex, ctx);        m_isChoice = choice;        m_hasObject = hasobj;        m_allowDuplicates = dupl;    }        /**     * Set the object context.     *      * @param objc object context     */    public void setObjectContext(IContextObj objc) {        m_hasObject = false;    }        //    // IComponent interface method definitions    public boolean hasAttribute() {        return m_attributes != null && m_attributes.size() > 0;    }    public void genAttrPresentTest(ContextMethodBuilder mb)        throws JiBXException {        if (m_attributes != null && m_attributes.size() > 0) {                        // if single possiblity just test it directly            int count = m_attributes.size();            if (count == 1) {                ((IComponent)m_attributes.get(0)).genAttrPresentTest(mb);            } else {                                // generate code for chained test with branches to found exit                BranchWrapper[] tofound = new BranchWrapper[count];                for (int i = 0; i < count; i++) {                    IComponent comp = (IComponent)m_attributes.get(i);                    comp.genAttrPresentTest(mb);                    tofound[i] = mb.appendIFNE(this);                }                                // fall off end of loop to push "false" on stack and jump to end                mb.appendICONST_0();                BranchWrapper toend = mb.appendUnconditionalBranch(this);                                // generate found target to push "true" on stack and continue                for (int i = 0; i < count; i++) {                    mb.targetNext(tofound[i]);                }                mb.appendICONST_1();                mb.targetNext(toend);                            }        } else {            throw new IllegalStateException                ("Internal error - no attributes present");        }    }    public void genAttributeUnmarshal(ContextMethodBuilder mb)        throws JiBXException {        if (m_attributes != null && m_attributes.size() > 0) {            for (int i = 0; i < m_attributes.size(); i++) {                IComponent attr = (IComponent)m_attributes.get(i);                attr.genAttributeUnmarshal(mb);            }        } else {            throw new IllegalStateException                ("Internal error - no attributes present");        }    }    public void genAttributeMarshal(ContextMethodBuilder mb)        throws JiBXException {        if (m_attributes != null && m_attributes.size() > 0) {            for (int i = 0; i < m_attributes.size(); i++) {                IComponent attr = (IComponent)m_attributes.get(i);                attr.genAttributeMarshal(mb);            }        } else {            throw new IllegalStateException                ("Internal error - no attributes present");        }    }    public boolean hasContent() {        return m_contents.size() > 0;    }    public void genContentUnmarshal(ContextMethodBuilder mb)        throws JiBXException {        if (m_contents.size() > 0) {                    // check for ordered or unordered content            if (m_isOrdered) {                            // just generate unmarshal code for each component in order                for (int i = 0; i < m_contents.size(); i++) {                    IComponent child = (IComponent)m_contents.get(i);                    child.genContentUnmarshal(mb);                }                            } else {                                // start by finding the number of required elements                int count = m_contents.size();                int nreq = 0;                for (int i = 0; i < count; i++) {                    if (!((IComponent)m_contents.get(i)).isOptional()) {                        nreq++;                    }                }                                // create array for tracking elements seen                boolean useflag = nreq > 0 || !m_allowDuplicates;                if (useflag) {                    mb.appendLoadConstant(count);                    mb.appendCreateArray("boolean");                    mb.defineSlot(this, ClassItem.typeFromName("boolean[]"));                }                            // generate unmarshal loop code that checks for each component,                //  branching to the next component until one is found and                //  exiting the loop only when no component is matched (or in                //  the case of flexible unmarshalling, only exiting the loop                //  when the enclosing end tag is seen). this uses the array(s)                //  of booleans to track elements seen and detect duplicates.                BranchWrapper link = null;                // TODO: initialize default values                BranchTarget first = mb.appendTargetNOP();