com.sun.logging.enterprise.system.webservices.rpc.LogDomains.properties Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common-util
There is a newer version: 10.0-b28
# Copyright 2004 Sun Microsystems, Inc. All rights reserved.
# SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
#
# Log messages used by the javax.enterprise.core.security logger
# LogDomains.SECURITY_LOGGER, subsystem SEC.
# See java.text.MessageFormat for details on constructing messages.
# Messages in this file must be of the form
# <4CharIntegerMessageId>:
#
#example.message1=JAXRPC0001:Test Message. Parameter 1={0} parameter 2={1}
#example.message2=JAXRPC0002:Date Message. Parameter 1={0,date} Parameter 2={1,time}
#example.message3=JAXRPC0003:Number Message. Parameter 1={0,number,integer}

#
#
error.caughtExceptionWhileHandlingRequest=JAXRPC0001:caught exception while handling request: {0}
error.caughtExceptionWhilePreparingResponse=JAXRPC0002:caught exception while preparing response: {0}
error.caughtExceptionPostHandlingRequest=JAXRPC0003:caught exception while invoking the post handling hook: {0}
#
message.faultMessageForException=JAXRPC0004:Internal Server Error ({0})

#
#
# the following properties are used by the http package
#
#

runtime.parser.classNotFound=JAXRPC1001:class not found: {0}
runtime.parser.xmlReader=JAXRPC1002:error parsing runtime descriptor: {0}
runtime.parser.invalidReaderState=JAXRPC1003:error parsing runtime descriptor: {0}
runtime.parser.unexpectedContent=JAXRPC1004:unexpected content in runtime descriptor (line {0})
runtime.parser.invalidElement=JAXRPC1005:invalid element \"{1}\" in runtime descriptor (line {0})
runtime.parser.invalidAttributeValue=JAXRPC1006:invalid value for attribute \"{2}\" of element \"{1}\" in runtime descriptor (line {0})
runtime.parser.invalidVersionNumber=JAXRPC1007:unsupported runtime descriptor version: {2}
runtime.parser.missing.attribute=JAXRPC1008:missing attribute \"{2}\" in element \"{1}\" of runtime descriptor (line {0})
runtime.parser.invalid.attribute.value=JAXRPC1009:invalid attribute value \"{1}\" in runtime descriptor (line {0})
runtime.parser.missing.attribute.no.line=JAXRPC1010:missing attribute \"{2}\" in element \"{1}\" of runtime descriptor
listener.parsingFailed=JAXRPC1011:failed to parse runtime descriptor: {0}
listener.info.initialize=JAXRPC1012:JAX-RPC context listener initializing
listener.info.destroy=JAXRPC1013:JAX-RPC context listener destroyed
servlet.info.initialize=JAXRPC1014:JAX-RPC servlet initializing
servlet.info.destroy=JAXRPC1015:JAX-RPC servlet destroyed
servlet.warning.missingContextInformation=JAXRPC1016:missing context information
servlet.warning.duplicateEndpointName=JAXRPC1017:duplicate endpoint name
servlet.info.emptyRequestMessage=JAXRPC1018:got empty request message
servlet.trace.gotRequestForEndpoint=JAXRPC1019:got request for endpoint: {0}
servlet.error.noImplementorForEndpoint=JAXRPC1020:no implementor for endpoint: {0}
servlet.trace.invokingImplementor=JAXRPC1021:invoking implementor: {0}
servlet.error.noEndpointSpecified=JAXRPC1022:no endpoint specified
servlet.error.noResponseMessage=JAXRPC1023:no response message
servlet.trace.writingFaultResponse=JAXRPC1024:writing fault response
servlet.trace.writingSuccessResponse=JAXRPC1025:writing success response
servlet.warning.duplicateEndpointUrlPattern=JAXRPC1026:duplicate URL pattern in endpoint: {0}
servlet.warning.ignoringImplicitUrlPattern=JAXRPC1027:unsupported implicit URL pattern in endpoint: {0}
servlet.faultstring.missingPort=JAXRPC1028:Missing port information
servlet.faultstring.portNotFound=JAXRPC1029:Port not found ({0})
servlet.faultstring.internalServerError=JAXRPC1030:Internal server error ({0})
publisher.info.applyingTransformation:applying transformation with actual address: {0}
publisher.info.generatingWSDL=JAXRPC1031:generating WSDL for endpoint: {0}
exception.cannotCreateTransformer=JAXRPC1032:cannot create transformer
exception.transformationFailed=JAXRPC1033:transformation failed
exception.templateCreationFailed=JAXRPC1034:failed to create a template object
servlet.html.title=Web Services
servlet.html.title2=Web Services
servlet.html.noInfoAvailable=No JAX-RPC context information available.
servlet.html.columnHeader.portName=Port Name
servlet.html.columnHeader.status=Status
servlet.html.columnHeader.information=Information
servlet.html.status.active=ACTIVE
servlet.html.status.error=ERROR
servlet.html.information.table= \
    \
    \
    \
    \
    \
    \
    \
    \
    \
    \
    \
    \
    \
    Address: {0}
WSDL: {0}?WSDL
Port QName: {1}
Remote interface: {2}
Implementation class: {3}
Model: {0}?model
servlet.html.notFound=404 Not Found: {0}

#
#
# all the following properties are used by the http/ea package
#
#
error.implementorFactory.noConfiguration=JAXRPC2001:no configuration specified
error.implementorFactory.noInputStream=JAXRPC2002:no configuration specified
error.implementorRegistry.unknownName=JAXRPC2003:unknown port name: {0}
error.implementorRegistry.cannotReadConfiguration=JAXRPC2004:cannot read configuration
error.implementorRegistry.classNotFound=JAXRPC2005:class not found: {0}
error.implementorRegistry.incompleteInformation=JAXRPC2006:configuration information is incomplete
error.implementorRegistry.duplicateName=JAXRPC2007:duplicate port name: {0}
error.implementorFactory.newInstanceFailed=JAXRPC2008:failed to instantiate service implementor for port \"{0}\"
error.implementorFactory.servantInitFailed=JAXRPC2009:failed to initialize the service implementor for port \"{0}\"
error.implementorRegistry.fileNotFound=JAXRPC2010:file not found: {0}
error.wsdlPublisher.cannotReadConfiguration=JAXRPC2011:cannot read configuration
error.servlet.init.config.parameter.missing=JAXRPC2012:cannot find configuration parameter: \"{0}\"
error.servlet.init.config.fileNotFound=JAXRPC2013:config file: \"{0}\" not found
#
error.servlet.caughtThrowable=JAXRPC2014:caught throwable: {0}
error.servlet.caughtThrowableInInit=JAXRPC2015:caught throwable during servlet initialization: {0}
error.servlet.caughtThrowableWhileRecovering=JAXRPC2016:caught throwable while recovering from a previous exception: {0}
error.servlet.noImplementorForPort=JAXRPC2017:no implementor registered for port: {0}
error.servlet.noPortSpecified=JAXRPC2018:no port specified in HTTP POST request URL
error.servlet.noResponseWasProduced=JAXRPC2019:no response was produced (internal error)
#
info.servlet.gotEmptyRequestMessage=JAXRPC2020:got empty request message
info.servlet.initializing=JAXRPC2021:JAX-RPC servlet: init
info.servlet.destroying=JAXRPC2022:JAX-RPC servlet: destroy
#
trace.servlet.requestForPortNamed=JAXRPC2023:got request for port: {0}
trace.servlet.handingRequestOverToImplementor=JAXRPC2024:handing request over to implementor: {0}
trace.servlet.gotResponseFromImplementor=JAXRPC2025:got response from implementor: {0}
trace.servlet.writingFaultResponse=JAXRPC2026:writing fault response
trace.servlet.writingSuccessResponse=JAXRPC2027:writing success response
#
html.nonRootPage.title=Web Service
html.nonRootPage.body1=A Web Service is installed at this URL.
html.nonRootPage.body2=Invalid request URI.
Please check your deployment information.
html.nonRootPage.body3a=Please refer to this page for information about the deployed services.
html.wsdlPage.title=Web Service
html.wsdlPage.noWsdl=No WSDL document available for publishing.
Please check your deployment information.
html.rootPage.title=Web Service
html.rootPage.body1=A Web Service is installed at this URL.
html.rootPage.body2a=It supports the following ports: 
html.rootPage.body2b=
html.rootPage.body3a=A WSDL description of these ports is available here.
html.rootPage.body4=This endpoint is incorrectly configured. Please check the location and contents of the configuration file.

#
#
http.client.cannot.connect=JAXRPC3001:cannot connect to server: {0}
http.client.failed=JAXRPC3002:HTTP transport error: {0}
local.client.failed=JAXRPC3003:local transport error: {0}
http.client.cannotCreateMessageFactory=JAXRPC3004:cannot create message factory


#
#
configuration.nestedConfigurationError=JAXRPC4001:configuration error: {0}
configuration.missing.attribute=JAXRPC4002:missing configuration attribute \"{2}\" in element \"{1}\" (line {0})
configuration.invalid.attribute.value=JAXRPC4003:invalid attribute value \"{1}\" (line {0})
configuration.rmi.duplicate.interface=JAXRPC4004:duplicate interface found: {0}
#
#
#
configuration.xmlReader=JAXRPC4005:error parsing configuration file: {0}
configuration.invalidReaderState=JAXRPC4006:error parsing configuration file: {0}
configuration.unexpectedContent=JAXRPC4007:unexpected content in configuration file (line {0})
configuration.invalidElement=JAXRPC4008:invalid element \"{1}\" in configuration file (line {0})
configuration.invalidAttributeValue=JAXRPC4009:invalid value for attribute \"{2}\" of element \"{1}\" in configuration file (line {0})
configuration.invalidVersionNumber=JAXRPC4010:unsupported configuration file version: {2}
configuration.missing.model=JAXRPC4011:missing model in configuration file (line {0})
configuration.unknown.serviceInfo=JAXRPC4012:unknown service info in configuration file (line {0})
configuration.unknown.modelInfo=JAXRPC4013:unknown model info in configuration file (line {0})
configuration.handlerChain.duplicate=JAXRPC4014:duplicate handler chain found: \"{2}\" (line {0})
configuration.invalidImport.targetNamespace=JAXRPC4015:cannot specify imported schema for target namespace: \"{0}\"
configuration.invalidImport.targetTypeNamespace=JAXRPC4016:cannot specify imported schema for target type namespace: \"{0}\"

#
#
#
deployment.parser.xmlReader=JAXRPC5001:error parsing deployment descriptor: {0}
deployment.parser.invalidReaderState=JAXRPC5002:error parsing deployment descriptor: {0}
deployment.parser.unexpectedContent=JAXRPC5003:unexpected content in deployment descriptor (line {0})
deployment.parser.invalidElement=JAXRPC5004:invalid element \"{1}\" in deployment descriptor (line {0})
deployment.parser.invalidAttributeValue=JAXRPC5005:invalid value for attribute \"{2}\" of element \"{1}\" in deployment descriptor (line {0})
deployment.parser.invalidVersionNumber=JAXRPC5006:unsupported deployment descriptor version: {2}
deployment.parser.missing.attribute=JAXRPC5007:missing attribute \"{2}\" in element \"{1}\" of deployment descriptor (line {0})
deployment.parser.invalid.attribute.value=JAXRPC5008:invalid attribute value \"{1}\" in deployment descriptor (line {0})
deployment.parser.missing.attribute.no.line=JAXRPC5009:missing attribute \"{2}\" in element \"{1}\" of deployment descriptor


#
# $Id: LogDomains.properties,v 1.2 2004/02/20 03:43:54 qouyang Exp $
#
service.exception.nested=JAXRPC6001:service error: {0}
service.interface.required=JAXRPC6002:not an interface: {0}
service.implementation.not.found=JAXRPC6003:cannot locate service implementation class for service: {0}
service.implementation.cannot.create=JAXRPC6004:failed to create service implementation instance: {0}
dii.exception.nested=JAXRPC6005:dynamic invocation error: {0}
dii.service.does.not.contain.port=JAXRPC6006:service: {0} does not contain port: {1}
dii.port.does.not.contain.operation=JAXRPC6007:port: {0} does not contain operation: {1}
dii.required.property.not.set=JAXRPC6008:property: "{0}" must be set on a Call object before it can be invoked in this configuration
dii.parameter.type.unknown=JAXRPC6009:no serializer/deserializer could be found for parameter number: {0}, named: "{1}", class: {2}, type: "{3}"
dii.parameter.type.ambiguous.no.class=JAXRPC6010:the serializer/deserializer for parameter number: {0}, named: "{1}", type: "{2}", is ambiguous because its class could not be determined
dii.parameter.type.ambiguous.no.typename=JAXRPC6011:the serializer/deserializer for parameter number: {0}, named: "{1}", class: {2}, is ambiguous because its XML type could not be determined
dii.parameter.type.underspecified=JAXRPC6012:the serializer/deserializer for parameter number: {0}, named: "{1}" cannot be found because no class or XML type could be determined for it
dii.parameter.count.exceeded=JAXRPC6013:expected only {0} parameter(s)
dii.typeregistry.encodingstyle.unrecognized=JAXRPC6014:encoding style "{0}" not found in type registry
dii.typeregistry.missing.in.call=JAXRPC6015:call object cannot be created without a TypeRegistry
dii.call.property.set.unrecognized=JAXRPC6016:cannot set unrecognized property: {0} on a Call object
dii.call.property.get.unrecognized=JAXRPC6017:cannot get unrecognized property: {0} on a Call object
dii.service.cant.create.call.without.registry=JAXRPC6018:service cannot create Call object until a TypeRegistry has been set using setTypeMappingRegistry()
dii.service.cant.create.proxy.parameter.name.type.mismatch=JAXRPC6019:number of parameter types does not match number of parameter names for method: {0}
dii.service.no.wsdl.available=JAXRPC6020:WSDL data missing, this operation is not available
dii.parameter.invalid.type=JAXRPC6021:parameter was expected to be of type: {0} but was of type: {1} instead
dii.outparameters.not.available=JAXRPC6022:output parameters are only available after Invoke() has been called
dii.parameterandreturntypespec.not.allowed=JAXRPC6023:cannot set parameter or return types on this Call object
dii.operation.style.unsupported=JAXRPC6024:operation style: "{0}" not supported
dii.encoding.style.unsupported=JAXRPC6025:encoding style: "{0}" not supported
dii.wsdl.service.unknown=JAXRPC6026:could not find service: {0} in the specified WSDL file. The service names found were: {1}
dii.dynamicproxy.method.unrecognized=JAXRPC6027:could not dispatch to method: {0} known methods are: {1}

#
#

#nested
nestedSerializationError=JAXRPC7001:serialization error: {0}
nestedDeserializationError=JAXRPC7002:deserialization error: {0}
nestedEncodingError=JAXRPC7003:encoding error: {0}

#soap
soap.malformedArrayType=JAXRPC7004:malformed array type: {0}
soap.tooManyArrayElements=JAXRPC7005:serialized array has too many elements
soap.illegalArrayElementPosition=JAXRPC7006:illegal array element position: {0}
soap.missingArrayElementPosition=JAXRPC7007:missing array element position
soap.outOfBoundsArrayElementPosition=JAXRPC7008:array element position is out of bounds: {0}
soap.unexpectedNull=JAXRPC7009:unexpected null
soap.unexpectedReference=JAXRPC7010:unexpected reference
soap.unexpectedElementName=JAXRPC7011:unexpected element name: expected={0}, actual={1}
soap.unexpectedElementType=JAXRPC7012:unexpected element type: expected={0}, actual={1}
soap.unexpectedArrayElementType=JAXRPC7013:unexpected array element type: expected={0}, actual={1}
soap.nonLocalReference=JAXRPC7014:non-local reference (href): {0}
soap.context.not.soapSerialization=JAXRPC7015:non-SOAP serialization context
soap.context.not.soapDeserialization=JAXRPC7016:non-SOAP deserialization context
soap.missingTrailingBlockID=JAXRPC7017:trailing block elements must have an id attribute
soap.missingContentID=JAXRPC7018:attachments must have a Content-ID attribute
soap.malformedArrayDimensions=JAXRPC7019:malformed array dimensions: {0}
soap.irregularMultiDimensionalArray=JAXRPC7020:multi-dimensional array is not regular
soap.illegalArrayOffset=JAXRPC7021:illegal array offset: {0}
soap.unexpectedArrayRank=JAXRPC7022:array has unexpected rank: expected={0}, actual={1}, arrayType={2}
soap.unexpectedArrayDimensions=JAXRPC7023:array has unexpected dimensions: expected={0}, actual={1}, arrayType={2}
soap.unexpectedEncodingStyle=JAXRPC7024:unexpected encoding style: expected={0}, actual={1}
soap.unspecifiedType=JAXRPC7025:annot encode XML type because it was not specified
soap.duplicate.data.member=JAXRPC7026:member {0} has already been defined
soap.incompleteObject=JAXRPC7027:incomplete object encountered while deserializing
soap.circularReferenceDetected=JAXRPC7028:circular reference detected while serializing: {0}
soap.missing.attachment.for.id=JAXRPC7029:no attachment with id \"{0}\" found in message
soap.multiple.attachments.for.id=JAXRPC7030:multiple attachments with the same id \"{0}\" found in message
soap.no.attachment.encoder.and.serializeAsAttachment=JAXRPC7031:serializeAsAttachment specified but no AttachmentEncoder was provided for type: \"{0}\"
soap.state.wont.notify.without.deserializer=JAXRPC7032:internal error: a deserializer must be registered with a deserialization state before it will accept listeners
soap.unsupportedType=JAXRPC7033:cannot decode XML type \"{0}\"
soap.cannot.serialize.type=JAXRPC7034:cannot serialize type \"{0}\"

# xsd
xsd.unexpectedElementName=JAXRPC8001:unexpected element name: expected={0}, actual={1}
xsd.unexpectedElementType=JAXRPC8002:unexpected element type: expected={0}, actual={1}
xsd.unexpectedNull=JAXRPC8003:unexpected null
xsd.unknownPrefix=JAXRPC8004:unknown prefix in QName literal: {0}
xsd.invalid.date=JAXRPC8005:invalid date

# typemapping
typemapping.nested.exception=JAXRPC9001:type mapping error: {0}
typemapping.nested.exception.static.initialization=JAXRPC9002:type mapping static initialization error: {0}
typemapping.mechanism.unsupported=JAXRPC9003:{0} : is not a supported (de)serialization mechanism
typemapping.registration.failed.nested.exception=JAXRPC9004:type mapping registration failed: {0}
typemapping.retrieval.failed.nested.exception=JAXRPC9005:ype mapping retrieval failed: {0}
typemapping.mappingDoesNotSupportEncoding=JAXRPC9006:type mapping does not support the specified encoding: {0}
typemapping.noMappingForEncoding=JAXRPC9007:there is no type mapping for the specified encoding: {0}
typemapping.serializerNotRegistered=JAXRPC9008:no serializer is registered for ({0}, {1})
typemapping.deserializerNotRegistered=JAXRPC9009:no deserializer is registered for ({0}, {1})
typemapping.serializer.is.dynamic=JAXRPC9010:dynamic resolution failed to find a serializer for java type:{0}, xml type {1}
typemapping.serializer.definition.recursive=JAXRPC9011:dynamic resolution found a recursive definition for java type: {0}, xmlType: {1}
typemapping.deserializer.is.dynamic=JAXRPC9012:dynamic resolution failed to find a deserializer for {0}
typemapping.not.serializable=JAXRPC9013:Could not serialze registry, type: {0} does not extend Serializable

# typemappingregistry
typemappingregistry.not.serializable=JAXRPC1101:Could not serialze internal registry, type: {0} does not extend Serializable

# literal
literal.unexpectedNull=JAXRPC1102:unexpected null value for literal data
literal.unexpectedElementName=JAXRPC1103:unexpected element name: expected={0}, actual={1}
literal.expectedElementName=JAXRPC1104:expected element is missing: {0}
literal.missingRequiredAttribute=JAXRPC1105:missing required attribute: {0}

# initializable
initializable.not.initialized=JAXRPC1106:object not initialized before use

type.is.not.array=JAXRPC1107:{0} is not an array type

request.parameter.count.incorrect=JAXRPC1108:expected {0} parameter(s) but received: {1}. Expected parameters: {3} Got parameters:{4}
deserializationstate.deserialize.no.deserializer=JAXRPC1109:illegal deserialization state: no deserializer is available for the current element


#
#

# Generator
generator.nestedGeneratorError=JAXRPC1201:generator error: {0}
generator.cant.write=JAXRPC1202:can''t write file: {0}
generator.cannot.create.dir=JAXRPC1203:can''t create directory: {0}
generator.array.of.array.not.supported=JAXRPC1204:arrays of arrays are not supported.
generator.unsupported.type.encountered=JAXRPC1205:unsupported type encountered: {0} (ns: {1})
generator.internal.processing.error.port=JAXRPC1206:there has been an internal processing error on port: {0}
generator.invalid.model.state.no.javatype=JAXRPC1207:no JavaType for type: {0}
generator.invalid.serializerinfo=JAXRPC1208:invalid serializerInfo for type: {0}, serializerInfo: {1}
generator.unsupported.encoding.encountered=JAXRPC1209:unsupported encoding encountered: {0}
generator.internal.error.should.not.happen=JAXRPC1210:internal error (should not happen): {0}
generator.literalTypesNotSupported=JAXRPC1211:literal types are not supported: {0} (ns: {1})

# stub
generator.stub.invalid.port.address=JAXRPC1212:invalid port address: {0}
generator.stub.generating.stub=JAXRPC1213:generating Stub: {0}...

# tie
generator.tie.cannot.dispatch=JAXRPC1214:cannot dispatch operation: {0}
generator.tie.operation.nameNotUnique=JAXRPC1215:cannot generate tie class: non-unique operation name detected: {0}
generator.tie.port.cannot.dispatch=JAXRPC1216:cannot dispatch to port(non-unique operations names and non-unique SOAPAction strings): {0}
generator.tie.generating.tie=JAXRPC1217:generating Tie: {0}...


# remoteInterface
generator.remoteInterface.invalidOperation=JAXRPC1218:invalid operation: {0}
generator.remoteInterface.multipleOutputParameters=JAXRPC1219:multiple \"out\" parameters in operation: {0}
generator.remoteInterface.resultIsInOutParameter=JAXRPC1220:result is \"inout\" parameter in operation: {0}
generator.remoteInterface.notSoapType=JAXRPC1221:not a SOAP type: \"{0}\"

# simpleTypeSerializerWriter
generator.simpleTypeSerializerWriter.no.encoder.for.type=JAXRPC1222:no encoder for type \"{0}\" and Java type \"{1}\"

# serializerRegistryGenerator
generator.serializerRegistryGenerator.warning.no.standard.simpletype.serialzer=JAXRPC1223:no serializer found for simpletype \"{0}\" and Java type \"{1}\" in StandardSerializerRegistry


#
#
handler.nestedError=JAXRPC1224:handler error: {0}
handler.chain.contains.handler.only=JAXRPC1225:A HandlerChain can only contain Handler instances: {0}
handler.cant.instantiate=JAXRPC1226:Unable to instantiate handler: {0} because: {1}


#
#


model.nestedModelError=JAXRPC1227:model error: {0}
model.duplicate.porttype=JAXRPC1228:duplicate PortType added to model: {0}
model.duplicate.operation=JAXRPC1229:duplicate Operation added to model: {0}
model.duplicate.faultmessage=JAXRPC1230:duplicate fault message added to model: {0}
model.duplicate.part=JAXRPC1231:duplicate part added to model: {0}
model.duplicate.property=JAXRPC1232:duplicate property added to model: {0}
model.duplicate.service=JAXRPC1233:duplicate service added to model: {0}
model.invalid.message.type=JAXRPC1234:invalid message type: {0}
model.schema.notImplemented=JAXRPC1235:unsupported XML Schema feature ({0})
model.schema.circularity=JAXRPC1236:circularity detected in schema: \"{0}\"
model.schema.invalidType=JAXRPC1237:invalid type: \"{0}\" (namespace: {1})
model.schema.unsupportedType=JAXRPC1238:unsupported type ({0}): \"{1}\" (namespace: {2})
model.schema.unsupportedType.anonymous=JAXRPC1239:unsupported anonymous type ({0})
model.schema.invalidLiteralInEnumeration=JAXRPC1240:invalid literal \"{0}\" in enumeration \"{1}\" (namespace: {2})
model.schema.invalidLiteralInEnumeration.anonymous=JAXRPC1241:invalid literal \"{0}\" in anonymous enumeration
model.uniqueness=JAXRPC1242:uniqueness constraint violation
model.parent.type.already.set=JAXRPC1243:parent of type \"{0}\" already set to \"{1}\", new value = \"{2}\"
model.parent.fault.already.set=JAXRPC1244:parent of fault \"{0}\" already set to \"{1}\", new value = \"{2}\"
model.exporter.unsupportedClass=JAXRPC1245:model exporter: unsupported class: {0}
model.importer.nonModel=JAXRPC1246:not a valid model document
model.importer.syntaxError=JAXRPC1247:syntax error in model document (line {0})
model.importer.invalidVersion=JAXRPC1248:invalid version \"{1}\" in model document (line {0})
model.importer.invalidClass=JAXRPC1249:invalid class name \"{1}\" in model document (line {0})
model.importer.invalidId=JAXRPC1250:invalid id \"{1}\ in model document (line {0})
model.importer.invalidLiteral=JAXRPC1251:invalid literal value in model document (line {0})
model.importer.invalidProperty=JAXRPC1252:invalid property in model document (line {0}


#
#

# general
modeler.nestedModelError=JAXRPC53:modeler error: {0}

# RmiModeler
rmimodeler.cannot.instantiate=JAXRPC1254:cannot instantiate class: {0}
rmimodeler.invalid.remote.interface=JAXRPC1255:invalid remote interface: {0}
rmimodeler.class.not.found=JAXRPC1256:class {0} not found.
rmimodeler.invalid.exception=JAXRPC1257:exception \"{0}\" is unsupported.
rmimodeler.invalid.rmi.type=JAXRPC1258:invalid type for JAX-RPC structure: {0}
rmimodeler.unexpected.type=JAXRPC1259:unexpected type: {0}
rmimodeler.invalid.encoding=JAXRPC1260:invalid encoding specified: {0}
rmimodeler.type.cannot.implement.remote=JAXRPC1261:type cannot implement remote: {0}
rmimodeler.type.does.not.implement.serializable=JAXRPC1262:type {0} does not implement serializable
rmimodeler.no.empty.constructor=JAXRPC1263:class {0} does not have a public accessible empty constructor
rmimodeler.ambiguous.member=JAXRPC1264:ambiguous member: {0}
rmimodeler.nestedRmiModelerError=JAXRPC1265:RmiModeler error: {0}
rmimodeler.could.not.resolve.property.type=JAXRPC1266:could not resolve property type: {0}
rmimodeler.property.setter.method.cant.be.overloaded=JAXRPC1267:property setter \"{0}\" of type \"{1}\" on class \"{2}\" cannot be overloaded
rmimodeler.must.implement.remote=\
	JAXRPC1268:invalid remote interface; class {0} does not implement an interface that extends java.rmi.Remote
rmimodeler.must.implement.remote.directly=\
	JAXRPC1269:invalid remote interface; class {0} does not directly implement a remote interface
rmimodeler.must.throw.remoteexception=\
	JAXRPC1270:{0} is not a valid remote interface: method {1} must throw java.rmi.RemoteException
rmimodeler.javabean.property.has.public.member: class \"{0}\" cannot have a JavaBean property \"{1}\" and a public member of the same name. 
rmimodeler.nested.inner.classes.not.supported=JAXRPC1271:nested inner classes are not supported: {0}
rmimodeler.must.not.extend.runtimeexception=JAXRPC1272:Service specific exceptions must not extend RuntimeException: {0}
rmimodeler.duplicate.type.name:JAXRPC1273:Duplicate type name \"{0}\" for Java type \"{1}\" found
rmimodeler.field.not.found=JAXRPC1274:Field \"{0}\" of Java class \"{1}\" not found.
rmimodeler.type.is.used.as.two.types=JAXRPC1275:Type \"{0}\" is used as a \"{1}\" and a \"{2}\"

# WSDLModeler
wsdlmodeler.multipleOutputParameters=JAXRPC1276:multiple \"out\" parameters in operation: {0}
wsdlmodeler.invalidOperation=JAXRPC1277:invalid operation: {0}
wsdlmodeler.resultIsInOutParameter=JAXRPC1278:result is \"inout\" parameter in operation: {0}
wsdlmodeler.invalid.parameterorder.parameter=JAXRPC1279:\"{0}\" specified in the parameterOrder attribute of message \"{1}\" is not a valid part of the message.
wsdlmodeler.invalid.parameterOrder.tooManyUnmentionedParts=JAXRPC1280:more than one part left out in the parameterOrder attribute of operation \"{0}\"
wsdlmodeler.invalid.parameter.differentTypes=JAXRPC1281:parameter \"{0}\" of operation \"{1}\" appears with different types in the input and output messages
wsdlmodeler.invalid.bindingOperation.notInPortType=JAXRPC1282:in binding \"{1}\", operation \"{0}\" does not appear in the corresponding port type
wsdlmodeler.invalid.bindingOperation.inputMissingSoapBody=JAXRPC1283:input message of binding operation \"{0}\" does not have a SOAP body extension
wsdlmodeler.invalid.bindingOperation.outputMissingSoapBody=JAXRPC1284:output message of binding operation \"{0}\" does not have a SOAP body extension
wsdlmodeler.invalid.bindingOperation.missingInputName=JAXRPC1285:binding operation \"{0}\" must specify a name for its input message
wsdlmodeler.invalid.bindingOperation.missingOutputName=JAXRPC1286:binding operation \"{0}\" must specify a name for its output message
wsdlmodeler.invalid.bindingOperation.multipleMatchingOperations=JAXRPC1287:in binding \"{1}\", operation \"{0}\" does not reference a unique operation in the corresponding port type
wsdlmodeler.invalid.bindingOperation.notFound=JAXRPC1288:in binding \"{1}\", operation \"{0}\" does not match any operation in the corresponding port type
wsdlmodeler.invalid.bindingOperation.inputSoapBody.missingNamespace=JAXRPC1289:input message of binding operation \"{0}\" must specify a value for the \"namespace\" attribute
wsdlmodeler.invalid.bindingOperation.outputSoapBody.missingNamespace=JAXRPC1290:output message of binding operation \"{0}\" must specify a value for the \"namespace\" attribute
wsdlmodeler.invalid.bindingOperation.inputHeader.missingNamespace=JAXRPC1291:input header \"{1}\" of binding operation \"{0}\" must specify a value for the \"namespace\" attribute
wsdlmodeler.invalid.bindingOperation.outputHeader.missingNamespace=JAXRPC1292:output header \"{1}\" of binding operation \"{0}\" must specify a value for the \"namespace\" attribute
wsdlmodeler.invalid.bindingFault.notUnique=JAXRPC1293:fault \"{0}\" in operation \"{1}\" matches more than one fault in the corresponding port type operation
wsdlmodeler.invalid.bindingFault.notFound=JAXRPC1294:fault \"{0}\" in operation \"{1}\" does not match any fault in the corresponding port type operation
wsdlmodeler.invalid.bindingFault.outputMissingSoapFault=JAXRPC1295:fault \"{0}\" in operation \"{1}\" does not have a SOAP fault extension
wsdlmodeler.invalid.bindingFault.missingName=JAXRPC1296:fault \"{0}\" in operation \"{1}\" must specify a value for the \"name\" attribute
wsdlmodeler.invalid.bindingFault.missingNamespace=JAXRPC1297:fault \"{0}\" in operation \"{1}\" must specify a value for the \"namespace\" attribute
wsdlmodeler.invalid.bindingFault.emptyMessage=JAXRPC1298:fault \"{0}\" refers to message \"{1}\", but the message has no parts
wsdlmodeler.invalid.bindingFault.messageHasMoreThanOnePart=JAXRPC1299:fault \"{0}\" refers to message \"{1}\", but the message has more than one parts
wsdlmodeler.invalid.message.partMustHaveTypeDescriptor=JAXRPC1301:in message \"{0}\", part \"{1}\" must specify a \"type\" attribute
wsdlmodeler.invalid=JAXRPC1302:invalid WSDL document
wsdlmodeler.unsolvableNamingConflicts=JAXRPC1303:the following naming conflicts occurred: {0}
#
wsdlmodeler.warning.ignoringUnrecognizedSchemaExtension=JAXRPC1304:ignoring schema element (unsupported version): {0}
wsdlmodeler.warning.searchSchema.unrecognizedTypes=JAXRPC1305:encountered {0} unrecognized type(s)
wsdlmodeler.warning.noServiceDefinitionsFound=JAXRPC1306:WSDL document does not define any services
wsdlmodeler.warning.noPortsInService=JAXRPC1307:Service \"{0}\" does not contain any usable ports
wsdlmodeler.warning.noOperationsInPort=JAXRPC1308:Port \"{0}\" does not contain any usable operations
wsdlmodeler.warning.ignoringNonSOAPPort=JAXRPC1309:ignoring port \"{0}\": not a SOAP port
wsdlmodeler.warning.ignoringNonSOAPPort.noAddress=JAXRPC1310:ignoring port \"{0}\": no SOAP address specified
wsdlmodeler.warning.ignoringSOAPBinding.nonHTTPTransport:ignoring SOAP port \"{0}\": unrecognized transport
wsdlmodeler.warning.ignoringOperation.notRequestResponse=JAXRPC1311:ignoring operation \"{0}\": not request-response
wsdlmodeler.warning.ignoringOperation.notEncoded=JAXRPC1312:ignoring RPC-style operation \"{0}\": parameters are not encoded
wsdlmodeler.warning.ignoringOperation.cannotHandleBodyPartsAttribute=JAXRPC1313:ignoring operation \"{0}\": cannot handle \"parts\" attribute of \"soap:body\" element
wsdlmodeler.warning.ignoringOperation.cannotHandleTypeMessagePart=JAXRPC1314:ignoring operation \"{0}\": message part does not refer to a schema element declaration
wsdlmodeler.warning.ignoringOperation.cannotHandleDocumentStyle=JAXRPC1315:ignoring operation \"{0}\": cannot handle document-style operations
wsdlmodeler.warning.ignoringFaults=JAXRPC1316:ignoring faults declared by operation \"{0}\"
wsdlmodeler.warning.ignoringFault.notEncoded=JAXRPC1317:ignoring literal fault \"{0}\" of binding operation \"{1}\"
wsdlmodeler.warning.ignoringHeader=JAXRPC1318:ignoring header \"{0}\" of binding operation \"{1}\"
wsdlmodeler.warning.ignoringHeader.notEncoded=JAXRPC1318:ignoring header \"{0}\" of binding operation \"{1}\": not SOAP-encoded
wsdlmodeler.warning.ignoringHeader.inconsistentDefinition=JAXRPC1319:ignoring header \"{0}\" of operation \"{1}\": its type is not constant across all operations in this port
#
wsdlmodeler.warning.ignoringOperation.notLiteral=JAXRPC1320:ignoring document-style operation \"{0}\": parameters are not literal
wsdlmodeler.warning.ignoringOperation.cannotHandleMoreThanOnePartInInputMessage=JAXRPC1321:ignoring operation \"{0}\": more than one part in input message
wsdlmodeler.warning.ignoringOperation.cannotHandleEmptyInputMessage=JAXRPC1322:ignoring operation \"{0}\": input message is empty
wsdlmodeler.warning.ignoringOperation.cannotHandleMoreThanOnePartInOutputMessage=JAXRPC1323:ignoring operation \"{0}\": more than one part in output message
wsdlmodeler.warning.ignoringOperation.cannotHandleEmptyOutputMessage=JAXRPC1324:ignoring operation \"{0}\": output message is empty
wsdlmodeler.warning.ignoringFault.documentOperation=JAXRPC1325:ignoring fault \"{0}\" of document-style operation \"{1}\"


#
#
processor.missing.model=model is missing


#
#
sender.nestedError=JAXRPC1402:sender error: {0}
sender.request.missingBodyInfo=JAXRPC1403:missing body information
sender.response.illegalValueOfMustUnderstandAttribute=JAXRPC1404:illegal value of \"mustUnderstand\" attribute: \"{0}\"
sender.response.headerNotUnderstood=JAXRPC1405:header not understood: \"{0}\"
sender.response.unexpectedBodyBlock=JAXRPC1406:unexpected body block: \"{0}\"
sender.response.unexpectedHeaderBlock=JAXRPC1407:unexpected header block: \"{0}\"
sender.response.unrecognizedOperation=JAXRPC1408:unrecognized operation (code: {0})
sender.response.unrecognizedFault=JAXRPC1409:unrecognized fault block
sender.response.fault=JAXRPC1410:received fault: \"{0}\" (code: \"{1}\" namespace: \"{2}\")
sender.stub.notInitialized=JAXRPC1411:stub was not initialized


#
#
soap.operation.unrecognized=JAXRPC1412:unrecognized operation: {0}
soap.operation.cannot.dispatch=JAXRPC1413:cannot dispatch ambiguous operation: {0}
soap.request.missing.soapaction.cannot.dispatch=JAXRPC1414:cannot dispatch operation, SOAPAction header is missing
soap.unexpectedHeaderBlock=JAXRPC1415:unexpected header block: \"{0}\" 
soap.protocol.emptyBody=JAXRPC1416:invalid SOAP envelope: body is empty
soap.protocol.missingBody=JAXRPC1417:invalid SOAP envelope: body is missing
soap.protocol.invalidEnvelopeContent=JAXRPC1418:invalid SOAP envelope content
soap.protocol.notAnEnvelope=JAXRPC1419:invalid SOAP envelope


#
#
streaming.ioException=JAXRPC1420:XML parsing error: {0}
streaming.parseException=JAXRPC1421:XML parsing error: {0}

xmlreader.illegalStateEncountered=JAXRPC1422:XML reader internal error: illegal state ({0})
xmlreader.unexpectedCharacterContent=JAXRPC1423:XML reader error: unexpected character content: \"{0}\"
xmlreader.ioException=JAXRPC1424:XML reader error: {0}
xmlreader.parseException=JAXRPC1425:XML parsing error: {0}
xmlreader.nestedError=JAXRPC1426:XML reader error: {0}

xmlwriter.noPrefixForURI=JAXRPC1427:XML writer error: no prefix for URI: \"{0}\"
xmlwriter.ioException=JAXRPC1428:XML writer error: {0}
xmlwriter.nestedError=JAXRPC1429:XML writer error: {0}
xmlreader.unexpectedState=JAXRPC1430:unexpected XML reader state. expected: {0} but found: {1}
xmlreader.unexpectedState.message=JAXRPC1431:unexpected XML reader state. expected: {0} but found: {1}. {2}

xmlrecorder.recording.ended=JAXRPC1432:no more recorded elements available

#
#
holder.valuefield.not.found=JAXRPC5005:Could not find the field in the Holder that contains the Holder's value: {0}


#
# WSCompiler
#


wscompile.usage=Usage: {0} [options] configuration_file\n\n\
\where [options] include:\n\
\  -classpath          specify where to find input class files\n\
\  -cp                 same as -classpath \n\
\  -d             specify where to place generated output files\n\
\  -define                   define a service\n\
\  -f:             enable the given features (see below)\n\
\  -features:      same as -f:\n\
\  -g                        generate debugging info\n\
\  -gen                      same as -gen:client\n\
\  -gen:client               generate client artifacts (stubs, etc.)\n\
\  -gen:server               generate server artifacts (ties, etc.)\n\
\  -gen:both                 generate both client and server artifacts\n\
\  -httpproxy::  specify a HTTP proxy server (port defaults to 8080)\n\
\  -import                   generate interfaces and value types only\n\
\  -keep                     keep generated files\n\
\  -model              write the internal model to the given file\n\
\  -nd            specify where to place non-class generated files\n\
\  -O                        optimize generated code\n\
\  -s             specify where to place generated source files\n\
\  -verbose                  output messages about what the compiler is doing\n\
\  -version                  print version information\n\
\ \n\
\Exactly one of the -import, -define, -gen options must be specified.\n\
\ \n\
\The -f option requires a comma-separated list of features.\n\
\ \n\
\Supported features (-f):\n\
\  datahandleronly           always map attachments to the DataHandler type\n\
\  explicitcontext           turn on explicit service context mapping\n\
\  infix=              specify an infix to use for generated serializers\n\
\  nodatabinding             turn off data binding for literal encoding\n\
\  noencodedtypes            turn off encoding type information\n\
\  nomultirefs               turn off support for multiple references\n\
\  novalidation              turn off full validation of imported WSDL documents\n\
\  searchschema              search schema aggressively for subtypes\n\
\  serializeinterfaces       turn on direct serialization of interface types\n\
\ \n\
\Internal options (unsupported):\n\
\  -Xdebugmodel:       write a readable version of the model to a file\n\
\  -Xprintstacktrace         print exception stack traces\n\
\ \n\
\Examples:\n\
\  wscompile -gen -classpath lib/foo.jar;lib/bar.jar -d generated config.xml\n\
\  wscompile -define -f:nodatabinding,novalidation config.xml\n\
\  wscompile -import -f:explicitcontext config.xml\n\
\   

#
# Generic Messages
#
wscompile.version={0} ({1}, build {2})
wscompile.invalidOption={0} is an invalid option or argument
wscompile.multipleConfigurationFiles=only one configuration file can be specified: {0}
wscompile.fileNotFound=error: file not found: {0}
wscompile.error=error: {0}
wscompile.warning=warning: {0}
wscompile.info=info: {0}
wscompile.missingConfigurationFile=missing configuration file
wscompile.duplicateOption=duplicate option: {0}
wscompile.noSuchDirectory=directory not found: {0}
wscompile.missingOptionArgument=option \"{0}\" requires an argument
wscompile.invalidModel=cannot create model file: {0}
wscompile.invalidPath=cannot create file: {0}
wscompile.unknownFeature=unknown feature: {0}
wscompile.unknownOption=unknown option: {0}
wscompile.invalidFeatureSyntax=invalid feature syntax: {0}
wscompile.compilationFailed=compilation failed, errors should have been reported
wscompile.noModeSpecified=no mode was specified, please use one of -import/-define/-gen
wscompile.tooManyModesSpecified=too many modes were specified, please use only one of -import/-define/-gen
wscompile.importRequiresWsdlConfig=-import requires a WSDL-based configuration file
wscompile.defineRequiresServiceConfig=-define requires a service-based configuration file


#
#

wsdeploy.usage=Usage: {0}  \n\n\
\where  include:\n\
\  -classpath          specify an optional classpath\n\
\  -keep                     keep temporary files\n\
\  -o       specify where to place the generated war file\n\
\  -tmpdir        specify the temporary directory to use\n\
\  -verbose                  output messages about what the compiler is doing\n\
\  -version                  print version information\n\
\ \n\
\ The -o option is required.\n\
\ \n\
\Examples:\n\
\  wsdeploy -o target.war myapp.war\n\
\   

#
# Generic Messages
#
wsdeploy.version={0} ({1}, build {2})
wsdeploy.invalidOption={0} is an invalid option or argument
wsdeploy.multipleWarFiles=only one input war file can be specified: {0}
wsdeploy.fileNotFound=file not found: {0}
wsdeploy.error=error: {0}
wsdeploy.warning=warning: {0}
wsdeploy.info=info: {0}
wsdeploy.missingWarFile=missing input war file
wsdeploy.missingDestinationWarFile=missing output war file, please use the -o option
wsdeploy.sourceDestinationConflict=source and destination war files conflict
wsdeploy.duplicateOption=duplicate option: {0}
wsdeploy.noSuchDirectory=directory not found: {0}
wsdeploy.missingOptionArgument=option \"{0}\" requires an argument
wsdeploy.invalidOutputFile=cannot create output war file: {0}
wsdeploy.noSuchDirectory=directory not found: {0}
wsdeploy.info.createdTempDir=created temporary directory: {0}
wsdeploy.info.removedTempDir=removed temporary directory: {0}
wsdeploy.info.processingEndpoint=processing endpoint: {0}
wsdeploy.info.createdWarFile=created output war file: {0}
wsdeploy.warning.endpointModelUnsupported=endpoints with models are currently unsupported: {0}


#
#
parsing.wsdlNotDefaultNamespace=default namespace must be \"{0}\"
parsing.onlyOneOfElementOrTypeRequired=only one of the \"element\" or \"type\" attributes is allowed in part \"{0}\"
parsing.elementOrTypeRequired=either the \"element\" or the \"type\" attribute is required in part \"{0}\"
parsing.invalidElement=invalid element: \"{0}\" (in namespace \"{1}\")
parsing.invalidAttributeValue=invalid value \"{1}\" for attribute \"{0}\"
parsing.invalidExtensionElement=invalid extension element: \"{0}\" (in namespace \"{1}\")
parsing.invalidWsdlElement=invalid WSDL element: \"{0}\"
parsing.requiredExtensibilityElement=unknown required extensibility element \"{0}\" (in namespace \"{1}\")
parsing.tooManyElements=too many \"{0}\" elements under \"{1}\" element \"{2}\"
parsing.invalidOperationStyle=operation \"{0}\" has an invalid style
parsing.onlyOneTypesAllowed=only one "types" element allowed in "{0}"
parsing.onlyOneDocumentationAllowed=only one "documentation" element allowed in "{0}"
parsing.incorrectRootElement=expected root element \"{2}\" (in namespace \"{3}\"), found element \"{0}\" (in namespace \"{1}\")
parsing.unknownImportedDocumentType=imported document is of unknown type: {0}
parsing.unknownNamespacePrefix=undeclared namespace prefix: \"{0}\"
parsing.invalidURI=invalid URI: {0}
parsing.ioExceptionWithSystemId=failed to parse document at \"{0}\": {1}
parsing.ioException=parsing failed: {0}
parsing.saxExceptionWithSystemId=failed to parse document at \"{0}\": {1}
parsing.saxException=parsing failed: {0}
parsing.parserConfigException=parsing failed: {0}
parsing.factoryConfigException=parsing failed: {0}

#
parsing.missingRequiredAttribute=missing required attribute \"{1}\" of element \"{0}\"
parsing.invalidTag=expected element \"{1}\", found \"{0}\"
parsing.invalidTagNS=expected element \"{2}\" (in namespace \"{3}\"), found element \"{0}\" (in namespace \"{1}\")
parsing.nonWhitespaceTextFound=found unexpected non whitespace text: \"{0}\"
parsing.elementExpected=unexpected non-element found
#
entity.duplicate=duplicate entity: \"{0}\"
entity.duplicateWithType=duplicate \"{0}\" entity: \"{1}\"
entity.notFoundByQName=invalid entity name: \"{0}\" (in namespace: \"{1}\")
entity.notFoundByID=invalid entity id: \"{0}\"
#
validation.missingRequiredAttribute=missing required attribute \"{0}\" of element \"{1}\"
validation.missingRequiredProperty=missing required property \"{0}\" of element \"{1}\"
validation.missingRequiredSubEntity=missing required sub-entity \"{0}\" of element \"{1}\"
validation.invalidElement=invalid element: \"{0}\"
validation.duplicatedElement=duplicated element: \"{0}\"
validation.invalidSubEntity=invalid sub-element \"{0}\" of element \"{1}\"
validation.invalidAttribute=invalid attribute \"{0}\" of element \"{1}\"
validation.invalidAttributeValue=invalid value \"{1}\" for attribute \"{0}\"
validation.invalidRange=invalid range found (min: {0}, max: {1})
validation.exclusiveAttributes=exclusive attributes: \"{0}\", \"{1}\"
validation.incorrectTargetNamespace=target namespace is incorrect (expected: {1}, found: {0})
validation.unsupportedSchemaFeature=unsupported XML Schema feature: \"{0}\"
validation.shouldNotHappen=internal error ("{0}")
validation.invalidToken=invalid token \"{0}\"
validation.notSimpleType=not a simple type: \"{0}\"
validation.ambiguousName=ambiguous operation name: \"{0}\"
validation.invalidPrefix=undeclared namespace prefix: \"{0}\"


#
#
message.name=wsdlp
message.header=WSDL Parser for JAX-RPC
message.version=EA1
message.usage=usage: wsdlp [options] wsdl_file\n\
\  where options are:\n\
\      -echo                  emit the parsed document\n\
\      -help                  print usage information\n\
\      -schema                parse a schema file\n\
\      -validate              perform full validation\n\
\      -verbose -v            print detailed information\n\
\      -version               print version information\n\
\ 
message.ignoring=warning: ignoring \"{0}\" (ns: \"{1}\")
message.processed=info: processed \"{0}\"  (ns: \"{1}\")
#
error.invalidOption=error: invalid option: {0}
error.multipleFilenames=error: multiple filenames specified
error.missingFilename=error: missing filename
error.parsing=error: parsing failed: {0}
error.validation=error: validation failed: {0}
error.io=error: I/O exception: {0}
error.generic=error: unexpected: {0}


#
#

xrpcc.usage=Usage: {0}  \n\n\
\where  includes:\n\
\  -both                     generate both client and server artifacts\n\
\  -classpath          specify where to find input class files\n\
\  -client                   generate client artifacts (stubs, etc)\n\
\  -d             specify where to place generated output files\n\
\  -s             specify where to place generated source files\n\
\  -g                        generate debugging info\n\
\  -keep                     do not delete intermediate generated source files\n\
\  -keepgenerated            (same as "-keep")\n\
\  -nowarn                   generate no warnings\n\
\  -server                   generate server artifacts (ties, WSDL, etc)\n\
\  -verbose                  output messages about what the compiler is doing\n\
\  -version                  print version information\n\
\ \n\
\or the following internal options (unsupported):\n\
\  -Xactions:          specify a different set of processor actions\n\
\  -Xdatahandleronly         always map attachments to the DataHandler type\n\
\  -Xexplicitcontext         turn on explicit service context mapping\n\
\  -Xhttpproxy:: specify a HTTP proxy server (port defaults to 8080)\n\
\  -Ximport                  only generate remote interfaces and value types\n\
\  -Xmodel                   dump the internal model to stdout\n\
\  -Xmodel:            dump the internal model to the specified file\n\
\  -Xnocompile               generate source files but do not compile them\n\
\  -Xnodatabinding           turn off data binding for literal encoding\n\
\  -Xnoencodedtypes          turn off encoding type information\n\
\  -Xnomultirefs             turn off support for multiple references\n\
\  -Xnovalidation            turn off full validation of imported WSDL documents\n\
\  -Xprintstacktrace         print the stack trace for an exception\n\
\  -Xserializeinterfaces     this will cause subclasses of an interface to be\n\
\                            serialized as the interface specified in the\n\
\                            signature if the subclass was not specified as an\n\
\                            additional class\n\
\  -Xsearchschema            search schema aggressively for subtypes\n\
\  -Xxmodel:           write the internal model in XML format\n

#
# Generic Messages
#

xrpcc.error.generic=error: unexpected: {0}
xrpcc.error=error: {0}
xrpcc.warning=warning: {0}
xrpcc.info=info: {0}
xrpcc.only.one.configuration.file=error: only one configuration file can be specified: {0}
xrpcc.configuration.file.not.found=error: a configuration file must be specified.
xrpcc.cant.read=can''t read: {0}
xrpcc.option.unsupported=error: the {0} option is no longer supported.
xrpcc.option.already.seen=error: the {0} option may be specified no more than once.
xrpcc.option.requires.argument=error: the {0} option requires an argument.
xrpcc.option.incompatible=error: the {0} option is incompatible with previous ones.
xrpcc.option.deprecated=error: the {0} option has been deprecated.
xrpcc.option.mustSpecifyClientOrServer=error: must specify one of \"-client\", \"-server\" or \"-both\"
xrpcc.option.import.requiresWSDL=error: with the \"-Ximport\" option, the configuration file must specify a WSDL document.
xrpcc.no.such.directory=error: the {0} directory does not exist.
xrpcc.no.such.file=error: the {0} file does not exist.
xrpcc.no.such.option=error: {0} is an invalid option or argument.
xrpcc.version={0} ({1}, build {2})
xrpcc.wrote=[wrote {0}]
xrpcc.errors={0} errors
xrpcc.1error=1 error
xrpcc.warnings={0} warnings
xrpcc.1warning=1 warning
xrpcc.done_in=[done in {0} ms]
xrpcc.no.memory=\
	error: the compiler has run out of memory.  consider using the "-J-mx" command line option to increase the maximum heap size.
xrpcc.stack.overflow=\
	error: the compiler has run out of stack space.  consider using the "-J-oss" command line option to increase the memory allocated for the Java stack.
xrpcc.class.not.found=\
	error: class {0} not found.
xrpcc.missing.property=error: missing property generator.class.{0}
xrpcc.cannot.instantiate=error: cannot instantiate class {0}
xrpcc.cannot.use.both=error: cannot use both {0} and {1}
xrpcc.resource.not.found=error: {0} not found.
xrpcc.no.output.dir=\
	error: cannot find suitable output directory for {0}. use the -d option to specify a root directory.
xrpcc.cannot.create.dir=\
	error: cannot create output directory {0}.
xrpcc.invalid.processoraction.class=error: invalid ProcessorAction class \"{0}\"
xrpcc.replacing.action.class=xrpcc: replacing ProcessorAction class {0} with {1}.
Address:	{0}
WSDL:	{0}?WSDL
Port QName:	{1}
Remote interface:	{2}
Implementation class:	{3}
Model:	{0}?model