Public

getClassName

getName

getTypeQName

isAbstract

getCreateType

getExtensionTypes

getUri

topChildIterator

addChild

addTopChild

getAttributeComponents

getContentComponents

getNamespace

getTypeName

setAbstract

setClassName

setCreateType

setExtendsName

setFactoryName

setName

Running tasks concurrently on multiple threads

The Color class is used to encapsulate colors in the default sRGB color space or
colors in arbitrary

java.awt.Color

java.awt.Menu

An input stream that reads bytes from a file.    
File file = ...finally  
if (in != null)  
in.clos

java.io.FileInputStream

A specialized Reader that reads from a file in the file system. All read
requests made by calling me

java.io.FileReader

Allows reading from and writing to a file in a random-access manner. This is
different from the uni-

java.io.RandomAccessFile

Note: Do not use this class since it is obsolete. Please use the Map interface
for new implementatio

java.util.Dictionary

getApplicationContext

scheduleAtFixedRate

findViewById

/**
     * Constructor.
     * 
     * @param map mapping definition
     * @param haschild has child element(s) flag
     * @param hastext has child text(s) flag
     * @param base base mapping for schema type extension
     * @param tname name as type
     * @param oname name as element/group/attributeGroup
     */

/**
     * 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

/**
     * Handles unwrapping a message. This generates and returns the detailed description of how the
     * message is to be unwrapped. It also creates the data structures expected by the code
     * generation in order to be somewhat compatible with ADB unwrapping.
     *
     * @param msg                message to be unwrapped
     * @param isout              output message flag (wrapper inherits inner type, for XSLTs)
     * @param simpleTypeMap      binding formats
     * @param elementMap         map from element names to concrete mapping components of binding
     * @param complexTypeMap     binding mappings
     * @param typeMappedClassMap map from type qname to index
     * @param bindingMap         map from mapping components to containing binding definition
     * @param nameset            parameter variable names used in method
     * @param nsmap              mapr from URI to prefix for namespaces to be defined on wrapper
     *                           element
     * @param doc                document used for DOM components
     * @return detailed description element for code generation
     */

// find the schema definition for this message element

"Cannot unwrap - no definition found for element "

// create document to hold data binding details for element

": attributes not allowed on type to be unwrapped"

// if there's a particle present, it must be a sequence

": type to be unwrapped must be a sequence"

": contained sequence must have minOccurs='1' and maxOccurs='1'"

// add child param element matching each child of wrapper element

// check that child item obeys the unwrapping rules

": only element items allowed in sequence"

": all elements in contained sequence must be element references or reference a named type"

": only one child element allowed in sequence for wrapped output"

// add element to output with details of this element handling

// simple type translates to format element in binding

// check for restriction with simple base, and treat as base if so

/**
     * 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 attributes as part of complex type definition.
     * 
     * @param cont container element defining structure
     * @param offset offset for first child component to process
     * @param attrs complex type attribute list
     * @param hold holder for schema under construction
     */

// no children, must be mapping reference

"No schema equivalent for optional abstract mapping with attributes"

/**
     * Add the &lt;mapping> definition for a class to a binding. This creates either an abstract mapping with a type
     * name, or a concrete mapping with an element name, as determined by the passed-in mapping information. If the
     * class is a concrete mapping that extends or implements another class with an anonymous abstract mapping, the
     * created &lt;mapping> will extend that base mapping. TODO: type substitution requires extending the binding
     * definition
     * 
     * @param type fully qualified class name
     * @param detail mapping details
     */

// make "concrete" mapping abstract if no class creation possible

// fill details directly to this mapping unless abstract also created

// use abstract mapping for details (concrete will reference this one)

// find the binding containing this mapping

// check for superclass mapping to be extended (do this first for compatibility with schema type extension)

// not extending a base mapping, check if need to include superclass

"Internal error: unimplemented case of superclass "

// set extension for child concrete mapping

// add extension reference structure to mapping

// add all details of class member handling to binding

// define content as structure reference to abstract mapping

// set the member property map for mapping

" with neither abstract nor concrete mapping"

/**
     * Build compositor for type definition. This creates and returns the appropriate form of compositor for the
     * container, populated with particles matching the child element components of the binding container.
     * 
     * @param cont container element defining structure
     * @param offset offset for first child component to process
     * @param repeat repeated item flag
     * @param hold holder for schema under construction
     * @return constructed compositor
     */

// start with the appropriate type of compositor

// choice container goes directly to choice compositor

// ordered container goes directly to sequence compositor

// unordered repeat treated as repeated choice compositor

// unordered non-repeat treated as all compositor

// generate schema equivalents for content components of container

// create element for named content component

// no element name, but children; handle with recursive call

// item type with concrete mapping, make it an element

"Handling not implemented for unspecified mapping"

// handle mapping reference based on form and name use

// simplify by eliminating this level if only child a compositor

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

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

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