Public

Get the mode (IN, INOUT, OUT) of the parameter.

getMode

Get the name of this parameter. This call is equivalent to
getQName().getLocalPart().

getName

getType

Get the fully qualified name of this parameter.

getQName

Is this parameter in the input message header?

isInHeader

Is this parameter in the output message header?

isOutHeader

<init>

getMIMEInfo

Indicates whether this parameter is nillable or not.

isNillable

isOmittable

Set the inHeader flag for this parameter.

setInHeader

setMIMEInfo

Set the mode (IN, INOUT, OUT) of the parameter. If the input to this method is
not one of IN, INOUT,

setMode

Set the name of the parameter. This replaces both the name and the QName (the
namespaces becomes "")

setName

Indicate whether this parameter is nillable or not.

setNillable

setOmittable

Set the outHeader flag for this parameter.

setOutHeader

setQName

setType

Parameter

Parsing JSON documents to java classes using gson

A Rectangle specifies an area in a coordinate space that is enclosed by the 
Rectangle object's top-

java.awt.Rectangle

Thrown when a program encounters the end of a file or stream during an input
operation.

java.io.EOFException

A ConnectException is thrown if a connection cannot be established to a remote
host on a specific po

java.net.ConnectException

This exception is thrown when a program attempts to create an URL from an
incorrect specification.

java.net.MalformedURLException

An exception that indicates a failed JDBC operation. It provides the following
information about pro

java.sql.SQLException

A reentrant mutual exclusion Lock with the same basic behavior and semantics as
the implicit monitor

java.util.concurrent.locks.ReentrantLock

findViewById

getApplicationContext

putExtra

/**
     * For the given operation, this method returns the parameter info conveniently collated.
     * There is a bit of processing that is needed to write the interface, stub, and skeleton.
     * Rather than do that processing 3 times, it is done once, here, and stored in the
     * Parameters object.
     *
     * @param operation
     * @param namespace
     * @param bindingEntry
     * @return
     * @throws IOException
     */

// The input and output Vectors of Parameters

// Handle parameterOrder="", which is techinically illegal

// All input parts MUST be in the parameterOrder list.  It is an error otherwise.

// Construct a list of the parameters in the parameterOrder list, determining the

// mode of each parameter and preserving the parameterOrder list.

// index in the inputs Vector of the given name, -1 if it doesn't exist.

// index in the outputs Vector of the given name, -1 if it doesn't exist.

// The mode of this parameter is either in or inout

// Some special case logic for JAX-RPC, but also to make things

// If we have a single input and output with the same name

// instead of: void echo(StringHolder inout)

// add the input and make sure its a IN not an INOUT

// Get the mode info about those parts that aren't in the

// parameterOrder list. Since they're not in the parameterOrder list,

// the order is, first all in (and inout) parameters, then all out

// parameters, in the order they appear in the messages.

// Now that the remaining in and inout parameters are collected,

// determine the status of outputs.  If there is only 1, then it

// is the return value.  If there are more than 1, then they are

// make sure we dont have a duplicate name

/**
     * This method returns a vector containing Parameters which represent
     * each Part (shouldn't we call these "Parts" or something?)
     *
     * This routine does the wrapped doc/lit processing.
     * It is also used for generating Faults, and this really confuses things
     * but we need to do the same processing for the fault messages.
     *
     * This whole method is waaaay too complex.
     * It needs rewriting (for instance, we sometimes new up
     * a Parameter, then ignore it in favor of another we new up.)
     *
     * @param v       The output vector of parameters
     * @param parts   The parts of the message
     * @param literal Are we in a literal operation (or fault)?
     * @param opName  The operation (or fault) name
     * @param bindingEntry The binding for this operation - can be NULL if we are looking at a fault
     * @throws IOException when encountering an error in the WSDL
     */

// Determine if there's only one element.  For wrapped

// style, we normally only have 1 part which is an

// element.  But with MIME we could have any number of

// types along with that single element.  As long as

// there's only ONE element, and it's the same name as

// Try to sense "wrapped" document literal mode

// - That element has the same name as the operation

// - That element has no attributes (check done below)

// Just an FYI: The WSDL spec says that for use=encoded

// that parts reference an abstract type using the type attr

// but we kinda do the right thing here, so let it go.

// See if we can map all the XML types to java(?) types

// Since we can't (yet?) make the Axis engine generate the right

// XML for literal parts that specify the type attribute,

// (unless they're MIME types) abort processing with an

// node = getTypeEntry(typeName, false).getNode();

// Get the node which corresponds to the type entry for this

// <element name="bar"...>  <--- This one

// <element name="foo" type="tns:foo_type"/>

// If in fact we have such a type, go get the node that

// If we have nothing at this point, we're in trouble.

// If node is null, that means the element in question has no type declaration,

// mark the type entry as not just literal referenced

// This doesn't work, but it may help in the future.

// The problem is "wrapped" is a symbol table wide flag,

// which means if one operation breaks the rules

How to use setNamemethodin org.apache.axis.wsdl.symbolTable.Parameter

Best Java code snippets using org.apache.axis.wsdl.symbolTable.Parameter.setName (Showing top 6 results out of 315)

How to use
setName
method
in
org.apache.axis.wsdl.symbolTable.Parameter