_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q179700
|
Agent.post
|
test
|
private void post(Stack255 stack, Goal goal) {
synchronized (stack) {
logger.debug("{} posting goal {}", Log.logPrefix(getId()), goal.getClass().getSimpleName());
stack.push(goal);
Main.setAgentIdle(getId(), false);
}
Main.flagMessageTo(Main.poolid(getId()));
}
|
java
|
{
"resource": ""
}
|
q179701
|
Agent.send
|
test
|
public boolean send(int id, Goal msg) {
AObject obj = agents.get(id);
if (obj == null) {
logger.warn("{} attempted to send a message to unknown agent id '{}'", Log.logPrefix(getId()),
id);
return false;
}
logger.debug("{} is sending message of type {} to agent {}", Log.logPrefix(getId()),
msg.getClass().getSimpleName(), id);
((Agent) obj).post(msg);
return true;
}
|
java
|
{
"resource": ""
}
|
q179702
|
Agent.send
|
test
|
public boolean send(String name, Goal msg) {
AObject obj = agents.find(name);
if (obj == null) {
logger.warn("{} attempted to send a message to unknown agent '{}'", Log.logPrefix(getId()),
name);
return false;
}
((Agent) obj).post(msg);
return true;
}
|
java
|
{
"resource": ""
}
|
q179703
|
Agent.getGoals
|
test
|
public byte[] getGoals() {
byte[] arr = new byte[goals.length];
System.arraycopy(goals, 0, arr, 0, arr.length);
return arr;
}
|
java
|
{
"resource": ""
}
|
q179704
|
Agent.createBeliefSet
|
test
|
public void createBeliefSet(String name, BeliefSetField[] fields) throws BeliefBaseException {
beliefbase.createBeliefSet(getId(), name, fields);
}
|
java
|
{
"resource": ""
}
|
q179705
|
Agent.addBelief
|
test
|
public void addBelief(String beliefsetName, Object... tuple) throws BeliefBaseException {
beliefbase.addBelief(getId(), beliefsetName, tuple);
}
|
java
|
{
"resource": ""
}
|
q179706
|
Agent.eval
|
test
|
public boolean eval(String query) throws BeliefBaseException {
boolean result = beliefbase.eval(getId(), query);
lastresult = (result) ? beliefbase.query(getId(), query) : new HashSet<Belief>();
return result;
}
|
java
|
{
"resource": ""
}
|
q179707
|
Agent.suspend
|
test
|
public void suspend(boolean val) {
Main.setAgentIdle(getId(), val);
Main.flagMessageTo(Main.poolid(getId()));
}
|
java
|
{
"resource": ""
}
|
q179708
|
BeliefSet.getFieldByName
|
test
|
public BeliefSetField getFieldByName(String name) {
BeliefSetField field = null;
for (int i = 0; i < fields.length; i++) {
if (name.equals(fields[i].getName())) {
field = fields[i];
break;
}
}
return field;
}
|
java
|
{
"resource": ""
}
|
q179709
|
Greeter.registerNeighbours
|
test
|
private void registerNeighbours(Random rand, int count) throws BeliefBaseException {
int size = (count < 0) ? 0 : count;
for (int i = 0; i < size; i++) {
boolean male = (rand.nextDouble() < 0.5) ? true : false;
this.addBelief(beliefset, buildName(male), male ? "male" : "female");
}
}
|
java
|
{
"resource": ""
}
|
q179710
|
Greeter.buildName
|
test
|
private static String buildName(boolean male) {
StringBuilder name = new StringBuilder();
name.append(male ? males[rand.nextInt(males.length)] : females[rand.nextInt(females.length)])
.append(' ').append(middle[rand.nextInt(middle.length)]).append(' ')
.append(surnames[rand.nextInt(surnames.length)]);
return name.toString();
}
|
java
|
{
"resource": ""
}
|
q179711
|
IntentionSelector.run
|
test
|
public void run() {
Set<Integer> toRemove = new HashSet<Integer>();
do {
boolean idle = true;
// Remove agents that have have become idle due to an external event
removeInactiveAgents();
// Add agents that have have become active due to an external event
addActiveAgents();
for (Integer i : activeAgents) {
Agent agent = (Agent) GlobalState.agents.get(i);
Stack255 agentExecutionStack = (Stack255) (agent).getExecutionStack();
if (!isStackValid(agent, agentExecutionStack)) {
// Mark this agent for removal
toRemove.add(i);
continue;
}
// At least one agent is active
idle = false;
// Get the item at the top of the stack
Object node = (Object) agentExecutionStack.get((byte) (agentExecutionStack.size() - 1));
if (node instanceof Plan) {
// If it is a plan then execute a plan step; and if it finished then remove it
managePlan(i, agentExecutionStack, (Plan) node, toRemove);
} else if (node instanceof Goal) {
// If it is a goal then find a plan for it and put it on the stack
manageGoal(i, agent, agentExecutionStack, (Goal) node);
}
agent.nextActiveStack(); // select the next active stack for next time
}
// remove agents that have finished executing plans and have gone idle in this cycle
removeFinishedAgents(toRemove);
if (idle) {
waitOnExternalMessage();
if (shutdown) {
break;
}
}
}
while (true);
logger.debug("Pool {} is exiting", poolid);
}
|
java
|
{
"resource": ""
}
|
q179712
|
IntentionSelector.isStackValid
|
test
|
private boolean isStackValid(Agent agent, Stack255 agentExecutionStack) {
if (agentExecutionStack == null) {
return false;
}
final int esSize = agentExecutionStack.size();
logger.trace("{} execution stack is {}/255 full", Log.logPrefix(agent.getId()), esSize);
if (esSize == 0) {
return false;
}
if (esSize >= 255) {
logger.error("{} execution stack reached size limit of 255. Cannot continue.",
Log.logPrefix(agent.getId()));
return false;
}
return true;
}
|
java
|
{
"resource": ""
}
|
q179713
|
IntentionSelector.removeFinishedAgents
|
test
|
private void removeFinishedAgents(Set<Integer> toRemove) {
if (!toRemove.isEmpty()) {
for (int i : toRemove) {
activeAgents.remove(i);
}
toRemove.clear();
}
}
|
java
|
{
"resource": ""
}
|
q179714
|
IntentionSelector.manageGoal
|
test
|
private boolean manageGoal(int agentIndex, Agent agent, Stack255 agentExecutionStack, Goal node) {
// Get the goal type for this goal
GoalType gtype = (GoalType) GlobalState.goalTypes.find(node.getClass().getName());
byte[] ptypes = gtype.getChildren();
assert (ptypes != null);
// Clear any previous plan bindings before adding any new ones
bindings.clear();
for (int p = 0; p < ptypes.length; p++) {
PlanType ptype = (PlanType) GlobalState.planTypes.get(ptypes[p]);
try {
// Create an object of this Plan type, so we can
// access its context condition
Plan planInstance =
(Plan) (ptype.getPlanClass().getConstructor(Agent.class, Goal.class, String.class)
.newInstance(GlobalState.agents.get(agentIndex), node, "p"));
// Clear previously buffered context results if any
agent.clearLastResults();
// Evaluate the context condition
if (planInstance.context()) {
// Get the results of context query just performed
Set<Belief> results = agent.getLastResults();
// Add the results to the bindings
bindings.add(planInstance, (results == null) ? null : new LinkedHashSet<Belief>(results));
}
} catch (NoSuchMethodException | SecurityException | InstantiationException
| IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
logger.error("Could not create plan object of type " + ptype.getClass().getName(), e);
}
}
int numBindings = bindings.size();
if (numBindings == 0) {
// No plan options for this goal at this point in time, so move to the next agent
logger.debug(Log.logPrefix(agent.getId()) + " has no applicable plans for goal " + gtype
+ " and will continue to wait indefinitely");
return false;
}
// Call the meta-level planning prior to plan selection
agent.notifyAgentPrePlanSelection(bindings);
// Pick a plan option using specified policy
Plan planInstance = bindings.selectPlan(GlobalConstant.PLAN_SELECTION_POLICY);
// Now push the plan on to the intention stack
synchronized (agentExecutionStack) {
logger.debug(Log.logPrefix(agent.getId()) + " choose an instance of plan "
+ planInstance.getClass().getSimpleName() + " to handle goal "
+ node.getClass().getSimpleName());
agentExecutionStack.push(planInstance);
}
return true;
}
|
java
|
{
"resource": ""
}
|
q179715
|
IntentionSelector.shutdown
|
test
|
public void shutdown() {
synchronized (lock) {
logger.debug("Pool {} received shutdown message", poolid);
shutdown = true;
hasMessage = true;
lock.notify(); // NOPMD - ignore notifyall() warning
}
}
|
java
|
{
"resource": ""
}
|
q179716
|
IntentionSelector.setAgentIdle
|
test
|
public void setAgentIdle(int agentId, boolean idle) {
// If agent is becoming active, and not already active
if (!idle /* && !activeAgents.contains(agentId) */) {
synchronized (extToAdd) {
extToAdd.add(agentId);
}
}
// If agent is becoming idle, and not already idle
if (idle /* && activeAgents.contains(agentId) */) {
synchronized (extToRemove) {
extToRemove.add(agentId);
}
}
}
|
java
|
{
"resource": ""
}
|
q179717
|
Board.move
|
test
|
public boolean move(int pinA, int pinB) {
// Nothing to do if the pin number is invalid
if (pinA < 0 || pinA >= pins.length || pinB < 0 || pinB >= pins.length) {
Log.warn("Invalid board pin specified " + pinA + ". Should be between 0.." + (pins.length - 1)
+ " (inclusive).");
return false;
} else if (pins[pinA].isEmpty()) {
Log.warn("No disc on pin" + pinA);
return false;
} else if (pinA == pinB) {
Log.info("Moving disc from pin" + pinA + " on to itself (means the board will not change)");
return true;
}
int discOnA = pins[pinA].get(pins[pinA].size() - 1);
int discOnB =
(pins[pinB].isEmpty()) ? Integer.MAX_VALUE : pins[pinB].get(pins[pinB].size() - 1);
if (discOnB < discOnA) {
Log.warn("Cannot move disc" + discOnA + " (pin" + pinA + ") on to smaller disc" + discOnB
+ " (pin" + pinB + ")");
return false;
}
pins[pinB].add(pins[pinA].remove(pins[pinA].size() - 1));
return true;
}
|
java
|
{
"resource": ""
}
|
q179718
|
Main.init
|
test
|
public static boolean init(Config config) {
// Pause for key press from user if requested
if (config.isDoPauseForUserInput()) {
Program.pauseForUserInput();
}
// Configure logging
Log.createLogger(Main.LOGGER_NAME, config.getLogLevel(), config.getLogFile());
logger = LoggerFactory.getLogger(Main.LOGGER_NAME);
int numAgents = 0;
for (Config.AgentTypeData agentType : config.getAgents()) {
numAgents += agentType.getCount();
}
final int increment = 10000;
GlobalState.reset();
GlobalState.agents = new AObjectCatalog("agents", numAgents, increment);
// Create the central belief base
GlobalState.beliefbase = new ABeliefStore(numAgents, config.getNumThreads());
long t0;
// Create the agents
t0 = System.currentTimeMillis();
for (Config.AgentTypeData agentType : config.getAgents()) {
if (!ProgramLoader.loadAgent(agentType.getClassname(), agentType.getCount(),
GlobalState.agents)) {
// return unsuccessful
return false;
}
}
long t1 = System.currentTimeMillis();
logger.info("Created " + GlobalState.agents.size() + agentsIn + Log.formattedDuration(t0, t1));
// Initialise the thread pools
Program.initIntentionSelectionPools(numAgents, config.getNumThreads());
// Redirect the agent program output if specified
if (config.getProgramOutputFile() != null) {
try {
writer = new PrintStream(config.getProgramOutputFile(), "UTF-8");
} catch (FileNotFoundException | UnsupportedEncodingException e) {
logger.error("Could not open program outout file " + config.getProgramOutputFile(), e);
}
} else {
writer = System.out;
}
// Initialise the intention selection threads
Program.initIntentionSelectionThreads(config);
// return success
return true;
}
|
java
|
{
"resource": ""
}
|
q179719
|
Main.waitUntilIdle
|
test
|
public static void waitUntilIdle() {
// Wait till we are all done
long t0 = System.currentTimeMillis();
synchronized (poolsIdle) {
while (!arePoolsIdle()) {
try {
poolsIdle.wait();
} catch (InterruptedException e) {
logger.error("Failed to wait on termination condition: " + e.getMessage());
}
}
}
long t1 = System.currentTimeMillis();
logger.info(
"Finished running " + GlobalState.agents.size() + agentsIn + Log.formattedDuration(t0, t1));
}
|
java
|
{
"resource": ""
}
|
q179720
|
Main.finish
|
test
|
public static void finish() {
// Terminate the extensions first
for (JillExtension extension : GlobalState.eventHandlers) {
extension.finish();
}
// Now shut down the threads
Program.shutdownIntentionSelectionThreads();
// Finish the agents
long t0 = System.currentTimeMillis();
for (int i = 0; i < GlobalState.agents.size(); i++) {
// Get the agent
Agent agent = (Agent) GlobalState.agents.get(i);
// Terminate the agent
agent.finish();
}
// Close the writer
if (writer != null) {
writer.close();
}
long t1 = System.currentTimeMillis();
logger
.info("Terminated " + GlobalState.agents.size() + agentsIn + Log.formattedDuration(t0, t1));
}
|
java
|
{
"resource": ""
}
|
q179721
|
Main.arePoolsIdle
|
test
|
public static boolean arePoolsIdle() {
boolean idle = true;
for (int i = 0; i < npools; i++) {
idle &= (intentionSelectors[i] == null) || intentionSelectors[i].isIdle();
}
return idle;
}
|
java
|
{
"resource": ""
}
|
q179722
|
Main.poolid
|
test
|
public static int poolid(int agentid) {
int poolid = agentid / poolsize;
if (poolid + 1 > npools) {
poolid = npools - 1;
}
return poolid;
}
|
java
|
{
"resource": ""
}
|
q179723
|
JpaTranslationContext.pickExpression
|
test
|
@SuppressWarnings("unchecked")
public <E> Expression<E> pickExpression() {
Preconditions.checkState(this.expression != null, "No expression has been set");
Expression<E> result = (Expression<E>) this.expression;
expression = null;
return result;
}
|
java
|
{
"resource": ""
}
|
q179724
|
JpaTranslationContext.setExpression
|
test
|
public <E> void setExpression(Expression<E> expression) {
Preconditions.checkState(this.expression == null, "An expression is already set");
this.expression = expression;
}
|
java
|
{
"resource": ""
}
|
q179725
|
JpaUtils.join
|
test
|
public static Expression<?> join(String attribute, From<?, ?> from) {
Expression<?> path;
try {
String[] properties = attribute.split("\\.");
if (properties.length > 1) {
path = joinRecursively(properties, findOrCreateJoin(properties[0], from), 1)
.get(properties[properties.length - 1]);
} else {
path = from.get(properties[0]);
}
} catch (IllegalArgumentException e) {
throw SeedException.wrap(e, JpaErrorCode.UNABLE_TO_CREATE_JPA_JOIN_FOR_SPECIFICATION)
.put("property", attribute);
}
return path;
}
|
java
|
{
"resource": ""
}
|
q179726
|
JpaUtils.joinRecursively
|
test
|
private static Join<?, ?> joinRecursively(String[] properties, Join<?, ?> join, int index) {
if (index < properties.length - 1) {
return joinRecursively(properties, findOrCreateJoin(properties[index], join), index + 1);
} else {
return join;
}
}
|
java
|
{
"resource": ""
}
|
q179727
|
JpaUtils.findOrCreateJoin
|
test
|
private static Join<?, ?> findOrCreateJoin(String property, From<?, ?> from) {
for (Join<?, ?> rootJoin : from.getJoins()) {
if (rootJoin.getAttribute().getName().equals(property)) {
return rootJoin;
}
}
return from.join(property);
}
|
java
|
{
"resource": ""
}
|
q179728
|
PartialResponse.isEndReached
|
test
|
public boolean isEndReached() {
if (to == null || from == null) {
// No range specified, must be complete response
return true;
}
if (length == null) {
// No lenth specified, can't be end
return false;
}
return to == length - 1;
}
|
java
|
{
"resource": ""
}
|
q179729
|
MultipartFormArgumentsReader.getUploadStream
|
test
|
private static UploadStream getUploadStream(HttpServletRequest httpRequest, Type[] formalParameters) throws IOException {
FormIterator form = new FormIteratorImpl(httpRequest);
if (!form.hasNext()) {
throw new IllegalArgumentException("Empty form.");
}
Part part = form.next();
if (!(part instanceof UploadStream)) {
throw new IllegalArgumentException("Illegal form. Expected uploaded stream but got field |%s|.", part.getName());
}
return (UploadStream) part;
}
|
java
|
{
"resource": ""
}
|
q179730
|
RestServlet.handleRequest
|
test
|
@Override
protected void handleRequest(RequestContext context) throws IOException {
HttpServletRequest httpRequest = context.getRequest();
HttpServletResponse httpResponse = context.getResponse();
ArgumentsReader argumentsReader = null;
Object value = null;
ManagedMethodSPI method = null;
try {
method = restMethods.get(key(httpRequest.getPathInfo()));
if (method == null) {
throw new NoSuchMethodException();
}
Type[] formalParameters = method.getParameterTypes();
argumentsReader = argumentsReaderFactory.getArgumentsReader(httpRequest, formalParameters);
Object[] arguments = argumentsReader.read(httpRequest, formalParameters);
Object instance = container.getInstance(method.getDeclaringClass());
value = method.invoke(instance, arguments);
} catch (AuthorizationException e) {
sendUnauthorized(context);
return;
} catch (NoSuchMethodException e) {
sendNotFound(context, e);
return;
} catch (IllegalArgumentException e) {
// there are opinions that 422 UNPROCESSABLE ENTITY is more appropriate response
// see https://httpstatuses.com/422
sendBadRequest(context);
return;
} catch (InvocationException e) {
sendError(context, e);
return;
} finally {
if (argumentsReader != null) {
argumentsReader.clean();
}
}
httpResponse.setCharacterEncoding("UTF-8");
if (method.isVoid()) {
// expected servlet container behavior:
// since there is nothing written to respond to output stream, container either set content length to zero
// or closes connection signaling end of content
httpResponse.setStatus(HttpServletResponse.SC_NO_CONTENT);
return;
}
// expected servlet container behavior:
// if client request connection header is close container uses an internal buffer for serialized JSON, add content
// length response header based on buffer size and closes connection
// if client request connection header is not explicitly set to close, container uses an internal buffer for serialized
// JSON but with limited capacity; if capacity is not exceeded set response content length; if capacity is exceeded
// switch to chunked transfer
ContentType contentType = valueWriterFactory.getContentTypeForValue(value);
httpResponse.setStatus(HttpServletResponse.SC_OK);
httpResponse.setContentType(contentType.getValue());
ValueWriter valueWriter = valueWriterFactory.getValueWriter(contentType);
valueWriter.write(httpResponse, value);
}
|
java
|
{
"resource": ""
}
|
q179731
|
ContentType.hasParameter
|
test
|
public boolean hasParameter(String name, String value) {
Params.notNullOrEmpty(name, "Parameter name");
Params.notNullOrEmpty(value, "Parameter value");
return value.equals(parameters.get(name));
}
|
java
|
{
"resource": ""
}
|
q179732
|
ContentType.getParameter
|
test
|
public String getParameter(String name) {
Params.notNullOrEmpty(name, "Parameter name");
return parameters.get(name);
}
|
java
|
{
"resource": ""
}
|
q179733
|
ContentType.parseParameters
|
test
|
private static Map<String, String> parseParameters(String expression) {
// charset = UTF-8
Map<String, String> parameters = new HashMap<>();
int parametersSeparatorIndex = 0;
for (;;) {
int valueSeparatorIndex = expression.indexOf('=', parametersSeparatorIndex);
if (valueSeparatorIndex == -1) {
break;
}
String name = expression.substring(parametersSeparatorIndex, valueSeparatorIndex).trim();
++valueSeparatorIndex;
parametersSeparatorIndex = expression.indexOf(';', valueSeparatorIndex);
if (parametersSeparatorIndex == -1) {
parametersSeparatorIndex = expression.length();
}
if (valueSeparatorIndex == parametersSeparatorIndex) {
throw new SyntaxException("Invalid content type parameters |%s|. Value is empty.", expression);
}
if (parameters.put(name, expression.substring(valueSeparatorIndex, parametersSeparatorIndex).trim()) != null) {
throw new SyntaxException("Invalid content type parameters |%s|. Name override |%s|.", expression, name);
}
++parametersSeparatorIndex;
}
if (parameters.isEmpty()) {
throw new SyntaxException("Invalid content type parameters |%s|. Missing name/value separator.", expression);
}
return parameters;
}
|
java
|
{
"resource": ""
}
|
q179734
|
TransactionalResourceImpl.config
|
test
|
@Override
public void config(Config config) throws Exception {
log.trace("config(Config.Element)");
log.debug("Configure transaction manager |%s|.", transactionManager.getClass());
transactionManager.config(config);
}
|
java
|
{
"resource": ""
}
|
q179735
|
AbstractGenerator.getTargetFile
|
test
|
protected final GeneratedFile getTargetFile(final String artifactName, final String filename, final String logInfo) {
final Folder folder = getGeneratorConfig().findTargetFolder(artifactName);
final File dir = folder.getCanonicalDir();
final File file = new File(dir, filename);
// Make sure the folder exists
if (!dir.exists()) {
if (folder.isCreate()) {
dir.mkdirs();
} else {
throw new IllegalStateException("Directory '" + dir + "' does not exist, but configuration does not allow creation: "
+ "<folder name=\"" + folder.getName() + "\" create=\"false\" ... />");
}
}
// Make sure the parent directory for the file exists
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();
}
if (file.exists() && !folder.overrideAllowed(file)) {
// Skip file because override is not allowed
return new GeneratedFile(file, logInfo, true);
}
return new GeneratedFile(file, logInfo);
}
|
java
|
{
"resource": ""
}
|
q179736
|
AbstractGenerator.write
|
test
|
protected final void write(@NotNull final GeneratedArtifact artifact) throws GenerateException {
Contract.requireArgNotNull("artifact", artifact);
final GeneratedFile genFile = getTargetFile(artifact.getName(), artifact.getPathAndName(), null);
if (genFile.isSkip()) {
LOG.debug("Omitted already existing file: {} [{}]", genFile, artifact);
} else {
LOG.debug("Writing file: {} [{}]", genFile, artifact);
try {
final OutputStream out = new BufferedOutputStream(new FileOutputStream(genFile.getTmpFile()));
try {
out.write(artifact.getData());
} finally {
out.close();
}
genFile.persist();
} catch (final IOException ex) {
throw new GenerateException("Error writing artifact '" + artifact + "' to '" + artifact.getPathAndName() + "'!", ex);
}
}
}
|
java
|
{
"resource": ""
}
|
q179737
|
InstanceFieldsInitializationProcessor.postProcessInstance
|
test
|
@Override
public void postProcessInstance(ManagedClassSPI managedClass, Object instance) {
Config config = managedClass.getConfig();
if (config == null) {
return;
}
List<Config> fields = config.findChildren("instance-field");
if (!fields.isEmpty() && !InstanceType.POJO.equals(managedClass.getInstanceType())) {
throw new BugError("Cannot assign instance field on non %s type.", InstanceType.POJO);
}
for (Config field : fields) {
Classes.setFieldValue(instance, field.getAttribute("name"), field.getAttribute("value"));
}
}
|
java
|
{
"resource": ""
}
|
q179738
|
ManagedClass.getDeclaredConstructor
|
test
|
private static Constructor<?> getDeclaredConstructor(Class<?> implementationClass) {
if (implementationClass == null) {
return null;
}
Constructor<?>[] declaredConstructors = (Constructor<?>[]) implementationClass.getDeclaredConstructors();
if (declaredConstructors.length == 0) {
throw new BugError("Invalid implementation class |%s|. Missing constructor.", implementationClass);
}
Constructor<?> constructor = null;
for (Constructor<?> declaredConstructor : declaredConstructors) {
// synthetic constructors are created by compiler to circumvent JVM limitations, JVM that is not evolving with
// the same speed as the language; for example, to allow outer class to access private members on a nested class
// compiler creates a constructor with a single argument of very nested class type
if (declaredConstructor.isSynthetic()) {
continue;
}
if (declaredConstructor.getParameterTypes().length == 0) {
continue;
}
if (declaredConstructor.getAnnotation(Test.class) != null) {
continue;
}
if (constructor != null) {
throw new BugError("Implementation class |%s| has not a single constructor with parameters.", implementationClass);
}
constructor = declaredConstructor;
}
if (constructor == null) {
constructor = declaredConstructors[0];
}
constructor.setAccessible(true);
return constructor;
}
|
java
|
{
"resource": ""
}
|
q179739
|
ManagedClass.buildStringRepresentation
|
test
|
private String buildStringRepresentation(Config descriptor) {
StringBuilder builder = new StringBuilder();
builder.append(descriptor.getName());
builder.append(':');
if (implementationClass != null) {
builder.append(implementationClass.getName());
builder.append(':');
}
for (Class<?> interfaceClass : interfaceClasses) {
builder.append(interfaceClass.getName());
builder.append(':');
}
builder.append(instanceType);
builder.append(':');
builder.append(instanceScope);
builder.append(':');
builder.append(remotelyAccessible ? "NET" : "LOCAL");
if (implementationURL != null) {
builder.append(':');
builder.append(implementationURL);
}
return builder.toString();
}
|
java
|
{
"resource": ""
}
|
q179740
|
ManagedClass.getInterfaceMethod
|
test
|
private static Method getInterfaceMethod(Method method) {
for (Class<?> interfaceClass : method.getDeclaringClass().getInterfaces()) {
try {
return interfaceClass.getMethod(method.getName(), method.getParameterTypes());
} catch (NoSuchMethodException unused) {
}
}
return method;
}
|
java
|
{
"resource": ""
}
|
q179741
|
FormObject.type
|
test
|
private static Class<?> type(Field field) {
if (Types.isKindOf(field.getType(), List.class)) {
// for the purpose of this implementation only first parameterized
// type matters, as result from list declaration List<E>
return (Class<?>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
}
return field.getType();
}
|
java
|
{
"resource": ""
}
|
q179742
|
DependencyProcessor.getDependencyValue
|
test
|
@SuppressWarnings("unchecked")
protected static Object getDependencyValue(ManagedClassSPI hostManagedClass, Class<?> type) {
Stack<Class<?>> stackTrace = dependenciesStack.get();
if (stackTrace == null) {
stackTrace = new Stack<>();
dependenciesStack.set(stackTrace);
}
ContainerSPI container = hostManagedClass.getContainer();
if (stackTrace.contains(type)) {
try {
// add current dependency class to reveal what dependency from stack is circular
stackTrace.add(type);
StringBuilder builder = new StringBuilder();
builder.append("Circular dependency. Dependencies trace follows:\r\n");
for (Class<?> stackTraceClass : stackTrace) {
builder.append("\t- ");
builder.append(stackTraceClass.getName());
builder.append("\r\n");
}
log.error(builder.toString());
throw new BugError("Circular dependency for |%s|.", type.getName());
} finally {
// takes care to current thread stack trace is removed
dependenciesStack.remove();
}
}
stackTrace.push(type);
try {
ManagedClassSPI dependencyManagedClass = container.getManagedClass(type);
if (isProxyRequired(hostManagedClass, dependencyManagedClass)) {
// if scope proxy is required returns a Java Proxy handled by ScopeProxyHandler
ScopeProxyHandler<?> handler = new ScopeProxyHandler<>(container, type);
return Proxy.newProxyInstance(dependencyManagedClass.getImplementationClass().getClassLoader(), dependencyManagedClass.getInterfaceClasses(), handler);
}
Object value = container.getOptionalInstance((Class<? super Object>) type);
if (value != null) {
// if dependency type is a managed class returns it value from factory
return value;
}
if (Types.isKindOf(type, AppFactory.class)) {
// handle ApFactory and its hierarchy since it is a special case
return container;
}
if (Classes.isInstantiable(type)) {
// if requested type is instantiable POJO create a new empty instance of requested type
return Classes.newInstance(type);
}
// TODO: test value instance of
// if FactoryBean consider it as factory and substitute value
// e.g. value = ((FactoryBean)value).getInstance(value.getClass())
// all attempts to create dependency value has fallen
throw new BugError("Dependency |%s| not resolved for |%s|.", type.getName(), hostManagedClass);
} finally {
stackTrace.pop();
// do not remove stack trace after outermost call finished, i.e. when stack trace is empty
// leave it on thread local for reuse, in order to avoid unnecessary object creation
}
}
|
java
|
{
"resource": ""
}
|
q179743
|
GeneratedFile.persist
|
test
|
public final void persist() {
if (persisted) {
// Do nothing if already done
return;
}
try {
// Compare new and old file
if (FileUtils.contentEquals(tmpFile, file)) {
LOG.debug("Omitted: {} {}", getPath(), logInfo);
if (!tmpFile.delete()) {
tmpFile.deleteOnExit();
}
} else {
if (file.exists() && !file.delete()) {
throw new IOException("Wasn't able to delete file " + file);
}
if (!tmpFile.renameTo(file)) {
throw new IOException("Wasn't able to rename temporary file " + tmpFile + " to " + file);
}
LOG.info("Generated: {} {}", getPath(), logInfo);
}
persisted = true;
} catch (final IOException ex) {
throw new RuntimeException("Error comparing content: tmp=" + tmpFile + ", target=" + file + logInfo, ex);
}
}
|
java
|
{
"resource": ""
}
|
q179744
|
AbstractEndpoint.setDefaultLink
|
test
|
public final void setDefaultLink(String rel, String... hrefs) {
if (hrefs == null || hrefs.length == 0) {
defaultLinks.remove(rel);
} else {
defaultLinks.put(rel,
stream(hrefs).map(uri::resolve).collect(toSet()));
}
}
|
java
|
{
"resource": ""
}
|
q179745
|
AbstractEndpoint.setDefaultLinkTemplate
|
test
|
public final void setDefaultLinkTemplate(String rel, String href) {
if (href == null) {
defaultLinkTemplates.remove(rel);
} else {
defaultLinkTemplates.put(rel, href);
}
}
|
java
|
{
"resource": ""
}
|
q179746
|
AbstractEndpoint.handleLinks
|
test
|
@SuppressWarnings("LocalVariableHidesMemberVariable")
private void handleLinks(HttpResponse response) {
Map<String, Map<URI, String>> links = new HashMap<>();
Map<String, String> linkTemplates = new HashMap<>();
handleHeaderLinks(response, links, linkTemplates);
HttpEntity entity = response.getEntity();
if (entity != null) {
Header contentType = entity.getContentType();
if ((contentType != null) && contentType.getValue().startsWith("application/json")) {
try {
handleBodyLinks(serializer.readTree(entity.getContent()), links, linkTemplates);
} catch (IOException ex) {
throw new RuntimeException();
// Body error handling is done elsewhere
}
}
}
this.links = unmodifiableMap(links);
this.linkTemplates = unmodifiableMap(linkTemplates);
}
|
java
|
{
"resource": ""
}
|
q179747
|
AbstractEndpoint.handleHeaderLinks
|
test
|
protected void handleHeaderLinks(HttpResponse response, Map<String, Map<URI, String>> links, Map<String, String> linkTemplates) {
getLinkHeaders(response).forEach(header -> {
if (header.getRel() == null) {
return;
}
if (header.isTemplated()) {
linkTemplates.put(header.getRel(), header.getHref());
} else {
getOrAdd(links, header.getRel())
.put(uri.resolve(header.getHref()), header.getTitle());
}
});
}
|
java
|
{
"resource": ""
}
|
q179748
|
AbstractEndpoint.handleBodyLinks
|
test
|
protected void handleBodyLinks(JsonNode jsonBody, Map<String, Map<URI, String>> links, Map<String, String> linkTemplates) {
if (jsonBody.getNodeType() != JsonNodeType.OBJECT) {
return;
}
JsonNode linksNode = jsonBody.get("_links");
if (linksNode == null) {
linksNode = jsonBody.get("links");
}
if (linksNode == null) {
return;
}
linksNode.fields().forEachRemaining(x -> {
String rel = x.getKey();
Map<URI, String> linksForRel = getOrAdd(links, rel);
switch (x.getValue().getNodeType()) {
case ARRAY:
x.getValue().forEach(subobj -> {
if (subobj.getNodeType() == JsonNodeType.OBJECT) {
parseLinkObject(rel, (ObjectNode) subobj, linksForRel, linkTemplates);
}
});
break;
case OBJECT:
parseLinkObject(rel, (ObjectNode) x.getValue(), linksForRel, linkTemplates);
break;
}
});
}
|
java
|
{
"resource": ""
}
|
q179749
|
AbstractEndpoint.parseLinkObject
|
test
|
private void parseLinkObject(String rel, ObjectNode obj, Map<URI, String> linksForRel, Map<String, String> linkTemplates) {
JsonNode href = obj.findValue("href");
if (href == null) {
return;
}
JsonNode templated = obj.findValue("templated");
if (templated != null && templated.isBoolean() && templated.asBoolean()) {
linkTemplates.put(rel, href.asText());
} else {
JsonNode title = obj.findValue("title");
linksForRel.put(
uri.resolve(href.asText()),
(title != null && title.getNodeType() == JsonNodeType.STRING) ? title.asText() : null);
}
}
|
java
|
{
"resource": ""
}
|
q179750
|
AbstractEndpoint.getOrAdd
|
test
|
private static Map<URI, String> getOrAdd(Map<String, Map<URI, String>> map, String key) {
Map<URI, String> value = map.get(key);
if (value == null) {
map.put(key, value = new HashMap<>());
}
return value;
}
|
java
|
{
"resource": ""
}
|
q179751
|
AbstractEndpoint.handleCapabilities
|
test
|
protected void handleCapabilities(HttpResponse response) {
allowedMethods = unmodifiableSet(stream(response.getHeaders("Allow"))
.filter(x -> x.getName().equals("Allow"))
.flatMap(x -> stream(x.getElements())).map(x -> x.getName())
.collect(toSet()));
}
|
java
|
{
"resource": ""
}
|
q179752
|
AbstractEndpoint.isMethodAllowed
|
test
|
protected Optional<Boolean> isMethodAllowed(String method) {
if (allowedMethods.isEmpty()) {
return Optional.empty();
}
return Optional.of(allowedMethods.contains(method));
}
|
java
|
{
"resource": ""
}
|
q179753
|
Container.registerInstanceProcessor
|
test
|
protected void registerInstanceProcessor() {
registerInstanceProcessor(new InstanceFieldsInjectionProcessor());
registerInstanceProcessor(new InstanceFieldsInitializationProcessor());
registerInstanceProcessor(new ConfigurableInstanceProcessor());
registerInstanceProcessor(new PostConstructInstanceProcessor());
registerInstanceProcessor(new CronMethodsProcessor(cronManager));
registerInstanceProcessor(new LoggerInstanceProcessor());
}
|
java
|
{
"resource": ""
}
|
q179754
|
Container.registerInstanceFactory
|
test
|
protected void registerInstanceFactory(InstanceType instanceType, InstanceFactory instanceFactory) {
log.debug("Register instance factory |%s| to |%s|.", instanceFactory.getClass(), instanceType);
if (instanceFactories.put(instanceType, instanceFactory) != null) {
throw new BugError("Attempt to override instance type |%s|.", instanceType);
}
}
|
java
|
{
"resource": ""
}
|
q179755
|
Container.registerInstanceProcessor
|
test
|
protected void registerInstanceProcessor(InstanceProcessor instanceProcessor) {
for (InstanceProcessor existingInstanceProcessoor : instanceProcessors) {
if (existingInstanceProcessoor.getClass().equals(instanceProcessor.getClass())) {
throw new BugError("Attempt to override instance processor |%s|.", instanceProcessor.getClass());
}
}
log.debug("Register instance processor |%s|.", instanceProcessor.getClass());
instanceProcessors.add(instanceProcessor);
}
|
java
|
{
"resource": ""
}
|
q179756
|
Container.registerClassProcessor
|
test
|
protected void registerClassProcessor(ClassProcessor classProcessor) {
for (ClassProcessor existingClassProcessoor : classProcessors) {
if (existingClassProcessoor.getClass().equals(classProcessor.getClass())) {
throw new BugError("Attempt to override class processor |%s|.", classProcessor.getClass());
}
}
log.debug("Register class processor |%s|.", classProcessor.getClass());
classProcessors.add(classProcessor);
}
|
java
|
{
"resource": ""
}
|
q179757
|
Container.getInstance
|
test
|
@Override
public <T> T getInstance(Class<? super T> interfaceClass, Object... args) {
Params.notNull(interfaceClass, "Interface class");
ManagedClassSPI managedClass = classesPool.get(interfaceClass);
if (managedClass == null) {
throw new BugError("No managed class associated with interface class |%s|.", interfaceClass);
}
InstanceKey instanceKey = new InstanceKey(managedClass.getKey());
return getInstance(managedClass, instanceKey, args);
}
|
java
|
{
"resource": ""
}
|
q179758
|
ParameterizedTemplateModel.addArgument
|
test
|
public final void addArgument(@NotNull final Argument argument) {
if (arguments == null) {
arguments = new ArrayList<Argument>();
}
arguments.add(argument);
}
|
java
|
{
"resource": ""
}
|
q179759
|
ParameterizedTemplateModel.createTargetFileList
|
test
|
public final List<TargetFile> createTargetFileList() {
if (tflProducerConfig == null) {
LOG.info("Using target file list: {} elements", targetFiles.size());
return targetFiles;
}
final TargetFileListProducer producer = tflProducerConfig.getTargetFileListProducer();
LOG.info("Using target file list producer: {}", producer.getClass().getName());
return producer.createTargetFiles();
}
|
java
|
{
"resource": ""
}
|
q179760
|
ParameterizedTemplateModel.toXml
|
test
|
public final String toXml() {
try {
final JaxbHelper helper = new JaxbHelper();
return helper.write(this, createJaxbContext());
} catch (final MarshalObjectException ex) {
throw new RuntimeException(ex);
}
}
|
java
|
{
"resource": ""
}
|
q179761
|
ParameterizedTemplateModel.init
|
test
|
public final void init(final SrcGen4JContext context, final Map<String, String> vars) {
if (template != null) {
template = Utils4J.replaceVars(template, vars);
}
if (arguments != null) {
for (final Argument argument : arguments) {
argument.init(vars);
}
}
if (targetFiles != null) {
for (final TargetFile targetFile : targetFiles) {
targetFile.init(vars);
}
}
if (tflProducerConfig != null) {
tflProducerConfig.init(context, this, vars);
}
}
|
java
|
{
"resource": ""
}
|
q179762
|
ParameterizedTemplateModel.hasReferenceTo
|
test
|
public final boolean hasReferenceTo(final File templateDir, final File templateFile) {
final String p1 = Utils4J.getCanonicalPath(new File(templateDir, template));
final String p2 = Utils4J.getCanonicalPath(templateFile);
return p1.equals(p2);
}
|
java
|
{
"resource": ""
}
|
q179763
|
ParameterizedTemplateModel.create
|
test
|
public static ParameterizedTemplateModel create(final Reader reader) {
try {
final JaxbHelper helper = new JaxbHelper();
final ParameterizedTemplateModel pc = helper.create(reader, createJaxbContext());
Contract.requireValid(pc);
return pc;
} catch (final UnmarshalObjectException ex) {
throw new RuntimeException(ex);
}
}
|
java
|
{
"resource": ""
}
|
q179764
|
ParameterizedTemplateModel.create
|
test
|
public static ParameterizedTemplateModel create(final File file) {
try {
final JaxbHelper helper = new JaxbHelper();
final ParameterizedTemplateModel pc = helper.create(file, createJaxbContext());
pc.setFile(file);
Contract.requireValid(pc);
return pc;
} catch (final UnmarshalObjectException ex) {
throw new RuntimeException(ex);
}
}
|
java
|
{
"resource": ""
}
|
q179765
|
ManagedMethod.setRequestPath
|
test
|
void setRequestPath(String requestPath) {
this.requestPath = requestPath != null ? requestPath : Strings.toDashCase(method.getName());
}
|
java
|
{
"resource": ""
}
|
q179766
|
AbstractStreamEndpoint.getObservable
|
test
|
StoppableObservable<TEntity> getObservable(final long startIndex, Scheduler scheduler) {
return runAsync(scheduler, (rx.Observer<? super TEntity> observer, Subscription subscription) -> {
long currentStartIndex = startIndex;
while (!subscription.isUnsubscribed()) {
PartialResponse<TEntity> response;
try {
response = (currentStartIndex >= 0)
? readRange(currentStartIndex, null)
: readRange(null, -currentStartIndex);
} catch (IllegalStateException ex) {
// No new data available yet, keep polling
continue;
} catch (IOException | IllegalArgumentException | IllegalAccessException error) {
observer.onError(error);
return;
}
response.getElements().stream().forEach(observer::onNext);
if (response.isEndReached()) {
observer.onCompleted();
return;
}
// Continue polling for more data
currentStartIndex = response.getTo() + 1;
}
});
}
|
java
|
{
"resource": ""
}
|
q179767
|
InstanceScope.asObject
|
test
|
@SuppressWarnings("unchecked")
@Override
public <T> T asObject(String string, Class<T> valueType) {
return (T) new InstanceScope(string);
}
|
java
|
{
"resource": ""
}
|
q179768
|
ContextParamProcessor.setField
|
test
|
private void setField(Field field, String parameterName, Object instance) {
final Object value = context.getProperty(parameterName, field.getType());
try {
field.set(instance, value);
} catch (Exception e) {
throw new BugError(e);
}
}
|
java
|
{
"resource": ""
}
|
q179769
|
LogHelper.addCaptureToLogger
|
test
|
public void addCaptureToLogger(final AppenderAttachable logger,
final String appenderName) {
Appender currentAppender = logger.getAppender(appenderName);
Appender captureAppender = CaptureAppender.newAppenderFrom(currentAppender);
logger.addAppender(captureAppender);
}
|
java
|
{
"resource": ""
}
|
q179770
|
LogHelper.remove
|
test
|
public void remove(final AppenderAttachable logger, final String appenderName) {
logger.removeAppender(CaptureAppender.getAppenderNameFor(appenderName));
}
|
java
|
{
"resource": ""
}
|
q179771
|
LogHelper.clear
|
test
|
public void clear(final AppenderAttachable logger, final String appenderName) {
((CaptureAppender) logger.getAppender(CaptureAppender.getAppenderNameFor(
appenderName))).clear();
}
|
java
|
{
"resource": ""
}
|
q179772
|
MultipartMixedArgumentsReader.read
|
test
|
@Override
public Object[] read(HttpServletRequest httpRequest, Type[] formalParameters) throws IOException, IllegalArgumentException {
try {
Object[] arguments = new Object[formalParameters.length];
int argumentIndex = 0;
ServletFileUpload multipart = new ServletFileUpload();
FileItemIterator iterator = multipart.getItemIterator(httpRequest);
FileItemStream fileItemStream = null;
while (iterator.hasNext()) {
fileItemStream = iterator.next();
String contentType = fileItemStream.getContentType();
Type parameterType = formalParameters[argumentIndex];
ArgumentPartReader reader = argumentsReaderFactory.getArgumentPartReader(contentType, parameterType);
boolean streamArgument = StreamFactory.isStream(parameterType);
ArgumentPartReader argumentPartReader = (ArgumentPartReader) reader;
InputStream inputStream = streamArgument ? new LazyFileItemStream(fileItemStream) : fileItemStream.openStream();
arguments[argumentIndex] = argumentPartReader.read(inputStream, parameterType);
++argumentIndex;
// stream argument should be last on mixed arguments list
// save it to local thread storage for clean-up after arguments processed by application
if (streamArgument) {
threadLocal.set(inputStream);
break;
}
inputStream.close();
}
if (argumentIndex != formalParameters.length) {
throw new IllegalArgumentException("Not all parameters processed due to stream argument that is not the last on arguments list.");
}
return arguments;
} catch (FileUploadException e) {
throw new IOException(e.getMessage());
}
}
|
java
|
{
"resource": ""
}
|
q179773
|
AbstractEMFParser.parseModel
|
test
|
protected final void parseModel() {
if ((fileExtensions == null) || (fileExtensions.size() == 0)) {
throw new IllegalStateException("No file extensions for EMF model files set!");
}
// Drop previous resource set
resourceSet = new ResourceSetImpl();
error = false;
parseDirs();
parseResources();
}
|
java
|
{
"resource": ""
}
|
q179774
|
AbstractEMFParser.resolveProxies
|
test
|
protected final void resolveProxies() {
final List<String> unresolved = new ArrayList<String>();
if (!resolvedAllProxies(unresolved, 0)) {
LOG.warn("Could not resolve the following proxies ({}):", unresolved.size());
for (final String ref : unresolved) {
LOG.warn("Not found: {}", ref);
}
final Iterator<Notifier> it = resourceSet.getAllContents();
while (it.hasNext()) {
final Notifier next = it.next();
if (next instanceof EObject) {
final EObject obj = (EObject) next;
if (obj.eIsProxy()) {
try {
it.remove();
} catch (final UnsupportedOperationException ex) {
LOG.error("Could not remove proxy: " + obj, ex);
}
}
}
}
}
}
|
java
|
{
"resource": ""
}
|
q179775
|
AbstractEMFParser.getFiles
|
test
|
private File[] getFiles(final File dir) {
final File[] files = dir.listFiles(new FileFilter() {
@Override
public boolean accept(final File file) {
final boolean pointFile = file.getName().startsWith(".");
final String extension = FilenameUtils.getExtension(file.getName());
return (!pointFile && fileExtensions.contains(extension)) || file.isDirectory();
}
});
return files;
}
|
java
|
{
"resource": ""
}
|
q179776
|
AbstractEMFParser.parseDir
|
test
|
private void parseDir(final File dir) {
LOG.debug("Parse: {}", dir);
final File[] files = getFiles(dir);
if ((files == null) || (files.length == 0)) {
LOG.debug("No files found in directory: {}", dir);
} else {
for (final File file : files) {
if (file.isFile()) {
final Resource resource = resourceSet.getResource(URI.createFileURI(Utils4J.getCanonicalPath(file)), true);
final EList<Diagnostic> diagnostics = resource.getErrors();
if (diagnostics.size() == 0) {
LOG.debug("Parsed {}", file);
} else {
error = true;
LOG.error("Parsed {} with errors: {}", file, diagnostics);
}
} else {
parseDir(file);
}
}
}
}
|
java
|
{
"resource": ""
}
|
q179777
|
AbstractEMFParser.isModelFullyResolved
|
test
|
public boolean isModelFullyResolved() {
boolean resolved = true;
final Set<EObject> eObjects = findAllEObjects(resourceSet);
final Iterator<EObject> it = eObjects.iterator();
while (it.hasNext()) {
final EObject eObj = it.next();
if (eObj instanceof InternalEObject) {
final InternalEObject iObj = (InternalEObject) eObj;
for (final EObject crossRef : iObj.eCrossReferences()) {
if (crossRef.eIsProxy()) {
LOG.error("Unresolved: {}", crossRef);
resolved = false;
}
}
}
}
return resolved;
}
|
java
|
{
"resource": ""
}
|
q179778
|
AbstractEMFParser.findAllEObjects
|
test
|
private static Set<EObject> findAllEObjects(final ResourceSet resourceSet) {
final Set<EObject> list = new HashSet<EObject>();
for (final Iterator<Notifier> i = resourceSet.getAllContents(); i.hasNext();) {
final Notifier next = i.next();
if (next instanceof EObject) {
list.add((EObject) next);
}
}
return list;
}
|
java
|
{
"resource": ""
}
|
q179779
|
AbstractEMFParser.setModelDirs
|
test
|
protected final void setModelDirs(final File... modelDirs) {
if (modelDirs == null) {
this.modelDirs = null;
} else {
this.modelDirs = new ArrayList<File>();
this.modelDirs.addAll(Arrays.asList(modelDirs));
}
}
|
java
|
{
"resource": ""
}
|
q179780
|
AbstractEMFParser.setFileExtensions
|
test
|
protected final void setFileExtensions(final String... fileExtensions) {
if (fileExtensions == null) {
this.fileExtensions = null;
} else {
this.fileExtensions = new ArrayList<String>();
this.fileExtensions.addAll(Arrays.asList(fileExtensions));
}
}
|
java
|
{
"resource": ""
}
|
q179781
|
AbstractEMFParser.setModelResources
|
test
|
protected final void setModelResources(final URI... modelResources) {
if (modelResources == null) {
this.modelResources = null;
} else {
this.modelResources = new ArrayList<URI>();
this.modelResources.addAll(Arrays.asList(modelResources));
}
}
|
java
|
{
"resource": ""
}
|
q179782
|
CSVRecordReader.nextRecord
|
test
|
@Override
public final boolean nextRecord() throws IOException {
final String line = reader.readLine();
if (line == null) {
parts = null;
return false;
}
final List<String> newParts = splitLine(line);
parts = newParts.toArray(new String[newParts.size()]);
partIndex = 0;
return true;
}
|
java
|
{
"resource": ""
}
|
q179783
|
StatementImpl.setStringArray
|
test
|
public void setStringArray(String parameterName, String... values) throws java.sql.SQLException {
int arrayLen = this.getSql().getArrayLen(parameterName);
AssertUtils.assertTrue(values.length <= arrayLen);
for (int i = 0; i < arrayLen; i++) {
setString2(Sql.toParamName(parameterName, i), (i < values.length) ? values[i] : null);
}
}
|
java
|
{
"resource": ""
}
|
q179784
|
StatementImpl.setBoolean2
|
test
|
public void setBoolean2(String parameterName, Boolean value) throws java.sql.SQLException {
if (value == null) {
setNull(parameterName, Types.BIT);
} else {
setBoolean(parameterName, value);
}
}
|
java
|
{
"resource": ""
}
|
q179785
|
StatementImpl.executeLargeUpdate
|
test
|
@Override
public long executeLargeUpdate(java.lang.String sql, int[] columnIndexes) throws java.sql.SQLException {
return this.stat.executeLargeUpdate(sql, columnIndexes);
}
|
java
|
{
"resource": ""
}
|
q179786
|
InstanceType.asObject
|
test
|
@SuppressWarnings("unchecked")
@Override
public <T> T asObject(String string, Class<T> valueType) throws IllegalArgumentException, ConverterException {
return (T) new InstanceType(string);
}
|
java
|
{
"resource": ""
}
|
q179787
|
VelocityGenerator.merge
|
test
|
protected final void merge(final VelocityContext context, final String artifactName, final String templateName, final String filename)
throws GenerateException {
final GeneratedFile genFile = getTargetFile(artifactName, filename, templateName);
if (genFile.isSkip()) {
LOG.debug("Omitted already existing file: {} [{}]", genFile, templateName);
} else {
LOG.debug("Start merging velocity template: {} [{}]", genFile, templateName);
// Merge content
try {
final Writer writer = new FileWriter(genFile.getTmpFile());
try {
final Template template = ve.getTemplate(templateName);
template.merge(context, writer);
} finally {
writer.close();
}
genFile.persist();
} catch (final IOException ex) {
throw new GenerateException("Error merging template '" + templateName + "' to '" + filename + "'!", ex);
}
}
}
|
java
|
{
"resource": ""
}
|
q179788
|
ParameterizedTemplateParserConfig.getModelDir
|
test
|
public final File getModelDir() {
if ((modelDir == null) && (modelPath != null)) {
modelDir = Utils4J.getCanonicalFile(new File(modelPath));
}
return modelDir;
}
|
java
|
{
"resource": ""
}
|
q179789
|
ParameterizedTemplateParserConfig.getTemplateDir
|
test
|
public final File getTemplateDir() {
if ((templateDir == null) && (templatePath != null)) {
try {
templateDir = new File(templatePath).getCanonicalFile();
} catch (final IOException ex) {
throw new RuntimeException("Couldn't determine canonical template file: " + templatePath, ex);
}
}
return templateDir;
}
|
java
|
{
"resource": ""
}
|
q179790
|
XmlValueWriter.write
|
test
|
@Override
public void write(HttpServletResponse httpResponse, Object value) throws IOException {
final Document document = (Document) value;
document.serialize(new OutputStreamWriter(httpResponse.getOutputStream(), "UTF-8"));
}
|
java
|
{
"resource": ""
}
|
q179791
|
WebViewFactory.start
|
test
|
@Validate
public void start() {
QApplication.invokeLater(new Runnable() {
public void run() {
configureApplication();
m_logger.info("Creating a web ui...");
synchronized (WebViewFactory.this) {
m_browser = new WebWindow(m_url, WebViewFactory.this);
configureWindow(m_browser);
m_browser.show();
}
m_logger.info("Web UI created.");
}
});
}
|
java
|
{
"resource": ""
}
|
q179792
|
WebViewFactory.configureWindow
|
test
|
private void configureWindow(WebWindow web) {
if (m_fullscreen) {
// We need to store the previous width and height values
m_width = web.width();
m_height = web.height();
web.showFullScreen();
} else {
web.showNormal();
if (! m_resizable) {
web.setFixedSize(new QSize(m_width, m_height));
} else {
web.setBaseSize(new QSize(m_width, m_height));
}
web.resize(m_width, m_height);
}
if (! m_bar) {
web.menuBar().setVisible(false);
} else {
web.menuBar().setVisible(true);
if (m_icon != null) {
QIcon icon = new QIcon(m_icon);
web.setWindowIcon(icon);
}
web.setWindowTitle(m_appName);
}
if (! m_contextMenu) {
web.setContextMenuPolicy(ContextMenuPolicy.PreventContextMenu);
} else {
web.setContextMenuPolicy(ContextMenuPolicy.DefaultContextMenu);
}
}
|
java
|
{
"resource": ""
}
|
q179793
|
WebViewFactory.print
|
test
|
public void print(QWebView view) {
if (m_print) {
QPrinter printer = new QPrinter();
QPrintDialog printDialog = new QPrintDialog(printer, view);
if (printDialog.exec() == QDialog.DialogCode.Accepted.value()) {
// print ...
view.print(printer);
}
} else {
m_logger.warn("Print disabled");
}
}
|
java
|
{
"resource": ""
}
|
q179794
|
WebViewFactory.write
|
test
|
public static void write(InputStream in, OutputStream out)
throws IOException {
byte[] b = new byte[4096];
for (int n; (n = in.read(b)) != -1;) {
out.write(b, 0, n);
}
in.close();
out.close();
}
|
java
|
{
"resource": ""
}
|
q179795
|
ScopeProxyHandler.invoke
|
test
|
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
T instance = appFactory.getInstance(interfaceClass);
return method.invoke(instance, args);
}
|
java
|
{
"resource": ""
}
|
q179796
|
RequestContext.attach
|
test
|
public void attach(HttpServletRequest httpRequest, HttpServletResponse httpResponse) {
// takes care to not override request URL, locale and request path values if set by request pre-processor
if (requestURL == null) {
requestURL = httpRequest.getRequestURI();
}
if (locale == null) {
locale = httpRequest.getLocale();
}
if (requestPath == null) {
// request URI and context path cannot ever be null
requestPath = httpRequest.getRequestURI().substring(httpRequest.getContextPath().length());
}
this.httpRequest = httpRequest;
this.httpResponse = httpResponse;
this.attached = true;
}
|
java
|
{
"resource": ""
}
|
q179797
|
RequestContext.detach
|
test
|
public void detach() {
attached = false;
locale = null;
securityDomain = null;
cookies = null;
requestPath = null;
requestURL = null;
}
|
java
|
{
"resource": ""
}
|
q179798
|
RequestContext.getCookies
|
test
|
public Cookies getCookies() {
assertAttached();
if (cookies == null) {
cookies = new Cookies(httpRequest, httpResponse);
}
return cookies;
}
|
java
|
{
"resource": ""
}
|
q179799
|
RequestContext.dump
|
test
|
public void dump() {
if (!attached) {
return;
}
StringBuilder message = new StringBuilder();
message.append("Request context |");
message.append(httpRequest.getRequestURI());
message.append("|:");
message.append(System.lineSeparator());
message.append("\t- remote-address: ");
message.append(httpRequest.getRemoteHost());
message.append(System.lineSeparator());
message.append("\t- method: ");
message.append(httpRequest.getMethod());
message.append(System.lineSeparator());
message.append("\t- query-string: ");
if (httpRequest.getQueryString() != null) {
message.append(httpRequest.getQueryString());
}
Enumeration<String> headerNames = httpRequest.getHeaderNames();
while (headerNames.hasMoreElements()) {
message.append(System.lineSeparator());
String headerName = headerNames.nextElement();
message.append("\t- ");
message.append(headerName);
message.append(": ");
message.append(httpRequest.getHeader(headerName));
}
log.error(message.toString());
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.