Public

<init>

addChild

children

getDeclaredType

getEffectiveMapping

getFieldName

getGetName

getMapAsQName

getName

getSetName

hasDirectName

hasName

hasProperty

isChoice

isOptional

isOrdered

setCreateType

setDeclaredType

setFactoryName

setFieldName

ArrayList

Start an intent from android

The GridBagLayout class is a flexible layout manager that aligns components
vertically and horizonta

java.awt.GridBagLayout

java.nio.file.Path

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

java.util.Dictionary

A Map is a data structure consisting of a set of keys and values in which each
key is mapped to a si

java.util.Map

A TimeUnit represents time durations at a given unit of granularity and provides
utility methods to 

java.util.concurrent.TimeUnit

Factory for creating Log instances, with discovery and configuration features
similar to that employ

org.apache.commons.logging.LogFactory

setRequestProperty

notifyDataSetChanged

getSharedPreferences

/**
     * Check if a &lt;structure&gt; element represents a type derivation. If the element is empty, has no name or property,
     * is required, and is a mapping reference, then it can be handled as a type derivation.
     * 
     * @param struct
     * @return <code>true</code> if a type derivation, <code>false</code> if not
     */

/**
     * Create the detail information for a &lt;mapping>. This creates the detail information and adds it to the map,
     * then analyzes the structure of the mapping to find references to other mappings and to enumeration types.
     * 
     * @param map
     * @return detail
     */

// check structure of mapping definition for schema type extension

// type extension requires reference as first content component

// next search recursively for text and/or child element components this is done at this point (with loop

//  recursion, if needed) so that the flags can be set when creating the detail instance

// check for container with element name or text content

// component with name means child element

// value with no name implies text content

// collection implies child element (repeating)

// structure, check for mapping reference

// add container structure to expansion list

// mapping element reference, check if named

// add new mapping detail based on information found

// force generating an element for this mapping

// error if mapping extension doesn't map to type extension

// recursively check for extension type match

// flag generation as element in substitution group

"'extends' mapping not usable as schema extension base"

// process all references from this mapping

/**
     * Check references to mappings or enumeration types from component children of binding container element. This
     * allows for skipping a base mapping reference, so that mappings with type extension components can be handled
     * (with the extension component processed separately, since it's a special case).
     * 
     * @param cont container element
     * @param base child element representing base mapping reference (<code>null</code> if none)
     */

// process all child components of container

// check value reference to enumeration type

// collection items are enumeration type, count directly

// structure, check for nested definition

// just handle references from nested components

// no nested definition, check for mapping reference

"No handling defined for empty structure with no mapping reference"

// get the referenced mapping information

// named element referencing the mapping implies it's a type definition

// concrete with name should never happen

"No handling defined for name on concrete mapping reference"

/**
     * Build a schema element description from a binding content component.
     * 
     * @param comp source component
     * @param repeat repeated element flag
     * @param hold
     * @return element
     */

// set or create the element type definition

// collection with children, choice or sequence from order

// ordered children go to sequence element, repeating

// unordered children go to repeated choice element

// empty collection, item-type must reference a concrete mapping

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

"Handling not implemented for unspecified mapping"

// structure with children, choice or sequence from order

// ordered children go to sequence element

// no children, must be a mapping reference

// implicit mapping reference, find the handling

// set element type to that constructed from mapping

How to use childrenmethodin org.jibx.binding.model.StructureElement

Best Java code snippets using org.jibx.binding.model.StructureElement.children (Showing top 4 results out of 315)

How to use
children
method
in
org.jibx.binding.model.StructureElement