Public

getClassName

getName

getTypeQName

isAbstract

getCreateType

getExtensionTypes

getUri

topChildIterator

addChild

addTopChild

getAttributeComponents

getContentComponents

getNamespace

getTypeName

setAbstract

setClassName

setCreateType

setExtendsName

setFactoryName

setName

Connection

Reactive rest calls using spring rest template

An output stream that writes bytes to a file. If the output file exists, it can
be replaced or appen

java.io.FileOutputStream

This exception is thrown when a timeout expired on a socket read or accept
operation.

java.net.SocketTimeoutException

A controller for the selection of SelectableChannel objects. Selectable channels
can be registered w

java.nio.channels.Selector

This class contains various methods for manipulating arrays (such as sorting and
searching). This cl

java.util.Arrays

A java.util.Queue that additionally supports operations that wait for the queue
to become non-empty 

java.util.concurrent.BlockingQueue

An object that executes submitted Runnable tasks. This interface provides a way
of decoupling task s

java.util.concurrent.Executor

setContentView

requestLocationUpdates

getSystemService

/**
     * Accumulate all mapping definitions, including those found in included bindings. For each named abstract mapping
     * found, the class name is associated with the type name in the type map; for each concrete mapping found, the
     * class name is associated with the element name in the element map. Included bindings are handled with recursive
     * calls.
     *
     * @param binding binding definition root
     * @param elemmap map from fully-qualified class name to element qualified name
     * @param typemap map from fully-qualified class name to type qualified name
     */

// use recursive call to add nested definitions in included binding

// handle mapping as type if abstract with type name, or as element if concrete

/**
     * Accumulate all format and mapping definitions, including those found in included bindings. For each abstract
     * mapping or named format found, the type name is associated with the class data in the type map; for each concrete
     * mapping found, the element name (and namespace) is associated with the class data in the element map. Included
     * bindings are handled with recursive calls.
     *
     * @param binding binding definition root
     * @param elemmap map from element qualified name to class data
     * @param typemap map from type qualified name to class data
     */

// add named format as simple type definition

/**
     * Collect mapping from qnames to classes for top level mappings in JiBX binding.
     *
     * @param binding
     * @param dns            default namespace to be used unless overridden (empty string if none)
     * @param elementMap     map from element names to concrete mapping components of binding
     * @param complexTypeMap map from type names to abstract mapping components of binding
     * @param simpleTypeMap  map from type names to format definition components of binding
     * @param bindingMap     map from mapping components to containing binding definition
     */

// check default namespace set at top level of binding

// add all top level mapping and format definitions to maps

// recurse to process included binding definitions

// register named formats as simple type conversions

// record only abstract mappings with type names, and mappings with names

// register named abstract mappings as complex type conversions

// register concrete mappings as element conversions

/**
     * Build classes and bindings for all definitions, except those for singleton element definitions using a type.
     *
     * @param defs definitions to be generated
     * @param typeinst map from base type definition to singleton element definition using that type
     */

// compact again after inlining and converting extension references

// build the binding component for this definition

// abstract or concrete mapping for element

// abstract mapping for type definition or group

// add the mapping to binding and set on class

// create mapping for element name linked to type

// handle linking to substitution group head using extends mapping

// create single structure child invoking the type mapping

// set the definition for the class (and create any required secondary classes)

/**
     * Add mapping to schema definitions. This generates the appropriate schema representation for the mapping based on
     * the detail flags, which may include group and/or attributeGroup, complexType, and element definitions.
     * 
     * @param detail
     */

// get the documentation to be used for type

// start by generating group/attributeGroup schema components

// TODO: extend base type for group/attributeGroup?

// next generate the complex type definition

// finish by generating element definition

// check for just an element wrapper around type reference

// add documentation to element which is not also a type

How to use getTypeQNamemethodin org.jibx.binding.model.MappingElementBase

Best Java code snippets using org.jibx.binding.model.MappingElementBase.getTypeQName (Showing top 6 results out of 315)

How to use
getTypeQName
method
in
org.jibx.binding.model.MappingElementBase