Public

getClassName

getName

getTypeQName

isAbstract

getCreateType

getExtensionTypes

getUri

topChildIterator

addChild

addTopChild

getAttributeComponents

getContentComponents

getNamespace

getTypeName

setAbstract

setClassName

setCreateType

setExtendsName

setFactoryName

setName

Connection

Parsing JSON documents to java classes using gson

An Internet Protocol (IP) address. This can be either an IPv4 address or an IPv6
address, and in pra

java.net.InetAddress

This class represents proxy server settings. A created instance of Proxy stores
a type and an addres

java.net.Proxy

Doubly-linked list implementation of the List and Dequeinterfaces. Implements
all optional list oper

java.util.LinkedList

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

java.util.List

javax.swing.BoxLayout

org.hibernate.mapping.Table

putExtra

Return the contained value, if present, otherwise throw an exception to be
created by the provided s

orElseThrow

onCreateOptionsMenu

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

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

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

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

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

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

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