Public

getErrorCount

getFatalCount

getProblems

setBindingRoot

tourTree

addFatal

getFormatDefinitions

<init>

addError

addWarning

getParentElement

OutputStreamWriter

Start an intent from android

Formats or parses dates and times.This class provides factories for obtaining
instances configured f

java.text.DateFormat

This class consists exclusively of static methods that operate on or return
collections. It contains

java.util.Collections

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

java.util.Locale

A sequence of elements supporting sequential and parallel aggregate operations.
The following exampl

java.util.stream.Stream

Defines methods that all servlets must implement. A servlet is a small Java
program that runs within

javax.servlet.Servlet

XPath provides access to the XPath evaluation environment and expressions.

Evaluation of XPath Expr

javax.xml.xpath.XPath

getSupportFragmentManager

putExtra

requestLocationUpdates

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

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

// handle mapping reference based on form and name use

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

How to use addErrormethodin org.jibx.binding.model.ValidationContext

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

How to use
addError
method
in
org.jibx.binding.model.ValidationContext