_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q179300
|
FlowItemClient.sendFormToFlow
|
test
|
public FluidItem sendFormToFlow(
Form formToSendToFlowParam,
String flowParam) {
FluidItem itemToSend = new FluidItem();
itemToSend.setForm(formToSendToFlowParam);
itemToSend.setFlow(flowParam);
if (this.serviceTicket != null) {
itemToSend.setServiceTicket(this.serviceTicket);
}
try {
return new FluidItem(this.postJson(
itemToSend, WS.Path.FlowItem.Version1.sendFlowItemToFlow()));
} catch (JSONException e) {
throw new FluidClientException(e.getMessage(), e,
FluidClientException.ErrorCode.JSON_PARSING);
}
}
|
java
|
{
"resource": ""
}
|
q179301
|
WebSocketClient.onClose
|
test
|
@OnClose
public void onClose(Session userSessionParam, CloseReason reasonParam) {
this.userSession = null;
if (this.messageHandlers != null) {
this.messageHandlers.values().forEach(handle ->{
handle.connectionClosed();
});
}
}
|
java
|
{
"resource": ""
}
|
q179302
|
WebSocketClient.onMessage
|
test
|
@OnMessage
public void onMessage(String messageParam) {
boolean handlerFoundForMsg = false;
for(IMessageResponseHandler handler : new ArrayList<>(this.messageHandlers.values())) {
Object qualifyObj = handler.doesHandlerQualifyForProcessing(messageParam);
if(qualifyObj instanceof Error) {
handler.handleMessage(qualifyObj);
} else if(qualifyObj instanceof JSONObject) {
handler.handleMessage(qualifyObj);
handlerFoundForMsg = true;
break;
}
}
if(!handlerFoundForMsg) {
throw new FluidClientException(
"No handler found for message;\n"+messageParam,
FluidClientException.ErrorCode.IO_ERROR);
}
}
|
java
|
{
"resource": ""
}
|
q179303
|
WebSocketClient.sendMessage
|
test
|
public void sendMessage(ABaseFluidJSONObject aBaseFluidJSONObjectParam) {
if(aBaseFluidJSONObjectParam == null) {
throw new FluidClientException(
"No JSON Object to send.",
FluidClientException.ErrorCode.IO_ERROR);
} else {
this.sendMessage(aBaseFluidJSONObjectParam.toJsonObject().toString());
}
}
|
java
|
{
"resource": ""
}
|
q179304
|
WebSocketClient.sendMessage
|
test
|
public void sendMessage(String messageToSendParam) {
if(this.userSession == null) {
throw new FluidClientException(
"User Session is not set. Check if connection is open.",
FluidClientException.ErrorCode.IO_ERROR);
}
RemoteEndpoint.Async asyncRemote = null;
if((asyncRemote = this.userSession.getAsyncRemote()) == null) {
throw new FluidClientException(
"Remote Session is not set. Check if connection is open.",
FluidClientException.ErrorCode.IO_ERROR);
}
asyncRemote.sendText(messageToSendParam);
}
|
java
|
{
"resource": ""
}
|
q179305
|
WebSocketClient.closeSession
|
test
|
public void closeSession() {
if(this.userSession == null) {
return;
}
try {
this.userSession.close();
} catch (IOException e) {
throw new FluidClientException(
"Unable to close session. "+e.getMessage(),
e,FluidClientException.ErrorCode.IO_ERROR);
}
}
|
java
|
{
"resource": ""
}
|
q179306
|
SQLUtilWebSocketExecuteNativeSQLClient.executeNativeSQLSynchronized
|
test
|
public List<SQLResultSet> executeNativeSQLSynchronized(
NativeSQLQuery nativeSQLQueryParam) {
if(nativeSQLQueryParam == null)
{
return null;
}
if(nativeSQLQueryParam.getDatasourceName() == null ||
nativeSQLQueryParam.getDatasourceName().isEmpty())
{
throw new FluidClientException(
"No data-source name provided. Not allowed.",
FluidClientException.ErrorCode.FIELD_VALIDATE);
}
//No query to execute...
if((nativeSQLQueryParam.getQuery() == null ||
nativeSQLQueryParam.getQuery().isEmpty()) &&
(nativeSQLQueryParam.getStoredProcedure() == null ||
nativeSQLQueryParam.getStoredProcedure().isEmpty()))
{
return null;
}
//Validate the echo...
this.setEchoIfNotSet(nativeSQLQueryParam);
//Start a new request...
String uniqueReqId = this.initNewRequest();
//Send the actual message...
this.sendMessage(nativeSQLQueryParam, uniqueReqId);
try {
List<SQLResultSet> returnValue =
this.getHandler(uniqueReqId).getCF().get(
this.getTimeoutInMillis(),TimeUnit.MILLISECONDS);
//Connection was closed.. this is a problem....
if(this.getHandler(uniqueReqId).isConnectionClosed())
{
throw new FluidClientException(
"SQLUtil-WebSocket-ExecuteNativeSQL: " +
"The connection was closed by the server prior to the response received.",
FluidClientException.ErrorCode.IO_ERROR);
}
return returnValue;
}
//Interrupted...
catch (InterruptedException exceptParam) {
throw new FluidClientException(
"SQLUtil-WebSocket-ExecuteNativeSQL: " +
exceptParam.getMessage(),
exceptParam,
FluidClientException.ErrorCode.STATEMENT_EXECUTION_ERROR);
}
//Error on the web-socket...
catch (ExecutionException executeProblem) {
Throwable cause = executeProblem.getCause();
//Fluid client exception...
if(cause instanceof FluidClientException)
{
throw (FluidClientException)cause;
}
else
{
throw new FluidClientException(
"SQLUtil-WebSocket-ExecuteNativeSQL: " +
cause.getMessage(), cause,
FluidClientException.ErrorCode.STATEMENT_EXECUTION_ERROR);
}
}
//Timeout...
catch (TimeoutException eParam) {
throw new FluidClientException(
"SQLUtil-WebSocket-ExecuteNativeSQL: Timeout while waiting for all return data. There were '"
+this.getHandler(uniqueReqId).getReturnValue().size()
+"' items after a Timeout of "+(
TimeUnit.MILLISECONDS.toSeconds(this.getTimeoutInMillis()))+" seconds."
,FluidClientException.ErrorCode.IO_ERROR);
}
finally {
this.removeHandler(uniqueReqId);
}
}
|
java
|
{
"resource": ""
}
|
q179307
|
FluidLicenseClient.requestLicense
|
test
|
public String requestLicense(LicenseRequest licenseRequestParam) {
if(licenseRequestParam != null &&
this.serviceTicket != null)
{
licenseRequestParam.setServiceTicket(this.serviceTicket);
}
return this.executeTxtReceiveTxt(
HttpMethod.POST,
null,
false,
(licenseRequestParam == null) ? null :
licenseRequestParam.toJsonObject().toString(),
ContentType.APPLICATION_JSON,
Version1.licenseRequest());
}
|
java
|
{
"resource": ""
}
|
q179308
|
FluidLicenseClient.applyLicense
|
test
|
public LicenseRequest applyLicense(String licenseToApplyParam)
{
LicenseRequest liceReq = new LicenseRequest();
liceReq.setLicenseCipherText(licenseToApplyParam);
if(this.serviceTicket != null)
{
liceReq.setServiceTicket(this.serviceTicket);
}
return new LicenseRequest(this.postJson(
liceReq, Version1.licenseApply()));
}
|
java
|
{
"resource": ""
}
|
q179309
|
RouteFieldClient.createFieldTextPlain
|
test
|
public Field createFieldTextPlain(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.Text);
routeFieldParam.setTypeMetaData(FieldMetaData.Text.PLAIN);
}
return new Field(this.putJson(
routeFieldParam, Version1.routeFieldCreate()));
}
|
java
|
{
"resource": ""
}
|
q179310
|
RouteFieldClient.createFieldParagraphTextPlain
|
test
|
public Field createFieldParagraphTextPlain(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.ParagraphText);
routeFieldParam.setTypeMetaData(FieldMetaData.ParagraphText.PLAIN);
}
return new Field(this.putJson(
routeFieldParam, Version1.routeFieldCreate()));
}
|
java
|
{
"resource": ""
}
|
q179311
|
RouteFieldClient.createFieldParagraphTextHTML
|
test
|
public Field createFieldParagraphTextHTML(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.ParagraphText);
routeFieldParam.setTypeMetaData(FieldMetaData.ParagraphText.HTML);
}
return new Field(this.putJson(
routeFieldParam, Version1.routeFieldCreate()));
}
|
java
|
{
"resource": ""
}
|
q179312
|
RouteFieldClient.createFieldMultiChoiceSelectMany
|
test
|
public Field createFieldMultiChoiceSelectMany(
Field routeFieldParam,
List<String> multiChoiceValuesParam
) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(multiChoiceValuesParam == null ||
multiChoiceValuesParam.isEmpty()) {
throw new FluidClientException(
"No Multi-choice values provided.",
FluidClientException.ErrorCode.FIELD_VALIDATE);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.MultipleChoice);
routeFieldParam.setTypeMetaData(FieldMetaData.MultiChoice.SELECT_MANY);
routeFieldParam.setFieldValue(new MultiChoice(multiChoiceValuesParam));
}
return new Field(this.putJson(
routeFieldParam, Version1.routeFieldCreate()));
}
|
java
|
{
"resource": ""
}
|
q179313
|
RouteFieldClient.createFieldDateTimeDate
|
test
|
public Field createFieldDateTimeDate(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.DateTime);
routeFieldParam.setTypeMetaData(FieldMetaData.DateTime.DATE);
}
return new Field(this.putJson(
routeFieldParam, Version1.routeFieldCreate()));
}
|
java
|
{
"resource": ""
}
|
q179314
|
RouteFieldClient.updateFieldTextPlain
|
test
|
public Field updateFieldTextPlain(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.Text);
routeFieldParam.setTypeMetaData(FieldMetaData.Text.PLAIN);
}
return new Field(this.postJson(
routeFieldParam, Version1.routeFieldUpdate()));
}
|
java
|
{
"resource": ""
}
|
q179315
|
RouteFieldClient.updateFieldParagraphTextHTML
|
test
|
public Field updateFieldParagraphTextHTML(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.ParagraphText);
routeFieldParam.setTypeMetaData(FieldMetaData.ParagraphText.HTML);
}
return new Field(this.postJson(
routeFieldParam, Version1.routeFieldUpdate()));
}
|
java
|
{
"resource": ""
}
|
q179316
|
RouteFieldClient.updateFieldDateTimeDateAndTime
|
test
|
public Field updateFieldDateTimeDateAndTime(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.DateTime);
routeFieldParam.setTypeMetaData(FieldMetaData.DateTime.DATE_AND_TIME);
}
return new Field(this.postJson(
routeFieldParam, Version1.routeFieldUpdate()));
}
|
java
|
{
"resource": ""
}
|
q179317
|
RouteFieldClient.updateFieldDecimalPlain
|
test
|
public Field updateFieldDecimalPlain(Field routeFieldParam) {
if(routeFieldParam != null && this.serviceTicket != null) {
routeFieldParam.setServiceTicket(this.serviceTicket);
}
if(routeFieldParam != null) {
routeFieldParam.setTypeAsEnum(Field.Type.Decimal);
routeFieldParam.setTypeMetaData(FieldMetaData.Decimal.PLAIN);
}
return new Field(this.postJson(
routeFieldParam, Version1.routeFieldUpdate()));
}
|
java
|
{
"resource": ""
}
|
q179318
|
RouteFieldClient.updateFieldValue
|
test
|
public Field updateFieldValue(Field routeFieldValueParam) {
if(routeFieldValueParam != null && this.serviceTicket != null) {
routeFieldValueParam.setServiceTicket(this.serviceTicket);
}
return new Field(this.postJson(
routeFieldValueParam, Version1.routeFieldUpdateValue()));
}
|
java
|
{
"resource": ""
}
|
q179319
|
RouteFieldClient.createFieldValue
|
test
|
public Field createFieldValue(
Field routeFieldValueToCreateParam,
FluidItem fluidItemParam) {
if(routeFieldValueToCreateParam != null && this.serviceTicket != null) {
routeFieldValueToCreateParam.setServiceTicket(this.serviceTicket);
}
Long fluidItmId = (fluidItemParam == null) ? null : fluidItemParam.getId();
return new Field(this.putJson(
routeFieldValueToCreateParam,
Version1.routeFieldCreateValue(fluidItmId)));
}
|
java
|
{
"resource": ""
}
|
q179320
|
ConfigurationClient.getConfigurationByKey
|
test
|
public Configuration getConfigurationByKey(String configurationKeyParam)
{
Configuration configuration = new Configuration();
configuration.setKey(configurationKeyParam);
if(this.serviceTicket != null)
{
configuration.setServiceTicket(this.serviceTicket);
}
return new Configuration(this.postJson(
configuration, WS.Path.Configuration.Version1.getByKey()));
}
|
java
|
{
"resource": ""
}
|
q179321
|
ConfigurationClient.getAllConfigurations
|
test
|
public ConfigurationListing getAllConfigurations()
{
Configuration configuration = new Configuration();
if(this.serviceTicket != null)
{
configuration.setServiceTicket(this.serviceTicket);
}
return new ConfigurationListing(this.postJson(
configuration, WS.Path.Configuration.Version1.getAllConfigurations()));
}
|
java
|
{
"resource": ""
}
|
q179322
|
AttachmentClient.createAttachment
|
test
|
public Attachment createAttachment(Attachment attachmentParam)
{
if(attachmentParam != null && this.serviceTicket != null)
{
attachmentParam.setServiceTicket(this.serviceTicket);
}
return new Attachment(this.putJson(
attachmentParam, WS.Path.Attachment.Version1.attachmentCreate()));
}
|
java
|
{
"resource": ""
}
|
q179323
|
AttachmentClient.getAttachmentById
|
test
|
public Attachment getAttachmentById(
Long attachmentIdParam,
boolean includeAttachmentDataParam)
{
Attachment attachment = new Attachment(attachmentIdParam);
if(this.serviceTicket != null)
{
attachment.setServiceTicket(this.serviceTicket);
}
return new Attachment(this.postJson(
attachment, WS.Path.Attachment.Version1.getById(
includeAttachmentDataParam)));
}
|
java
|
{
"resource": ""
}
|
q179324
|
AttachmentClient.deleteAttachment
|
test
|
public Attachment deleteAttachment(Attachment attachmentParam)
{
if(attachmentParam != null && this.serviceTicket != null)
{
attachmentParam.setServiceTicket(this.serviceTicket);
}
return new Attachment(this.postJson(
attachmentParam, WS.Path.Attachment.Version1.attachmentDelete()));
}
|
java
|
{
"resource": ""
}
|
q179325
|
AttachmentClient.forceDeleteAttachment
|
test
|
public Attachment forceDeleteAttachment(Attachment attachmentParam)
{
if(attachmentParam != null && this.serviceTicket != null)
{
attachmentParam.setServiceTicket(this.serviceTicket);
}
return new Attachment(this.postJson(
attachmentParam,
WS.Path.Attachment.Version1.attachmentDelete(true)));
}
|
java
|
{
"resource": ""
}
|
q179326
|
XsdParserJar.parseJarFile
|
test
|
private void parseJarFile(InputStream inputStream) {
//https://www.mkyong.com/java/how-to-read-xml-file-in-java-dom-parser/
try {
Node schemaNode = getSchemaNode(inputStream);
if (isXsdSchema(schemaNode)){
XsdSchema.parse(this, schemaNode);
} else {
throw new ParsingException("The top level element of a XSD file should be the xsd:schema node.");
}
} catch (SAXException | IOException | ParserConfigurationException e) {
Logger.getAnonymousLogger().log(Level.SEVERE, "Exception while parsing.", e);
}
}
|
java
|
{
"resource": ""
}
|
q179327
|
XsdParserJar.setClassLoader
|
test
|
private void setClassLoader(String jarPath) {
if (!jarPath.endsWith(".jar")){
throw new ParsingException("The jarPath received doesn't represent a jar file.");
}
ClassLoader originalCl = Thread.currentThread().getContextClassLoader();
URL url = originalCl.getResource(jarPath);
if (url == null){
try {
url = new URL("file:/" + jarPath);
} catch (MalformedURLException e) {
throw new ParsingException("Invalid jar name.");
}
}
// Create class loader using given codebase
// Use prevCl as parent to maintain current visibility
ClassLoader urlCl = URLClassLoader.newInstance(new URL[]{url}, originalCl);
Thread.currentThread().setContextClassLoader(urlCl);
classLoader = urlCl;
}
|
java
|
{
"resource": ""
}
|
q179328
|
XsdGroup.rule2
|
test
|
private void rule2() {
if (!(parent instanceof XsdSchema) && name != null){
throw new ParsingException(XSD_TAG + " element: The " + NAME_TAG + " should only be used when the parent of the " + XSD_TAG + " is the " + XsdSchema.XSD_TAG + " element." );
}
}
|
java
|
{
"resource": ""
}
|
q179329
|
XsdGroup.rule3
|
test
|
private void rule3() {
if (parent instanceof XsdSchema && name == null){
throw new ParsingException(XSD_TAG + " element: The " + NAME_TAG + " should is required the parent of the " + XSD_TAG + " is the " + XsdSchema.XSD_TAG + " element." );
}
}
|
java
|
{
"resource": ""
}
|
q179330
|
XsdAttribute.rule3
|
test
|
private void rule3() {
if (attributesMap.containsKey(REF_TAG) && (simpleType != null || form != null || type != null)){
throw new ParsingException(XSD_TAG + " element: If " + REF_TAG + " attribute is present, simpleType element, form attribute and type attribute cannot be present at the same time.");
}
}
|
java
|
{
"resource": ""
}
|
q179331
|
XsdParser.getSchemaNode
|
test
|
private Node getSchemaNode(String filePath) throws IOException, SAXException, ParserConfigurationException {
Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(filePath);
doc.getDocumentElement().normalize();
return doc.getFirstChild();
}
|
java
|
{
"resource": ""
}
|
q179332
|
XsdElement.rule7
|
test
|
private void rule7() {
if (parent instanceof XsdSchema && attributesMap.containsKey(FORM_TAG)){
throw new ParsingException(XSD_TAG + " element: The " + FORM_TAG + " attribute can only be present when the parent of the " + xsdElementIsXsdSchema);
}
}
|
java
|
{
"resource": ""
}
|
q179333
|
XsdElement.rule3
|
test
|
private void rule3() {
if (parent instanceof XsdSchema && attributesMap.containsKey(REF_TAG)){
throw new ParsingException(XSD_TAG + " element: The " + REF_TAG + " attribute cannot be present when the parent of the " + xsdElementIsXsdSchema);
}
}
|
java
|
{
"resource": ""
}
|
q179334
|
ConvertTypeOfObject.convert
|
test
|
@Override public T convert(final Object value) {
if (value == null) {
return null;
} else if (isIterable() && Iterable.class.isAssignableFrom(value.getClass())) {
return convertIterable(value);
} else if (reflectedKlass.assignableFromObject(value)) {
return (T) value;
} else if (reflectedKlass.canBeUnboxed(value.getClass())) {
return (T) value;
} else if (reflectedKlass.canBeBoxed(value.getClass())) {
return (T) value;
}
FluentClass<?> klassToCreate;
if (reflectedKlass.isPrimitive()) {
klassToCreate = reflectedKlass.boxedType();
} else {
klassToCreate = reflectedKlass;
}
return (T) convertValueTo(value, klassToCreate);
}
|
java
|
{
"resource": ""
}
|
q179335
|
CliFactory.createCli
|
test
|
public static <O> Cli<O> createCli(final Class<O> klass) throws InvalidOptionSpecificationException
{
return new CliInterfaceImpl<O>(klass);
}
|
java
|
{
"resource": ""
}
|
q179336
|
CliFactory.createCliUsingInstance
|
test
|
public static <O> Cli<O> createCliUsingInstance(final O options) throws InvalidOptionSpecificationException
{
return new CliInstanceImpl<O>(options);
}
|
java
|
{
"resource": ""
}
|
q179337
|
CliFactory.parseArguments
|
test
|
public static <O> O parseArguments(final Class<O> klass, final String... arguments)
throws ArgumentValidationException, InvalidOptionSpecificationException
{
return createCli(klass).parseArguments(arguments);
}
|
java
|
{
"resource": ""
}
|
q179338
|
CliFactory.parseArgumentsUsingInstance
|
test
|
public static <O> O parseArgumentsUsingInstance(final O options, final String... arguments)
throws ArgumentValidationException, InvalidOptionSpecificationException
{
return createCliUsingInstance(options).parseArguments(arguments);
}
|
java
|
{
"resource": ""
}
|
q179339
|
DiscoveryApi.urlBuilder
|
test
|
Builder urlBuilder(String path) {
Builder builder =
baseUrlBuilder().addPathSegment(configuration.getApiPackage())
.addPathSegment(configuration.getApiVersion()).addPathSegment(path);
if (configuration.getPathModifier() != DiscoveryApiConfiguration.PathModifier.NONE) {
builder.addPathSegment(configuration.getPathModifier().getModifier());
}
return builder;
}
|
java
|
{
"resource": ""
}
|
q179340
|
HeaderGridView.removeFooterView
|
test
|
public boolean removeFooterView(View v) {
if (mFooterViewInfos.size() > 0) {
boolean result = false;
if (mAdapter != null && ((FooterViewGridAdapter) mAdapter).removeFooter(v)) {
notifiyChanged();
result = true;
}
removeFixedViewInfo(v, mFooterViewInfos);
return result;
}
return false;
}
|
java
|
{
"resource": ""
}
|
q179341
|
Line.getValue
|
test
|
public double getValue(double p) {
if (module == null) {
throw new NoModuleException();
}
double x = (x1 - x0) * p + x0;
double y = (y1 - y0) * p + y0;
double z = (z1 - z0) * p + z0;
double value = module.getValue(x, y, z);
if (attenuate) {
return p * (1.0 - p) * 4 * value;
} else {
return value;
}
}
|
java
|
{
"resource": ""
}
|
q179342
|
Noise.gradientNoise3D
|
test
|
public static double gradientNoise3D(double fx, double fy, double fz, int ix, int iy, int iz, int seed) {
// Randomly generate a gradient vector given the integer coordinates of the
// input value. This implementation generates a random number and uses it
// as an index into a normalized-vector lookup table.
int vectorIndex = (X_NOISE_GEN * ix + Y_NOISE_GEN * iy + Z_NOISE_GEN * iz + SEED_NOISE_GEN * seed);
vectorIndex ^= (vectorIndex >> SHIFT_NOISE_GEN);
vectorIndex &= 0xff;
double xvGradient = Utils.RANDOM_VECTORS[(vectorIndex << 2)];
double yvGradient = Utils.RANDOM_VECTORS[(vectorIndex << 2) + 1];
double zvGradient = Utils.RANDOM_VECTORS[(vectorIndex << 2) + 2];
// Set up us another vector equal to the distance between the two vectors
// passed to this function.
double xvPoint = (fx - ix);
double yvPoint = (fy - iy);
double zvPoint = (fz - iz);
// Now compute the dot product of the gradient vector with the distance
// vector. The resulting value is gradient noise. Apply a scaling and
// offset value so that this noise value ranges from 0 to 1.
return ((xvGradient * xvPoint) + (yvGradient * yvPoint) + (zvGradient * zvPoint)) + 0.5;
}
|
java
|
{
"resource": ""
}
|
q179343
|
Noise.intValueNoise3D
|
test
|
public static int intValueNoise3D(int x, int y, int z, int seed) {
// All constants are primes and must remain prime in order for this noise
// function to work correctly.
int n = (X_NOISE_GEN * x + Y_NOISE_GEN * y + Z_NOISE_GEN * z + SEED_NOISE_GEN * seed) & 0x7fffffff;
n = (n >> 13) ^ n;
return (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
}
|
java
|
{
"resource": ""
}
|
q179344
|
Noise.valueNoise3D
|
test
|
public static double valueNoise3D(int x, int y, int z, int seed) {
return intValueNoise3D(x, y, z, seed) / 2147483647.0;
}
|
java
|
{
"resource": ""
}
|
q179345
|
Utils.cubicInterp
|
test
|
public static double cubicInterp(double n0, double n1, double n2, double n3, double a) {
double p = (n3 - n2) - (n0 - n1);
double q = (n0 - n1) - p;
double r = n2 - n0;
return p * a * a * a + q * a * a + r * a + n1;
}
|
java
|
{
"resource": ""
}
|
q179346
|
Utils.sCurve5
|
test
|
public static double sCurve5(double a) {
double a3 = a * a * a;
double a4 = a3 * a;
double a5 = a4 * a;
return (6.0 * a5) - (15.0 * a4) + (10.0 * a3);
}
|
java
|
{
"resource": ""
}
|
q179347
|
Range.setBounds
|
test
|
public void setBounds(double currentLower, double currentUpper, double newLower,
double newUpper) {
if (currentLower == currentUpper) {
throw new IllegalArgumentException("currentLower must not equal currentUpper. Both are " + currentUpper);
}
if (newLower == newUpper) {
throw new IllegalArgumentException("newLowerBound must not equal newUpperBound. Both are " + newUpper);
}
currentLowerBound = currentLower;
currentUpperBound = currentUpper;
newLowerBound = newLower;
newUpperBound = newUpper;
recalculateScaleBias();
}
|
java
|
{
"resource": ""
}
|
q179348
|
PluginEventsProcessor.doProcess
|
test
|
protected void doProcess(final CloudTrailEvent event) {
for (final FullstopPlugin plugin : getPluginsForEvent(event)) {
doProcess(event, plugin);
}
}
|
java
|
{
"resource": ""
}
|
q179349
|
PluginEventsProcessor.doProcess
|
test
|
protected void doProcess(final CloudTrailEvent event, final FullstopPlugin plugin) {
try {
plugin.processEvent(event);
} catch (HystrixRuntimeException | HttpServerErrorException e) {
log.warn(e.getMessage(), e);
} catch (final Exception e) {
log.error(e.getMessage(), e);
}
}
|
java
|
{
"resource": ""
}
|
q179350
|
CloudTrailEventSupport.getAccountId
|
test
|
public static String getAccountId(final CloudTrailEvent event) {
final CloudTrailEventData eventData = getEventData(event);
final UserIdentity userIdentity = checkNotNull(eventData.getUserIdentity(), USER_IDENTITY_SHOULD_NEVER_BE_NULL);
final String value = ofNullable(userIdentity.getAccountId()).orElse(eventData.getRecipientAccountId());
return checkNotNull(value, ACCOUNT_ID_OR_RECIPIENT_SHOULD_NEVER_BE_NULL);
}
|
java
|
{
"resource": ""
}
|
q179351
|
WhitelistRulesEvaluator.apply
|
test
|
@Override
public Boolean apply(final RuleEntity ruleEntity, final ViolationEntity violationEntity) {
final List<Predicate<ViolationEntity>> predicates = newArrayList();
trimOptional(ruleEntity.getAccountId())
.map(WhitelistRulesEvaluator::accountIsEqual)
.ifPresent(predicates::add);
trimOptional(ruleEntity.getRegion())
.map(WhitelistRulesEvaluator::regionIsEqual)
.ifPresent(predicates::add);
trimOptional(ruleEntity.getViolationTypeEntityId())
.map(WhitelistRulesEvaluator::violationTypeIdIsEqual)
.ifPresent(predicates::add);
trimOptional(ruleEntity.getImageName())
.map(WhitelistRulesEvaluator::imageNameMatches)
.ifPresent(predicates::add);
trimOptional(ruleEntity.getImageOwner())
.map(WhitelistRulesEvaluator::imageOwnerIsEqual)
.ifPresent(predicates::add);
trimOptional(ruleEntity.getApplicationId())
.map(WhitelistRulesEvaluator::applicationIdIsEqual)
.ifPresent(predicates::add);
trimOptional(ruleEntity.getApplicationVersion())
.map(WhitelistRulesEvaluator::applicationVersionIsEqual)
.ifPresent(predicates::add);
trimOptional(ruleEntity.getMetaInfoJsonPath())
.map(this::metaInfoJsonPathExists)
.ifPresent(predicates::add);
final Optional<Predicate<ViolationEntity>> whiteListTest = predicates.stream().reduce(Predicate::and);
return whiteListTest.isPresent() && whiteListTest.get().test(violationEntity);
}
|
java
|
{
"resource": ""
}
|
q179352
|
FileEventReader.getEventSerializer
|
test
|
private EventSerializer getEventSerializer(final GZIPInputStream inputStream, final CloudTrailLog ctLog)
throws IOException {
final EventSerializer serializer;
if (isEnableRawEventInfo) {
final String logFileContent = new String(LibraryUtils.toByteArray(inputStream), StandardCharsets.UTF_8);
final JsonParser jsonParser = this.mapper.getFactory().createParser(logFileContent);
serializer = new RawLogDeliveryEventSerializer(logFileContent, ctLog, jsonParser);
}
else {
final JsonParser jsonParser = this.mapper.getFactory().createParser(inputStream);
serializer = new DefaultEventSerializer(ctLog, jsonParser);
}
return serializer;
}
|
java
|
{
"resource": ""
}
|
q179353
|
TemporaryFolder.createFile
|
test
|
public File createFile(String fileName) throws IOException {
Path path = Paths.get(rootFolder.getPath(), fileName);
return Files.createFile(path).toFile();
}
|
java
|
{
"resource": ""
}
|
q179354
|
TemporaryFolder.createDirectory
|
test
|
public File createDirectory(String directoryName) {
Path path = Paths.get(rootFolder.getPath(), directoryName);
try {
return Files.createDirectory(path).toFile();
} catch (IOException ex) {
throw new TemporaryFolderException(
String.format("Failed to create directory: '%s'", path.toString()), ex);
}
}
|
java
|
{
"resource": ""
}
|
q179355
|
RestoreContext.restore
|
test
|
public void restore() {
for (String propertyName : propertyNames) {
if (restoreProperties.containsKey(propertyName)) {
// reinstate the original value
System.setProperty(propertyName, restoreProperties.get(propertyName));
} else {
// remove the (previously unset) property
System.clearProperty(propertyName);
}
}
}
|
java
|
{
"resource": ""
}
|
q179356
|
LazyMap.createImplementation
|
test
|
private Map<K, V> createImplementation()
{
if (delegate instanceof HashMap == false)
return new HashMap<K, V>(delegate);
return delegate;
}
|
java
|
{
"resource": ""
}
|
q179357
|
CachedCollection.add
|
test
|
public boolean add(final Object obj) {
maintain();
SoftObject soft = SoftObject.create(obj, queue);
return collection.add(soft);
}
|
java
|
{
"resource": ""
}
|
q179358
|
Property.set
|
test
|
public static String set(String name, String value)
{
return PropertyManager.setProperty(name, value);
}
|
java
|
{
"resource": ""
}
|
q179359
|
Property.getArray
|
test
|
public static String[] getArray(String base, String[] defaultValues)
{
return PropertyManager.getArrayProperty(base, defaultValues);
}
|
java
|
{
"resource": ""
}
|
q179360
|
StateMachine.nextState
|
test
|
public State nextState(String actionName)
throws IllegalTransitionException
{
Transition t = currentState.getTransition(actionName);
if( t == null )
{
String msg = "No transition for action: '" + actionName
+ "' from state: '" + currentState.getName() + "'";
throw new IllegalTransitionException(msg);
}
State nextState = t.getTarget();
log.trace("nextState("+actionName+") = "+nextState);
currentState = nextState;
return currentState;
}
|
java
|
{
"resource": ""
}
|
q179361
|
SoftSet.processQueue
|
test
|
private void processQueue()
{
ComparableSoftReference cr;
while( (cr = (ComparableSoftReference) gcqueue.poll()) != null )
{
map.remove(cr.getKey());
}
}
|
java
|
{
"resource": ""
}
|
q179362
|
WeakTypeCache.get
|
test
|
@SuppressWarnings({"unchecked", "cast"})
public T get(Type type)
{
if (type == null)
throw new IllegalArgumentException("Null type");
if (type instanceof ParameterizedType)
return getParameterizedType((ParameterizedType) type);
else if (type instanceof Class)
return getClass((Class<?>) type);
else if (type instanceof TypeVariable)
// TODO Figure out why we need this cast with the Sun compiler?
return (T) getTypeVariable((TypeVariable) type);
else if (type instanceof GenericArrayType)
return getGenericArrayType((GenericArrayType) type);
else if (type instanceof WildcardType)
return getWildcardType((WildcardType) type);
else
throw new UnsupportedOperationException("Unknown type: " + type + " class=" + type.getClass());
}
|
java
|
{
"resource": ""
}
|
q179363
|
WeakTypeCache.getParameterizedType
|
test
|
protected T getParameterizedType(ParameterizedType type)
{
// First check if we already have it
T result = peek(type);
if (result != null)
return result;
// Instantiate
result = instantiate(type);
// Put the perlimanary result into the cache
put(type, result);
// Generate the details
generate(type, result);
return result;
}
|
java
|
{
"resource": ""
}
|
q179364
|
WeakTypeCache.getTypeVariable
|
test
|
protected <D extends GenericDeclaration> T getTypeVariable(TypeVariable<D> type)
{
// TODO JBMICROCONT-131 improve this
return get(type.getBounds()[0]);
}
|
java
|
{
"resource": ""
}
|
q179365
|
NestedRuntimeException.printStackTrace
|
test
|
public void printStackTrace(final PrintStream stream) {
if (nested == null || NestedThrowable.PARENT_TRACE_ENABLED) {
super.printStackTrace(stream);
}
NestedThrowable.Util.print(nested, stream);
}
|
java
|
{
"resource": ""
}
|
q179366
|
NestedRuntimeException.printStackTrace
|
test
|
public void printStackTrace(final PrintWriter writer) {
if (nested == null || NestedThrowable.PARENT_TRACE_ENABLED) {
super.printStackTrace(writer);
}
NestedThrowable.Util.print(nested, writer);
}
|
java
|
{
"resource": ""
}
|
q179367
|
MarshalledValueOutputStream.replaceObject
|
test
|
protected Object replaceObject(Object obj) throws IOException
{
if( (obj instanceof Remote) && !(obj instanceof RemoteStub) )
{
Remote remote = (Remote) obj;
try
{
obj = RemoteObject.toStub(remote);
}
catch(IOException ignore)
{
// Let the Serialization layer try with the orignal obj
}
}
return obj;
}
|
java
|
{
"resource": ""
}
|
q179368
|
BasicTaskWrapper.run
|
test
|
public void run()
{
// Get the execution thread
this.runThread = Thread.currentThread();
// Check for a start timeout
long runTime = getElapsedTime();
if (startTimeout > 0l && runTime >= startTimeout)
{
taskRejected(new StartTimeoutException("Start Timeout exceeded for task " + taskString));
return;
}
// We are about to start, check for a stop
boolean stopped = false;
synchronized (stateLock)
{
if (state == TASK_STOPPED)
{
stopped = true;
}
else
{
state = TASK_STARTED;
taskStarted();
if (waitType == Task.WAIT_FOR_START)
stateLock.notifyAll();
}
}
if (stopped)
{
taskRejected(new TaskStoppedException("Task stopped for task " + taskString));
return;
}
// Run the task
Throwable throwable = null;
try
{
task.execute();
}
catch (Throwable t)
{
throwable = t;
}
// It is complete
taskCompleted(throwable);
// We are completed
synchronized (stateLock)
{
state = TASK_COMPLETED;
if (waitType == Task.WAIT_FOR_COMPLETE)
stateLock.notifyAll();
}
}
|
java
|
{
"resource": ""
}
|
q179369
|
BasicTaskWrapper.setTask
|
test
|
protected void setTask(Task task)
{
if (task == null)
throw new IllegalArgumentException("Null task");
this.task = task;
this.taskString = task.toString();
this.startTime = System.currentTimeMillis();
this.waitType = task.getWaitType();
this.priority = task.getPriority();
this.startTimeout = task.getStartTimeout();
this.completionTimeout = task.getCompletionTimeout();
}
|
java
|
{
"resource": ""
}
|
q179370
|
BasicTaskWrapper.taskAccepted
|
test
|
protected boolean taskAccepted()
{
try
{
task.accepted(getElapsedTime());
return true;
}
catch (Throwable t)
{
log.warn("Unexpected error during 'accepted' for task: " + taskString, t);
return false;
}
}
|
java
|
{
"resource": ""
}
|
q179371
|
BasicTaskWrapper.taskRejected
|
test
|
protected boolean taskRejected(RuntimeException e)
{
try
{
task.rejected(getElapsedTime(), e);
return true;
}
catch (Throwable t)
{
log.warn("Unexpected error during 'rejected' for task: " + taskString, t);
if (e != null)
log.warn("Original reason for rejection of task: " + taskString, e);
return false;
}
}
|
java
|
{
"resource": ""
}
|
q179372
|
BasicTaskWrapper.taskStarted
|
test
|
protected boolean taskStarted()
{
try
{
task.started(getElapsedTime());
return true;
}
catch (Throwable t)
{
log.warn("Unexpected error during 'started' for task: " + taskString, t);
return false;
}
}
|
java
|
{
"resource": ""
}
|
q179373
|
BasicTaskWrapper.taskCompleted
|
test
|
protected boolean taskCompleted(Throwable throwable)
{
try
{
task.completed(getElapsedTime(), throwable);
return true;
}
catch (Throwable t)
{
log.warn("Unexpected error during 'completed' for task: " + taskString, t);
if (throwable != null)
log.warn("Original error during 'run' for task: " + taskString, throwable);
return false;
}
}
|
java
|
{
"resource": ""
}
|
q179374
|
BasicTaskWrapper.taskStop
|
test
|
protected boolean taskStop()
{
try
{
task.stop();
return true;
}
catch (Throwable t)
{
log.warn("Unexpected error during 'stop' for task: " + taskString, t);
return false;
}
}
|
java
|
{
"resource": ""
}
|
q179375
|
WorkerQueue.getJobImpl
|
test
|
protected Executable getJobImpl() throws InterruptedException
{
// While the queue is empty, wait();
// when notified take an event from the queue and return it.
while (m_currentJob == null) {wait();}
// This one is the job to return
JobItem item = m_currentJob;
// Go on to the next object for the next call.
m_currentJob = m_currentJob.m_next;
return item.m_job;
}
|
java
|
{
"resource": ""
}
|
q179376
|
WorkerQueue.putJobImpl
|
test
|
protected void putJobImpl(Executable job)
{
JobItem posted = new JobItem(job);
if (m_currentJob == null)
{
// The queue is empty, set the current job to process and
// wake up the thread waiting in method getJob
m_currentJob = posted;
notifyAll();
}
else
{
JobItem item = m_currentJob;
// The queue is not empty, find the end of the queue ad add the
// posted job at the end
while (item.m_next != null) {item = item.m_next;}
item.m_next = posted;
}
}
|
java
|
{
"resource": ""
}
|
q179377
|
BlockingMode.toBlockingMode
|
test
|
public static final BlockingMode toBlockingMode(String name)
{
BlockingMode mode = null;
if( name == null )
{
mode = null;
}
else if( name.equalsIgnoreCase("run") )
{
mode = RUN;
}
else if( name.equalsIgnoreCase("wait") )
{
mode = WAIT;
}
else if( name.equalsIgnoreCase("discard") )
{
mode = DISCARD;
}
else if( name.equalsIgnoreCase("discardOldest") )
{
mode = DISCARD_OLDEST;
}
else if( name.equalsIgnoreCase("abort") )
{
mode = ABORT;
}
return mode;
}
|
java
|
{
"resource": ""
}
|
q179378
|
BlockingMode.readResolve
|
test
|
Object readResolve() throws ObjectStreamException
{
// Replace the marshalled instance type with the local instance
BlockingMode mode = ABORT;
switch( type )
{
case RUN_TYPE:
mode = RUN;
break;
case WAIT_TYPE:
mode = RUN;
break;
case DISCARD_TYPE:
mode = RUN;
break;
case DISCARD_OLDEST_TYPE:
mode = RUN;
break;
case ABORT_TYPE:
mode = RUN;
break;
}
return mode;
}
|
java
|
{
"resource": ""
}
|
q179379
|
Catalog.setupReaders
|
test
|
public void setupReaders() {
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setNamespaceAware(true);
spf.setValidating(false);
SAXCatalogReader saxReader = new SAXCatalogReader(spf);
saxReader.setCatalogParser(null, "XMLCatalog",
"org.apache.xml.resolver.readers.XCatalogReader");
saxReader.setCatalogParser(OASISXMLCatalogReader.namespaceName,
"catalog",
"org.apache.xml.resolver.readers.OASISXMLCatalogReader");
addReader("application/xml", saxReader);
TR9401CatalogReader textReader = new TR9401CatalogReader();
addReader("text/plain", textReader);
}
|
java
|
{
"resource": ""
}
|
q179380
|
Catalog.addReader
|
test
|
public void addReader(String mimeType, CatalogReader reader) {
if (readerMap.containsKey(mimeType)) {
Integer pos = (Integer) readerMap.get(mimeType);
readerArr.set(pos.intValue(), reader);
} else {
readerArr.add(reader);
Integer pos = new Integer(readerArr.size()-1);
readerMap.put(mimeType, pos);
}
}
|
java
|
{
"resource": ""
}
|
q179381
|
Catalog.copyReaders
|
test
|
protected void copyReaders(Catalog newCatalog) {
// Have to copy the readers in the right order...convert hash to arr
Vector mapArr = new Vector(readerMap.size());
// Pad the mapArr out to the right length
for (int count = 0; count < readerMap.size(); count++) {
mapArr.add(null);
}
Enumeration enumt = readerMap.keys();
while (enumt.hasMoreElements()) {
String mimeType = (String) enumt.nextElement();
Integer pos = (Integer) readerMap.get(mimeType);
mapArr.set(pos.intValue(), mimeType);
}
for (int count = 0; count < mapArr.size(); count++) {
String mimeType = (String) mapArr.get(count);
Integer pos = (Integer) readerMap.get(mimeType);
newCatalog.addReader(mimeType,
(CatalogReader)
readerArr.get(pos.intValue()));
}
}
|
java
|
{
"resource": ""
}
|
q179382
|
Catalog.newCatalog
|
test
|
protected Catalog newCatalog() {
String catalogClass = this.getClass().getName();
try {
Catalog c = (Catalog) (Class.forName(catalogClass).newInstance());
c.setCatalogManager(catalogManager);
copyReaders(c);
return c;
} catch (ClassNotFoundException cnfe) {
catalogManager.debug.message(1, "Class Not Found Exception: " + catalogClass);
} catch (IllegalAccessException iae) {
catalogManager.debug.message(1, "Illegal Access Exception: " + catalogClass);
} catch (InstantiationException ie) {
catalogManager.debug.message(1, "Instantiation Exception: " + catalogClass);
} catch (ClassCastException cce) {
catalogManager.debug.message(1, "Class Cast Exception: " + catalogClass);
} catch (Exception e) {
catalogManager.debug.message(1, "Other Exception: " + catalogClass);
}
Catalog c = new Catalog();
c.setCatalogManager(catalogManager);
copyReaders(c);
return c;
}
|
java
|
{
"resource": ""
}
|
q179383
|
Catalog.loadSystemCatalogs
|
test
|
public void loadSystemCatalogs()
throws MalformedURLException, IOException {
Vector catalogs = catalogManager.getCatalogFiles();
if (catalogs != null) {
for (int count = 0; count < catalogs.size(); count++) {
catalogFiles.addElement(catalogs.elementAt(count));
}
}
if (catalogFiles.size() > 0) {
// This is a little odd. The parseCatalog() method expects
// a filename, but it adds that name to the end of the
// catalogFiles vector, and then processes that vector.
// This allows the system to handle CATALOG entries
// correctly.
//
// In this init case, we take the last element off the
// catalogFiles vector and pass it to parseCatalog. This
// will "do the right thing" in the init case, and allow
// parseCatalog() to do the right thing in the non-init
// case. Honest.
//
String catfile = (String) catalogFiles.lastElement();
catalogFiles.removeElement(catfile);
parseCatalog(catfile);
}
}
|
java
|
{
"resource": ""
}
|
q179384
|
Catalog.parseCatalog
|
test
|
public synchronized void parseCatalog(URL aUrl) throws IOException {
catalogCwd = aUrl;
base = aUrl;
default_override = catalogManager.getPreferPublic();
catalogManager.debug.message(4, "Parse catalog: " + aUrl.toString());
DataInputStream inStream = null;
boolean parsed = false;
for (int count = 0; !parsed && count < readerArr.size(); count++) {
CatalogReader reader = (CatalogReader) readerArr.get(count);
try {
inStream = new DataInputStream(aUrl.openStream());
} catch (FileNotFoundException fnfe) {
// No catalog; give up!
break;
}
try {
reader.readCatalog(this, inStream);
parsed=true;
} catch (CatalogException ce) {
if (ce.getExceptionType() == CatalogException.PARSE_FAILED) {
// give up!
break;
} else {
// try again!
}
}
try {
inStream.close();
} catch (IOException e) {
//nop
}
}
if (parsed) parsePendingCatalogs();
}
|
java
|
{
"resource": ""
}
|
q179385
|
Catalog.parsePendingCatalogs
|
test
|
protected synchronized void parsePendingCatalogs()
throws MalformedURLException, IOException {
if (!localCatalogFiles.isEmpty()) {
// Move all the localCatalogFiles into the front of
// the catalogFiles queue
Vector newQueue = new Vector();
Enumeration q = localCatalogFiles.elements();
while (q.hasMoreElements()) {
newQueue.addElement(q.nextElement());
}
// Put the rest of the catalogs on the end of the new list
for (int curCat = 0; curCat < catalogFiles.size(); curCat++) {
String catfile = (String) catalogFiles.elementAt(curCat);
newQueue.addElement(catfile);
}
catalogFiles = newQueue;
localCatalogFiles.clear();
}
// Suppose there are no catalog files to process, but the
// single catalog already parsed included some delegate
// entries? Make sure they don't get lost.
if (catalogFiles.isEmpty() && !localDelegate.isEmpty()) {
Enumeration e = localDelegate.elements();
while (e.hasMoreElements()) {
catalogEntries.addElement(e.nextElement());
}
localDelegate.clear();
}
// Now process all the files on the catalogFiles vector. This
// vector can grow during processing if CATALOG entries are
// encountered in the catalog
while (!catalogFiles.isEmpty()) {
String catfile = (String) catalogFiles.elementAt(0);
try {
catalogFiles.remove(0);
} catch (ArrayIndexOutOfBoundsException e) {
// can't happen
}
if (catalogEntries.size() == 0 && catalogs.size() == 0) {
// We haven't parsed any catalogs yet, let this
// catalog be the first...
try {
parseCatalogFile(catfile);
} catch (CatalogException ce) {
System.out.println("FIXME: " + ce.toString());
}
} else {
// This is a subordinate catalog. We save its name,
// but don't bother to load it unless it's necessary.
catalogs.addElement(catfile);
}
if (!localCatalogFiles.isEmpty()) {
// Move all the localCatalogFiles into the front of
// the catalogFiles queue
Vector newQueue = new Vector();
Enumeration q = localCatalogFiles.elements();
while (q.hasMoreElements()) {
newQueue.addElement(q.nextElement());
}
// Put the rest of the catalogs on the end of the new list
for (int curCat = 0; curCat < catalogFiles.size(); curCat++) {
catfile = (String) catalogFiles.elementAt(curCat);
newQueue.addElement(catfile);
}
catalogFiles = newQueue;
localCatalogFiles.clear();
}
if (!localDelegate.isEmpty()) {
Enumeration e = localDelegate.elements();
while (e.hasMoreElements()) {
catalogEntries.addElement(e.nextElement());
}
localDelegate.clear();
}
}
// We've parsed them all, reinit the vector...
catalogFiles.clear();
}
|
java
|
{
"resource": ""
}
|
q179386
|
Catalog.parseCatalogFile
|
test
|
protected synchronized void parseCatalogFile(String fileName)
throws MalformedURLException, IOException, CatalogException {
// The base-base is the cwd. If the catalog file is specified
// with a relative path, this assures that it gets resolved
// properly...
try {
// tack on a basename because URLs point to files not dirs
String userdir = fixSlashes(System.getProperty("user.dir"));
catalogCwd = new URL("file:" + userdir + "/basename");
} catch (MalformedURLException e) {
String userdir = fixSlashes(System.getProperty("user.dir"));
catalogManager.debug.message(1, "Malformed URL on cwd", userdir);
catalogCwd = null;
}
// The initial base URI is the location of the catalog file
try {
base = new URL(catalogCwd, fixSlashes(fileName));
} catch (MalformedURLException e) {
try {
base = new URL("file:" + fixSlashes(fileName));
} catch (MalformedURLException e2) {
catalogManager.debug.message(1, "Malformed URL on catalog filename",
fixSlashes(fileName));
base = null;
}
}
catalogManager.debug.message(2, "Loading catalog", fileName);
catalogManager.debug.message(4, "Default BASE", base.toString());
fileName = base.toString();
DataInputStream inStream = null;
boolean parsed = false;
boolean notFound = false;
for (int count = 0; !parsed && count < readerArr.size(); count++) {
CatalogReader reader = (CatalogReader) readerArr.get(count);
try {
notFound = false;
inStream = new DataInputStream(base.openStream());
} catch (FileNotFoundException fnfe) {
// No catalog; give up!
notFound = true;
break;
}
try {
reader.readCatalog(this, inStream);
parsed = true;
} catch (CatalogException ce) {
if (ce.getExceptionType() == CatalogException.PARSE_FAILED) {
// give up!
break;
} else {
// try again!
}
}
try {
inStream.close();
} catch (IOException e) {
//nop
}
}
if (!parsed) {
if (notFound) {
catalogManager.debug.message(3, "Catalog does not exist", fileName);
} else {
catalogManager.debug.message(1, "Failed to parse catalog", fileName);
}
}
}
|
java
|
{
"resource": ""
}
|
q179387
|
Catalog.unknownEntry
|
test
|
public void unknownEntry(Vector strings) {
if (strings != null && strings.size() > 0) {
String keyword = (String) strings.elementAt(0);
catalogManager.debug.message(2, "Unrecognized token parsing catalog", keyword);
}
}
|
java
|
{
"resource": ""
}
|
q179388
|
Catalog.parseAllCatalogs
|
test
|
public void parseAllCatalogs()
throws MalformedURLException, IOException {
// Parse all the subordinate catalogs
for (int catPos = 0; catPos < catalogs.size(); catPos++) {
Catalog c = null;
try {
c = (Catalog) catalogs.elementAt(catPos);
} catch (ClassCastException e) {
String catfile = (String) catalogs.elementAt(catPos);
c = newCatalog();
c.parseCatalog(catfile);
catalogs.setElementAt(c, catPos);
c.parseAllCatalogs();
}
}
// Parse all the DELEGATE catalogs
Enumeration enumt = catalogEntries.elements();
while (enumt.hasMoreElements()) {
CatalogEntry e = (CatalogEntry) enumt.nextElement();
if (e.getEntryType() == DELEGATE_PUBLIC
|| e.getEntryType() == DELEGATE_SYSTEM
|| e.getEntryType() == DELEGATE_URI) {
Catalog dcat = newCatalog();
dcat.parseCatalog(e.getEntryArg(1));
}
}
}
|
java
|
{
"resource": ""
}
|
q179389
|
Catalog.resolveDoctype
|
test
|
public String resolveDoctype(String entityName,
String publicId,
String systemId)
throws MalformedURLException, IOException {
String resolved = null;
catalogManager.debug.message(3, "resolveDoctype("
+entityName+","+publicId+","+systemId+")");
systemId = normalizeURI(systemId);
if (publicId != null && publicId.startsWith("urn:publicid:")) {
publicId = PublicId.decodeURN(publicId);
}
if (systemId != null && systemId.startsWith("urn:publicid:")) {
systemId = PublicId.decodeURN(systemId);
if (publicId != null && !publicId.equals(systemId)) {
catalogManager.debug.message(1, "urn:publicid: system identifier differs from public identifier; using public identifier");
systemId = null;
} else {
publicId = systemId;
systemId = null;
}
}
if (systemId != null) {
// If there's a SYSTEM entry in this catalog, use it
resolved = resolveLocalSystem(systemId);
if (resolved != null) {
return resolved;
}
}
if (publicId != null) {
// If there's a PUBLIC entry in this catalog, use it
resolved = resolveLocalPublic(DOCTYPE,
entityName,
publicId,
systemId);
if (resolved != null) {
return resolved;
}
}
// If there's a DOCTYPE entry in this catalog, use it
boolean over = default_override;
Enumeration enumt = catalogEntries.elements();
while (enumt.hasMoreElements()) {
CatalogEntry e = (CatalogEntry) enumt.nextElement();
if (e.getEntryType() == OVERRIDE) {
over = e.getEntryArg(0).equalsIgnoreCase("YES");
continue;
}
if (e.getEntryType() == DOCTYPE
&& e.getEntryArg(0).equals(entityName)) {
if (over || systemId == null) {
return e.getEntryArg(1);
}
}
}
// Otherwise, look in the subordinate catalogs
return resolveSubordinateCatalogs(DOCTYPE,
entityName,
publicId,
systemId);
}
|
java
|
{
"resource": ""
}
|
q179390
|
Catalog.resolveDocument
|
test
|
public String resolveDocument()
throws MalformedURLException, IOException {
// If there's a DOCUMENT entry, return it
catalogManager.debug.message(3, "resolveDocument");
Enumeration enumt = catalogEntries.elements();
while (enumt.hasMoreElements()) {
CatalogEntry e = (CatalogEntry) enumt.nextElement();
if (e.getEntryType() == DOCUMENT) {
return e.getEntryArg(1); //FIXME check this
}
}
return resolveSubordinateCatalogs(DOCUMENT,
null, null, null);
}
|
java
|
{
"resource": ""
}
|
q179391
|
Catalog.resolveSystem
|
test
|
public String resolveSystem(String systemId)
throws MalformedURLException, IOException {
catalogManager.debug.message(3, "resolveSystem("+systemId+")");
systemId = normalizeURI(systemId);
if (systemId != null && systemId.startsWith("urn:publicid:")) {
systemId = PublicId.decodeURN(systemId);
return resolvePublic(systemId, null);
}
// If there's a SYSTEM entry in this catalog, use it
if (systemId != null) {
String resolved = resolveLocalSystem(systemId);
if (resolved != null) {
return resolved;
}
}
// Otherwise, look in the subordinate catalogs
return resolveSubordinateCatalogs(SYSTEM,
null,
null,
systemId);
}
|
java
|
{
"resource": ""
}
|
q179392
|
Catalog.resolveLocalURI
|
test
|
protected String resolveLocalURI(String uri)
throws MalformedURLException, IOException {
Enumeration enumt = catalogEntries.elements();
while (enumt.hasMoreElements()) {
CatalogEntry e = (CatalogEntry) enumt.nextElement();
if (e.getEntryType() == URI
&& (e.getEntryArg(0).equals(uri))) {
return e.getEntryArg(1);
}
}
// If there's a REWRITE_URI entry in this catalog, use it
enumt = catalogEntries.elements();
String startString = null;
String prefix = null;
while (enumt.hasMoreElements()) {
CatalogEntry e = (CatalogEntry) enumt.nextElement();
if (e.getEntryType() == REWRITE_URI) {
String p = e.getEntryArg(0);
if (p.length() <= uri.length()
&& p.equals(uri.substring(0, p.length()))) {
// Is this the longest prefix?
if (startString == null
|| p.length() > startString.length()) {
startString = p;
prefix = e.getEntryArg(1);
}
}
}
if (prefix != null) {
// return the systemId with the new prefix
return prefix + uri.substring(startString.length());
}
}
// If there's a DELEGATE_URI entry in this catalog, use it
enumt = catalogEntries.elements();
Vector delCats = new Vector();
while (enumt.hasMoreElements()) {
CatalogEntry e = (CatalogEntry) enumt.nextElement();
if (e.getEntryType() == DELEGATE_URI) {
String p = e.getEntryArg(0);
if (p.length() <= uri.length()
&& p.equals(uri.substring(0, p.length()))) {
// delegate this match to the other catalog
delCats.addElement(e.getEntryArg(1));
}
}
}
if (delCats.size() > 0) {
Enumeration enumCats = delCats.elements();
if (catalogManager.debug.getDebug() > 1) {
catalogManager.debug.message(2, "Switching to delegated catalog(s):");
while (enumCats.hasMoreElements()) {
String delegatedCatalog = (String) enumCats.nextElement();
catalogManager.debug.message(2, "\t" + delegatedCatalog);
}
}
Catalog dcat = newCatalog();
enumCats = delCats.elements();
while (enumCats.hasMoreElements()) {
String delegatedCatalog = (String) enumCats.nextElement();
dcat.parseCatalog(delegatedCatalog);
}
return dcat.resolveURI(uri);
}
return null;
}
|
java
|
{
"resource": ""
}
|
q179393
|
Catalog.resolveSubordinateCatalogs
|
test
|
protected synchronized String resolveSubordinateCatalogs(int entityType,
String entityName,
String publicId,
String systemId)
throws MalformedURLException, IOException {
for (int catPos = 0; catPos < catalogs.size(); catPos++) {
Catalog c = null;
try {
c = (Catalog) catalogs.elementAt(catPos);
} catch (ClassCastException e) {
String catfile = (String) catalogs.elementAt(catPos);
c = newCatalog();
try {
c.parseCatalog(catfile);
} catch (MalformedURLException mue) {
catalogManager.debug.message(1, "Malformed Catalog URL", catfile);
} catch (FileNotFoundException fnfe) {
catalogManager.debug.message(1, "Failed to load catalog, file not found",
catfile);
} catch (IOException ioe) {
catalogManager.debug.message(1, "Failed to load catalog, I/O error", catfile);
}
catalogs.setElementAt(c, catPos);
}
String resolved = null;
// Ok, now what are we supposed to call here?
if (entityType == DOCTYPE) {
resolved = c.resolveDoctype(entityName,
publicId,
systemId);
} else if (entityType == DOCUMENT) {
resolved = c.resolveDocument();
} else if (entityType == ENTITY) {
resolved = c.resolveEntity(entityName,
publicId,
systemId);
} else if (entityType == NOTATION) {
resolved = c.resolveNotation(entityName,
publicId,
systemId);
} else if (entityType == PUBLIC) {
resolved = c.resolvePublic(publicId, systemId);
} else if (entityType == SYSTEM) {
resolved = c.resolveSystem(systemId);
} else if (entityType == URI) {
resolved = c.resolveURI(systemId);
}
if (resolved != null) {
return resolved;
}
}
return null;
}
|
java
|
{
"resource": ""
}
|
q179394
|
Catalog.makeAbsolute
|
test
|
protected String makeAbsolute(String sysid) {
URL local = null;
sysid = fixSlashes(sysid);
try {
local = new URL(base, sysid);
} catch (MalformedURLException e) {
catalogManager.debug.message(1, "Malformed URL on system identifier", sysid);
}
if (local != null) {
return local.toString();
} else {
return sysid;
}
}
|
java
|
{
"resource": ""
}
|
q179395
|
Catalog.normalizeURI
|
test
|
protected String normalizeURI(String uriref) {
String newRef = "";
byte[] bytes;
if (uriref == null) {
return null;
}
try {
bytes = uriref.getBytes("UTF-8");
} catch (UnsupportedEncodingException uee) {
// this can't happen
catalogManager.debug.message(1, "UTF-8 is an unsupported encoding!?");
return uriref;
}
for (int count = 0; count < bytes.length; count++) {
int ch = bytes[count] & 0xFF;
if ((ch <= 0x20) // ctrl
|| (ch > 0x7F) // high ascii
|| (ch == 0x22) // "
|| (ch == 0x3C) // <
|| (ch == 0x3E) // >
|| (ch == 0x5C) // \
|| (ch == 0x5E) // ^
|| (ch == 0x60) // `
|| (ch == 0x7B) // {
|| (ch == 0x7C) // |
|| (ch == 0x7D) // }
|| (ch == 0x7F)) {
newRef += encodedByte(ch);
} else {
newRef += (char) bytes[count];
}
}
return newRef;
}
|
java
|
{
"resource": ""
}
|
q179396
|
Catalog.encodedByte
|
test
|
protected String encodedByte (int b) {
String hex = Integer.toHexString(b).toUpperCase();
if (hex.length() < 2) {
return "%0" + hex;
} else {
return "%" + hex;
}
}
|
java
|
{
"resource": ""
}
|
q179397
|
Catalog.addDelegate
|
test
|
protected void addDelegate(CatalogEntry entry) {
int pos = 0;
String partial = entry.getEntryArg(0);
Enumeration local = localDelegate.elements();
while (local.hasMoreElements()) {
CatalogEntry dpe = (CatalogEntry) local.nextElement();
String dp = dpe.getEntryArg(0);
if (dp.equals(partial)) {
// we already have this prefix
return;
}
if (dp.length() > partial.length()) {
pos++;
}
if (dp.length() < partial.length()) {
break;
}
}
// now insert partial into the vector at [pos]
if (localDelegate.size() == 0) {
localDelegate.addElement(entry);
} else {
localDelegate.insertElementAt(entry, pos);
}
}
|
java
|
{
"resource": ""
}
|
q179398
|
SoftValueRef.create
|
test
|
static <K, V> SoftValueRef<K, V> create(K key, V val, ReferenceQueue<V> q)
{
if (val == null)
return null;
else
return new SoftValueRef<K, V>(key, val, q);
}
|
java
|
{
"resource": ""
}
|
q179399
|
ThrowableHandler.fireOnThrowable
|
test
|
protected static void fireOnThrowable(int type, Throwable t) {
Object[] list = listeners.toArray();
for (int i=0; i<list.length; i++) {
((ThrowableListener)list[i]).onThrowable(type, t);
}
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.