Examples of org.jibx.binding.classes.ClassItem

org.jibx.binding.classes.ClassItem
Wrapper for field or method information. Provides the information needed for access to either existing or added methods in existing classes. @author Dennis M. Sosnoski

        ClassFile base = ClassCache.requireClassFile(FACTORY_BASE);
        ClassFile cf = new ClassFile(m_factoryName, m_targetRoot, base,
            Constants.ACC_PUBLIC, FACTORY_INTERFACES);
        
        // add static field for instance
        ClassItem inst = cf.addField(FACTORY_INTERFACE,
            FACTORY_INSTNAME, PRIVATESTATIC_ACCESS);
        
        // add private method to return binding classes blob (replaced later)
        MethodBuilder mb = new ExceptionMethodBuilder(CLASSLIST_METHOD_NAME,
            Type.STRING, new Type[0], cf,
            Constants.ACC_PRIVATE|Constants.ACC_STATIC);
        mb.appendACONST_NULL();
        mb.appendReturn(Type.STRING);
        mb.codeComplete(false);
        ClassItem clasblobmeth = mb.addMethod();
        
        // add the private constructor method
        mb = new ExceptionMethodBuilder("<init>", Type.VOID, new Type[0], cf,
            Constants.ACC_PRIVATE);
        
        // start superclass constructor call with name/versions, classes used
        mb.appendLoadLocal(0);
        mb.appendLoadConstant(m_name);
        mb.appendLoadConstant(m_majorVersion);
        mb.appendLoadConstant(m_minorVersion);
        mb.appendCall(clasblobmeth);
        
        // load count of mapped classes
        int count = s_mappedClasses.size();
        int mcnt = m_extraClasses == null ? count : count +
            m_extraClasses.size();
        
        // create argument blob of mapped class names
        String[] names = new String[mcnt];
        for (int i = 0; i < count; i++) {
            names[i] = (String)s_mappedClasses.get(i);
        }
        for (int i = count; i < mcnt; i++) {
            names[i] = (String)m_extraClasses.get(i-count);
        }
        codegenString(buildClassNamesBlob(names), mb);
        
        // create argument blob of unmarshaller class names
        if (m_isInput) {
            for (int i = 0; i < count; i++) {
                String cname = (String)s_mappedClasses.get(i);
                IMapping map = m_activeContext.getMappingAtLevel(cname);
                if (map != null && map.getUnmarshaller() != null) {
                    names[i] = map.getUnmarshaller().getName();
                } else {
                    names[i] = null;
                }
            }
            for (int i = count; i < mcnt; i++) {
                names[i] = (String)m_extraUnmarshallers.get(i-count);
            }
            codegenString(buildClassNamesBlob(names), mb);
        } else {
            mb.appendACONST_NULL();
        }
        
        // create argument blob of marshaller class names
        if (m_isOutput) {
            for (int i = 0; i < count; i++) {
                String cname = (String)s_mappedClasses.get(i);
                IMapping map = m_activeContext.getMappingAtLevel(cname);
                if (map != null && map.getMarshaller() != null) {
                    names[i] = map.getMarshaller().getName();
                } else {
                    names[i] = null;
                }
            }
            for (int i = count; i < mcnt; i++) {
                names[i] = (String)m_extraMarshallers.get(i-count);
            }
            codegenString(buildClassNamesBlob(names), mb);
        } else {
            mb.appendACONST_NULL();
        }
        
        // create argument array of namespace URIs
        String[] nsuris = new String[m_namespaceUris.size()];
        mb.appendLoadConstant(m_namespaceUris.size());
        mb.appendCreateArray("java.lang.String");
        for (int i = 0; i < m_namespaceUris.size(); i++) {
            mb.appendDUP();
            mb.appendLoadConstant(i);
            String uri = (String)m_namespaceUris.get(i);
            mb.appendLoadConstant(uri);
            mb.appendAASTORE();
            nsuris[i] = uri;
        }
        
        // create argument array of namespace prefixes
        if (m_isOutput) {
            mb.appendLoadConstant(m_namespacePrefixes.size());
            mb.appendCreateArray("java.lang.String");
            for (int i = 0; i < m_namespacePrefixes.size(); i++) {
                mb.appendDUP();
                mb.appendLoadConstant(i);
                mb.appendLoadConstant((String)m_namespacePrefixes.get(i));
                mb.appendAASTORE();
            }
        } else {
            mb.appendACONST_NULL();
        }
        
        // create argument blobs of globally mapped element names and URIs
        names = new String[count];
        String[] namespaces = new String[count];
        for (int i = 0; i < count; i++) {
            String cname = (String)s_mappedClasses.get(i);
            IMapping map = m_activeContext.getMappingAtLevel(cname);
            if (map != null) {
                NameDefinition ndef = map.getName();
                if (ndef != null) {
                    names[i] = ndef.getName();
                    namespaces[i] = ndef.getNamespace();
                }
            }
        }
        codegenString(buildNamesBlob(names), mb);
        mb.appendLoadConstant(buildNamespaceIndexBlob(nsuris, namespaces));
        
        // create argument array of class names with unique IDs
        if (m_uniqueIds != null && m_uniqueIds.size() > 0) {
            mb.appendLoadConstant(m_uniqueIds.size());
            mb.appendCreateArray("java.lang.String");
            for (int i = 0; i < m_uniqueIds.size(); i++) {
                mb.appendDUP();
                mb.appendLoadConstant(i);
                mb.appendLoadConstant((String)m_uniqueIds.get(i));
                mb.appendAASTORE();
            }
        } else {
            mb.appendACONST_NULL();
        }
        
        // create argument blobs of abstract mapping information
        GrowableStringArray allnames = new GrowableStringArray();
        int abmapcnt = 0;
        StringBuffer buff = new StringBuffer();
        for (int i = 0; i < count; i++) {
            String tname = (String)s_mappedClasses.get(i);
            IMapping map = m_activeContext.getMappingAtLevel(tname);
            if (map != null && map.isAbstract()) {
                ITypeBinding bind = map.getBinding();
                allnames.add(tname);
                allnames.add(map.getBoundType());
                allnames.add(bind.getCreateMethod());
                allnames.add(bind.getCompleteMethod());
                allnames.add(bind.getPrepareMethod());
                allnames.add(bind.getAttributePresentTestMethod());
                allnames.add(bind.getAttributeUnmarshalMethod());
                allnames.add(bind.getAttributeMarshalMethod());
                allnames.add(bind.getContentPresentTestMethod());
                allnames.add(bind.getContentUnmarshalMethod());
                allnames.add(bind.getContentMarshalMethod());
                abmapcnt++;
                ArrayList nss = map.getNamespaces();
                if (nss == null) {
                    buff.append((char)1);
                } else {
                    buff.append((char)(nss.size()+1));
                    for (int j = 0; j < nss.size(); j++) {
                        NamespaceDefinition nsdef =
                            (NamespaceDefinition)nss.get(j);
                        buff.append((char)(nsdef.getIndex()+1));
                    }
                }
            }
        }
        codegenString(buildClassNamesBlob(allnames.toArray()), mb);
        codegenString(buff.toString(), mb);
        
        // create argument blobs of precompiled base binding names and factories
        int basecount = m_baseBindings.size();
        codegenString(buildNamesBlob(m_baseBindings.toArray()), mb);
        String namesblob = buildClassNamesBlob(m_baseBindingFactories.toArray());
        if (m_closureFactories.size() > 0) {
            namesblob += "|" + buildClassNamesBlob(m_closureFactories.toArray());
        }
        codegenString(namesblob, mb);
        
        // create argument blob for base binding factory hashes
        char[] hashchars = new char[basecount*2];
        for (int i = 0; i < basecount; i++) {
            int hash = ((Integer)m_baseHashes.get(i)).intValue();
            hashchars[i*2] = (char)(hash >> 16);
            hashchars[i*2+1] = (char)hash;
        }
        codegenString(new String(hashchars), mb);
        
        // create array of blobs of base binding namespace translation tables
        mb.appendLoadConstant(basecount + m_closureNamespaceTables.size());
        mb.appendCreateArray("java.lang.String");
        for (int i = 0; i < basecount; i++) {
            int[] table = (int[])m_baseNamespaceTables.get(i);
            if (table != null) {
                mb.appendDUP();
                mb.appendLoadConstant(i);
                mb.appendLoadConstant(buildIntsBlob(table));
                mb.appendAASTORE();
            }
        }
        for (int i = 0; i < m_closureNamespaceTables.size(); i++) {
            int[] table = (int[])m_closureNamespaceTables.get(i);
            mb.appendDUP();
            mb.appendLoadConstant(i+basecount);
            mb.appendLoadConstant(buildIntsBlob(table));
            mb.appendAASTORE();
        }
        
        // call the base class constructor
        mb.appendCallInit(FACTORY_BASE,
            "(Ljava/lang/String;IILjava/lang/String;Ljava/lang/String;" +
            "Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;" +
            "[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" +
            "[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" +
            "Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;" +
            "[Ljava/lang/String;)V");
        
        // get class names for types (abstract non-base mappings)
        GrowableStringArray tnames = new GrowableStringArray();
        if (m_isForceClasses) {
            for (int i = 0; i < count; i++) {
                String cname = (String)s_mappedClasses.get(i);
                IMapping map = m_activeContext.getMappingAtLevel(cname);
                if (map != null && map.isAbstract() && !map.isBase()) {
                    String tname = map.getTypeName();
                    if (tname == null) {
                        tname = cname;
                    }
                    tnames.add(tname);
                }
            }
        }
        
        // check if map needed for types
        ClassItem tmap = null;
        if (tnames.size() >= TYPEMAP_MINIMUM_SIZE) {
            
            // create field for map
            tmap = cf.addPrivateField(STRINGINT_MAPTYPE, TYPEMAP_NAME);

View Full Code Here

                    haveobj = false;
                    
                } else {
                    
                    // check if we have a no argument constructor
                    ClassItem cons = m_createClass.getInitializerMethod("()V");
                    if (cons == null) {
                        if (m_container.getBindingRoot().isAddConstructors()) {
                            m_createClass.addDefaultConstructor();
                        } else {
                            
                            // cannot create instance, throw exception
                            mb.appendCreateNew(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS);
                            mb.appendDUP();
                            mb.appendLoadConstant("Cannot create instance of class " +
                                m_createClass.getName() + " (no default constructor)");
                            mb.appendCallInit(MethodBuilder.FRAMEWORK_EXCEPTION_CLASS,
                                MethodBuilder.EXCEPTION_CONSTRUCTOR_SIGNATURE1);
                            mb.appendThrow();
                            haveobj = false;
                            
                        }
                    } else {
                        cons.makeAccessible(m_class.getMungedFile());
                    }
                    if (haveobj) {
                        
                        // no factory, so create an instance, duplicate the
                        //  reference, and then call the null constructor

View Full Code Here

        ClassFile cf = m_class.getMungedFile();
        if (m_class.isDirectAccess() && !cf.isAbstract() &&
            cf.addInterface(SOURCE_TRACKING_INTERFACE)) {
        
            // add position tracking fields to class
            ClassItem srcname = cf.addPrivateField("java.lang.String;",
                SOURCEDOCUMENT_FIELDNAME);
            ClassItem srcline = cf.addPrivateField("int", SOURCELINE_FIELDNAME);
            ClassItem srccol = cf.addPrivateField("int",
                SOURCECOLUMN_FIELDNAME);
        
            // add method for setting the source information
            MethodBuilder mb = new ExceptionMethodBuilder(SETSOURCE_METHODNAME,
                Type.VOID, SETSOURCE_ARGS, cf, Constants.ACC_PUBLIC);

View Full Code Here

            sigs.add
                ("(Ljava/lang/Object;Lorg/jibx/runtime/IUnmarshallingContext;)V");
            sigs.add("(Ljava/lang/Object;)V");
            
            // set method needs verification of argument and return type
            ClassItem setmeth = cf.getMethod(set,
                (String[])sigs.toArray(new String[0]));
            if (setmeth == null) {
                
                // nothing known about signature, try anything by name
                setmeth = cf.getMethod(set, "");
                if (setmeth != null) {
                    if (!setmeth.getTypeName().equals("void") ||
                        setmeth.getArgumentCount() > 2) {
                        setmeth = null;
                    } else if (setmeth.getArgumentCount() == 2) {
                        String xtype = setmeth.getArgumentType(1);
                        if (!"org.jibx.runtime.IUnmarshallingContext".equals(xtype)) {
                            setmeth = null;
                        }
                    }
                }

View Full Code Here

     */
    public void genFlag(MethodBuilder mb) throws JiBXException {
        
        // first check direct access to property from method class
        ClassFile from = mb.getClassFile();
        ClassItem access = m_flagMethod;
        if (!from.isAccessible(access)) {
            access = m_objContext.getBoundClass().
                getStoreMethod(access, mb.getClassFile());
        }
        
        // generated instruction calls the "flag" method
        if (access.isMethod()) {
            if (access.getArgumentCount() > 1) {
                ((ContextMethodBuilder)mb).loadContext();
            }
            mb.addMethodExceptions(access);
            mb.appendCall(access);
        }
        if (access.isStatic()) {
            discardValue(mb);
        }
    }

View Full Code Here

        // nothing to be done if called on "this" or implicit reference
        if (!m_isThis && !m_isImplicit) {
        
            // first check direct access to property from method class
            ClassFile from = mb.getClassFile();
            ClassItem access = m_getMethod;
            if (access == null) {
                access = m_fieldItem;
            }
            if (access != null && !from.isAccessible(access)) {
                access = m_objContext.getBoundClass().
                    getLoadMethod(access, mb.getClassFile());
            }
        
            // generated instruction either loads a field value or calls a "get"
            //  method, as appropriate
            if (access == null) {
                Integer index = (Integer)mb.getKeyValue(this);
                discardValue(mb);
                if (index == null) {
                    mb.appendACONST_NULL();
                } else {
                    mb.appendLoadLocal(index.intValue());
                }
            } else {
                if (access.isStatic()) {
                    discardValue(mb);
                }
                if (access.isMethod()) {
                    if (access.getArgumentCount() > 0) {
                        mb.loadContext();
                    }
                    mb.addMethodExceptions(access);
                    mb.appendCall(access);
                } else {

View Full Code Here

            // nothing to be done if called on "this" or implicit reference
            if (!m_isThis && !m_isImplicit) {
            
                // first check direct access to property from method class
                ClassFile from = mb.getClassFile();
                ClassItem access = m_setMethod;
                if (access == null) {
                    access = m_fieldItem;
                }
                if (!from.isAccessible(access)) {
                    access = m_objContext.getBoundClass().
                        getStoreMethod(access, mb.getClassFile());
                }
                
                // save to local if no way of getting value
                if (m_getMethod == null && m_fieldItem == null) {
                    duplicateValue(mb);
                    Integer index = (Integer)mb.getKeyValue(this);
                    if (index == null) {
                        int slot = mb.addLocal(null,
                            ClassItem.typeFromName(m_setValueType));
                        index = IntegerCache.getInteger(slot);
                        mb.setKeyValue(this, index);
                    } else {
                        mb.appendStoreLocal(index.intValue());
                    }
                }
                
                // generated instruction either stores a field value or calls a
                //  "set" method, as appropriate
                if (access.isMethod()) {
                    if (access.getArgumentCount() > 1) {
                        
                        // this test is ugly, needed because of backfill method
                        //  calls from ValueChild
                        if (mb instanceof ContextMethodBuilder) {
                            ((ContextMethodBuilder)mb).loadContext();
                        } else {
                            mb.appendACONST_NULL();
                        }
                    }
                    mb.addMethodExceptions(access);
                    mb.appendCall(access);
                } else {
                    mb.appendPut(access);
                }
                if (access.isStatic()) {
                    discardValue(mb);
                }
            }
        }
    }

View Full Code Here

0 1

TOP

Related Classes of org.jibx.binding.classes.ClassItem

org.apache.bcel.classfile.Attribute

org.apache.bcel.classfile.ExceptionTable

org.apache.bcel.classfile.LocalVariable

org.apache.bcel.classfile.LocalVariableTable

org.apache.bcel.generic.ArrayType

org.apache.bcel.generic.ObjectType

org.apache.bcel.generic.Type

org.jibx.binding.BindingGenerator

org.jibx.binding.def.BindingBuilder

org.jibx.binding.def.BindingDefinition

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.