Public

getClassName

getName

getTypeQName

isAbstract

getCreateType

getExtensionTypes

getUri

topChildIterator

addChild

addTopChild

getAttributeComponents

getContentComponents

getNamespace

getTypeName

setAbstract

setClassName

setCreateType

setExtendsName

setFactoryName

setName

Connection

Finding current android device location

This class represents a server-side socket that waits for incoming client
connections. A ServerSocke

java.net.ServerSocket

Thrown when a hostname can not be resolved.

java.net.UnknownHostException

An ordered collection (also known as a sequence). The user of this interface has
precise control ove

java.util.List

The TimerTask class represents a task to run at a specified time. The task may
be run once or repeat

java.util.TimerTask

javax.management.Notification

javax.swing.JLabel

putExtra

addToBackStack

scheduleAtFixedRate

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