mappingdefinition.java

来自「JiBX是一个为Java提供的XML数据绑定框架。它可以和现存的类一起运行」· Java 代码 · 共 811 行 · 第 1/3 页

                
                // just create an instance of the (non-abstract) mapped class
                genNewInstance(mb);
                mb.storeObject();
                
            }
            
            // define unmarshallings for child mappings of this mapping
            mb.targetNext(ifnnull);
            ArrayList maps = m_defContext.getMappings();
            if (maps != null && maps.size() > 0) {
                for (int i = 0; i < maps.size(); i++) {
                    IMapping map = (IMapping)maps.get(i);
                    if (!map.isAbstract() || map.isBase()) {
                        mb.loadContext(UNMARSHALCONTEXT_CLASS);
                        mb.appendLoadConstant(map.getIndex());
                        NameDefinition mname = map.getName();
                        if (mname == null) {
                            mb.appendACONST_NULL();
                            mb.appendACONST_NULL();
                        } else {
                            map.getName().genPushUriPair(mb);
                        }
                        mb.appendLoadConstant(map.getUnmarshaller().getName());
                        mb.appendCallVirtual(ADDUNMARSHALLER_METHOD,
                            ADDUNMARSHALLER_SIGNATURE);
                    }
                }
            }
            
            // load object and cast to type
            mb.loadObject();
            mb.appendCreateCast(type);
            
            // handle the actual unmarshalling
            if (hasattr) {
                m_component.genAttributeUnmarshal(mb);
            }
            if (hascont) {
                m_component.genContentUnmarshal(mb);
            }
            
            // undefine unmarshallings for child mappings of this mapping
            if (maps != null && maps.size() > 0) {
                for (int i = 0; i < maps.size(); i++) {
                    IMapping map = (IMapping)maps.get(i);
                    if (!map.isAbstract() || map.isBase()) {
                        mb.loadContext(UNMARSHALCONTEXT_CLASS);
                        mb.appendLoadConstant(map.getIndex());
                        mb.appendCallVirtual(REMOVEUNMARSHALLER_METHOD,
                            REMOVEUNMARSHALLER_SIGNATURE);
                    }
                }
            }
            
            // finish by returning unmarshalled object reference
            mb.appendReturn("java.lang.Object");
            mb.codeComplete(false);
            mb.addMethod();
        
            // add interface if mapped class is directly unmarshallable
            if (hasname && m_class.getClassFile() == m_class.getMungedFile()) {
                addIUnmarshallableMethod();
            }
        }
    
        // add marshaller access method
        if (def.isOutput()) {
            
            // build the marshal implementation method; this loads the
            //  passed object and casts it to the target type, then handles
            //  marshalling first attributes and followed by content for the
            //  item
            ContextMethodBuilder mb = new ContextMethodBuilder
                (MARSHAL_METHODNAME, Type.VOID, MARSHAL_METHOD_ARGS, cf,
                Constants.ACC_PUBLIC|Constants.ACC_FINAL,
                1, "java.lang.Object", 2, MARSHALCONTEXT_INTERFACE);
            mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
            // TODO: optionally check for null value on object
            
            // define marshallings for child mappings of this mapping
            ArrayList maps = m_defContext.getMappings();
            if (maps != null && maps.size() > 0) {
                for (int i = 0; i < maps.size(); i++) {
                    IMapping map = (IMapping)maps.get(i);
                    if (!map.isAbstract() || map.isBase()) {
                        mb.loadContext(MARSHALCONTEXT_CLASS);
                        mb.appendLoadConstant(map.getIndex());
                        mb.appendLoadConstant(map.getMarshaller().getName());
                        mb.appendCallVirtual(ADDMARSHALLER_METHOD,
                            ADDMARSHALLER_SIGNATURE);
                    }
                }
            }
            
            // handle the actual marshalling
            if (hasattr || hascont) {
                mb.loadObject(m_class.getClassName());
                if (hasattr) {
                    if (hascont) {
                        mb.appendDUP();
                    }
                    m_component.genAttributeMarshal(mb);
                }
                if (hascont) {
                    m_component.genContentMarshal(mb);
                }
            }
            
            // undefine marshallings for child mappings of this mapping
            if (maps != null && maps.size() > 0) {
                for (int i = 0; i < maps.size(); i++) {
                    IMapping map = (IMapping)maps.get(i);
                    if (!map.isAbstract() || map.isBase()) {
                        mb.loadContext(MARSHALCONTEXT_CLASS);
                        mb.appendLoadConstant(map.getIndex());
                        mb.appendCallVirtual(REMOVEMARSHALLER_METHOD,
                            REMOVEMARSHALLER_SIGNATURE);
                    }
                }
            }
            
            // finish with plain return
            mb.appendReturn();
            mb.codeComplete(false);
            mb.addMethod();
            
            // build method to check if extending a particular abstract
            //  mapping
            ExceptionMethodBuilder xb = new ExceptionMethodBuilder
                (CHECKEXTENDS_METHODNAME, CHECKEXTENDS_SIGNATURE, cf,
                Constants.ACC_PUBLIC|Constants.ACC_FINAL);
            xb.appendLoadLocal(1);
            xb.appendLoadConstant(getIndex());
            xb.appendISUB();
            BranchWrapper ifident = xb.appendIFEQ(this);
            if (m_baseMapping != null) {
                xb.appendLoadLocal(1);
                xb.appendLoadConstant(m_baseMapping.getIndex());
                xb.appendISUB();
                BranchWrapper iftrue = xb.appendIFEQ(this);
                xb.appendICONST_0();
                xb.appendReturn("int");
                xb.targetNext(iftrue);
            }
            xb.targetNext(ifident);
            xb.appendICONST_1();
            xb.appendReturn("int");
            xb.codeComplete(false);
            xb.addMethod();
        
            // add interface if mapped class is directly marshallable
            if (hasname && m_class.getClassFile() == m_class.getMungedFile()) {
                addIMarshallableMethod();
            }
            
            // check for mapping with extensions to add extra method and
            //  interface
            if (m_extensions != null) {
                
                // for an abstract mapping, add base marshal implementation
                //  that just passes handling on to the appropriate
                //  extension class, and add corresponding interface to
                //  class.
                mb = new ContextMethodBuilder(BASEMARSHAL_METHODNAME,
                    Type.VOID, MARSHAL_METHOD_ARGS, cf,
                    Constants.ACC_PUBLIC|Constants.ACC_FINAL,
                    1, "java.lang.Object", 2, MARSHALCONTEXT_INTERFACE);
                mb.addException(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
                // TODO: optionally check for null value on object
                mb.loadContext();
                mb.loadObject(IMARSHALLABLE_INTERFACE);
                mb.appendCallInterface(GETINDEX_METHOD, GETINDEX_SIGNATURE);
                mb.loadObject();
                mb.appendCallVirtual("java.lang.Object.getClass",
                    "()Ljava/lang/Class;");
                mb.appendCallVirtual("java.lang.Class.getName",
                    "()Ljava/lang/String;");
                mb.appendCallInterface(GETMARSHALLER_METHOD,
                    GETMARSHALLER_SIGNATURE);
                mb.appendDUP();
                mb.appendLoadConstant(getIndex());
                mb.appendCallInterface(CHECKEXTENDS_METHOD,
                    CHECKEXTENDS_SIGNATURE);
                BranchWrapper ifvalid = mb.appendIFNE(this);
            
                // generate and throw exception describing the problem
                mb.appendCreateNew("java.lang.StringBuffer");
                mb.appendDUP();
                mb.appendLoadConstant("Mapping for type ");
                mb.appendCallInit("java.lang.StringBuffer",
                    "(Ljava/lang/String;)V");
                mb.appendDUP();
                mb.loadObject();
                mb.appendCallVirtual("java.lang.Object.getClass",
                    "()Ljava/lang/Class;");
                mb.appendCallVirtual("java.lang.Class.getName",
                    "()Ljava/lang/String;");
                mb.appendCallVirtual("java.lang.StringBuffer.append", 
                    "(Ljava/lang/String;)Ljava/lang/StringBuffer;");
                mb.appendDUP();
                mb.appendLoadConstant(" must extend abstract mapping for " +
                    "type " + m_class.getClassName());
                mb.appendCallVirtual("java.lang.StringBuffer.append", 
                    "(Ljava/lang/String;)Ljava/lang/StringBuffer;");
                mb.appendCallVirtual("java.lang.StringBuffer.toString",
                    "()Ljava/lang/String;");
                mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
                mb.appendDUP_X1();
                mb.appendSWAP();
                mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
                    MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
                mb.appendThrow();
            
                // for valid extension mapping, just call the marshaller
                mb.targetNext(ifvalid);
                mb.loadObject();
                mb.loadContext();
                mb.appendCallInterface(MARSHALLERMARSHAL_METHOD,
                    MARSHALLERMARSHAL_SIGNATURE);
                mb.appendReturn();
                mb.codeComplete(false);
                mb.addMethod();
                
                // add extended interface to constructed class
                cf.addInterface(ABSTRACTMARSHALLER_INTERFACE);
            }
        }
    
        // add as generated class
        m_marshaller = m_unmarshaller = MungedClass.getUniqueSupportClass(cf);
    }
    
    //
    // IComponent interface method definitions
    
    public NameDefinition getWrapperName() {
        return m_name;
    }

    public void setLinkages() throws JiBXException {
        m_component.setLinkages();
        m_defContext.setLinkages();
    }
    
    // DEBUG
    public void print(int depth) {
        BindingDefinition.indent(depth);
        System.out.print("mapping class " + m_class.getClassFile().getName());
        if (m_name != null) {
            System.out.print(" to element " + m_name.toString());
        }
        System.out.print(" (#" + getIndex() + ')');
        if (m_baseMapping != null) {
            System.out.print(" extends " + m_baseMapping.getBoundType());
        }
        if (m_isAbstract) {
            if (m_extensions != null) {
                System.out.print(" (abstract, " + m_extensions.size() +
                    " extensions)");
            } else {
                System.out.print(" (abstract)");
            }
        }
        System.out.println();
        m_defContext.print(depth+1);
        m_component.print(depth+1);
    }
}