Public

getElementDefaultNamespace

getSpecificTemplate

StringBuilder

Parsing JSON documents to java classes using gson

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

java.io.FileReader

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

java.net.SocketTimeoutException

A plug-in replacement for JDK1.5 java.util.Hashtable. This version is based on
org.cliffc.high_scale

java.util.Hashtable

 Locale represents a language/country/variant combination. Locales are used to
alter the presentatio

java.util.Locale

Basic implementation of javax.sql.DataSource that is configured via JavaBeans
properties. This is no

org.apache.commons.dbcp.BasicDataSource

Central representation of an Ant project. This class defines an Ant project with
all of its targets,

org.apache.tools.ant.Project

notifyDataSetChanged

setContentView

setScale

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

// no children, must be mapping reference

// handle mapping reference based on form and name use

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

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

// 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 useDefinitionContext in org.jibx.binding.model

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

How to use
DefinitionContext
in
org.jibx.binding.model