Public

This is a convenience method that loads an InputStream using
getDataResourceStream() and turns it in

getDocument

Merges the two paths to create a valid version of the second path. This method
should be used when y

createRelativePath

getAddressingContext

getClassLoader

getRealDirectory

Records the WS-Addressing data for the current request.

addAddressingContext

getDefaultURI

getDeploymentEPR

getSoapClient

Removes the context object for the current request.

removeAddressingContext

LocalDateTime

Creating JSON documents from java classes using gson

This Graphics2D class extends the Graphics class to provide more sophisticated
control overgraphics 

java.awt.Graphics2D

ArrayList is an implementation of List, backed by an array. All optional
operations including adding

java.util.ArrayList

A specific moment in time, with millisecond precision. Values typically come
from System#currentTime

java.util.Date

SortedSet is a Set which iterates over its elements in a sorted order. The order
is determined eithe

java.util.SortedSet

Timers schedule one-shot or recurring TimerTask for execution. Prefer
java.util.concurrent.Scheduled

java.util.Timer

A Handler object accepts a logging request and exports the desired messages to a
target, for example

java.util.logging.Handler

scheduleAtFixedRate

setScale

onRequestPermissionsResult

/**
     * 
     * Reads all of the schemas that are imported by the given schema and adds
     * their content to its parent Node. This method is recursive - it will read
     * through the imported schemas and resolve their imports as well. The
     * method tracks the namespaces is resolves so that no duplicates are
     * imported.
     * 
     * @param schemaContainer
     *            The Element that contains the schema being evaluated. Imported
     *            schemas will be appended to this Element.
     * 
     * @param currentSchema
     *            The schema whose imports will be resolved.
     * 
     * @param path
     *            The path of the document that contains the current schema.
     *            This is used to resolve the paths of the imported schemas.
     * 
     * @param environment
     *            The Muse environment is used to load the imported schema
     *            files.
     * 
     * @param namespaces
     *            The set of namespace URIs that have already been processed.
     *            This allows the method to skip those schemas that have already
     *            been processed via other imports and not duplicate XML.
     * 
     */

// This is to guard against imports that do not have a location

// such as imports in a WSDL types section that reference

// if the target namespace hasn't been seen before, we can add it

// record that we found it before reading through the doc

/**
     * 
     * Loads the WSDL at the given path, resolving any imports if desired.
     * 
     * @param environment
     *            The Muse environment is used to load the WSDL file.
     * 
     * @param wsdlPath
     *            The relative path of the WSDL file.
     * 
     * @param resolveReferences
     *            True if you want the method to process and WSDL and XSD
     *            imports that are in the WSDL document. The resulting Document
     *            may be much larger depending on how many imports are
     *            discovered while the method recurses through the other
     *            WSDLs/XSDs.
     * 
     * @return A Document with the WSDL content. If the last parameter was
     *         'true', the Document will have the contents of other WSDLs and
     *         XSDs merged into it.
     * 
     */

// if they just want the doc, we can quit now

// otherwise we must process all imports/includes, then add in

// any WSDL imports and merge them together

// ...then create all WSDLs that were imported...

/**
     * 
     * Reads all of the schemas that are included by the given schema and adds
     * their content to it. The method is recursive - it will read through each
     * included schema and resolve its imports and includes. The method tracks
     * the namespaces is resolves so that no duplicates are imported.
     * 
     * @param finalSchema
     *            The original schema whose includes are being resolved. All
     *            included schema content will be added to this node.
     * 
     * @param currentSchema
     *            The schema whose includes and imports are being resolved. In
     *            the initial call to this method, finalSchema and currentSchema
     *            should be the same node. As the method recurses, currentSchema
     *            will be the included schema that is being processed.
     * 
     * @param path
     *            The path of the document that contains the current schema.
     *            This is used to resolve the paths of the imported schemas.
     * 
     * @param environment
     *            The Muse environment is used to load the included schema
     *            files.
     * 
     * @param namespaces
     *            The set of namespace URIs that have already been processed.
     *            This allows the method to skip those schemas that have already
     *            been processed via other imports/includes and not duplicate
     *            XML.
     * 
     */

// copy the included schema content into this schema directly

// copy namespace prefixes from the schema

// now resolve the imports in the included schema - any imports

// will be added to the schema's parent element (since they have

// finally, recurse and process the new schema's includes

// sanity check - make sure we only initialize once

// this flag is never modified anywhere else, so we can read it 

// NOTE: we set the flag here so that if the router's initialize() 

//       makes remote requests that are serviced by this same 

//       endpoint, we don't end up in an infinite recursion

// put all custom serializers in the serializer registry

// create the router, which will instantiate resources that 

// are specified in the deployment descriptor (using the 

// /muse/resource-type/@instances-at-startup attribute)

// the router didn't finish initializing, so there's probably 

// no log to write to. just print to the console

/**
     * 
     * @param wsdl
     *        The DOM document holding the resource's WSDL.
     *        
     * @return The metadata descriptor referenced in the resource's WSDL, or 
     *         an 'open' descriptor (no restrictions) if none is found.
     *
     */

// load the doc and parse into a descriptor

// pre-existing consumer is optional - other consumers can 

How to use getDocumentmethodin org.apache.muse.core.Environment

Best Java code snippets using org.apache.muse.core.Environment.getDocument (Showing top 6 results out of 315)

How to use
getDocument
method
in
org.apache.muse.core.Environment