_id
stringlengths 2
7
| title
stringlengths 3
140
| partition
stringclasses 3
values | text
stringlengths 73
34.1k
| language
stringclasses 1
value | meta_information
dict |
---|---|---|---|---|---|
q180900
|
UserRoster.createEntry
|
test
|
public void createEntry(String user, String name, String[] groups)
throws XMPPException {
if (!connection.isAuthenticated()) {
throw new IllegalStateException("Not logged in to server.");
}
if (connection.isAnonymous()) {
throw new IllegalStateException(
"Anonymous users can't have a roster.");
}
// Create and send roster entry creation packet.
Roster rosterPacket = new Roster();
rosterPacket.setType(IQ.Type.set);
rosterPacket.addItem(new JID(user), name, null, null,
Arrays.asList(groups));
// Wait up to a certain number of seconds for a reply from the server.
PacketCollector collector = connection
.createPacketCollector(new PacketIDFilter(rosterPacket.getID()));
connection.sendPacket(rosterPacket);
IQ response = (IQ) collector.nextResult(SmackConfiguration
.getPacketReplyTimeout());
collector.cancel();
if (response == null) {
throw new XMPPException("No response from the server.");
}
// If the server replied with an error, throw an exception.
else if (response.getType() == IQ.Type.error) {
throw new XMPPException(response.getError());
}
// Create a presence subscription packet and send.
Presence presencePacket = new Presence(Presence.Type.subscribe);
presencePacket.setTo(user);
connection.sendPacket(presencePacket);
}
|
java
|
{
"resource": ""
}
|
q180901
|
UserRoster.getEntries
|
test
|
public Collection<RosterEntry> getEntries() {
Set<RosterEntry> allEntries = new HashSet<RosterEntry>();
// Loop through all roster groups and add their entries to the answer
for (RosterGroup rosterGroup : getGroups()) {
allEntries.addAll(rosterGroup.getEntries());
}
// Add the roster unfiled entries to the answer
allEntries.addAll(unfiledEntries);
return Collections.unmodifiableCollection(allEntries);
}
|
java
|
{
"resource": ""
}
|
q180902
|
UserRoster.getPresenceResource
|
test
|
public Presence getPresenceResource(String userWithResource) {
String key = getPresenceMapKey(userWithResource);
String resource = StringUtils.parseResource(userWithResource);
Map<String, Presence> userPresences = presenceMap.get(key);
if (userPresences == null) {
Presence presence = new Presence(Presence.Type.unavailable);
presence.setFrom(userWithResource);
return presence;
} else {
Presence presence = userPresences.get(resource);
if (presence == null) {
presence = new Presence(Presence.Type.unavailable);
presence.setFrom(userWithResource);
return presence;
} else {
return presence;
}
}
}
|
java
|
{
"resource": ""
}
|
q180903
|
UserRoster.setOfflinePresences
|
test
|
private void setOfflinePresences() {
Presence packetUnavailable;
for (String user : presenceMap.keySet()) {
Map<String, Presence> resources = presenceMap.get(user);
if (resources != null) {
for (String resource : resources.keySet()) {
packetUnavailable = new Presence(Presence.Type.unavailable);
packetUnavailable.setFrom(user + "/" + resource);
presencePacketListener.processPacket(packetUnavailable);
}
}
}
}
|
java
|
{
"resource": ""
}
|
q180904
|
UserRoster.fireRosterChangedEvent
|
test
|
private void fireRosterChangedEvent(Collection<String> addedEntries,
Collection<String> updatedEntries, Collection<String> deletedEntries) {
for (RosterListener listener : rosterListeners) {
if (!addedEntries.isEmpty()) {
listener.entriesAdded(addedEntries);
}
if (!updatedEntries.isEmpty()) {
listener.entriesUpdated(updatedEntries);
}
if (!deletedEntries.isEmpty()) {
listener.entriesDeleted(deletedEntries);
}
}
}
|
java
|
{
"resource": ""
}
|
q180905
|
Authentication.setDigest
|
test
|
public void setDigest(String connectionID, String password) {
setDigest(StringUtils.hash(connectionID + password));
}
|
java
|
{
"resource": ""
}
|
q180906
|
InformationProvider.generateResource
|
test
|
@Override
public Optional<? extends ResourceModel> generateResource(ResourceModel resourceModel, Optional<EventModel> event) {
switch (resourceModel.getResourceID()) {
case BroadcasterAvailablePlaylists.RESOURCE_ID: return createBroadcasterAvailablePlaylists();
case BroadcasterPlaylist.RESOURCE_ID : return createBroadcasterPlaylist(resourceModel);
default: return MusicResourceGenerator.super.generateResource(resourceModel, event);
}
}
|
java
|
{
"resource": ""
}
|
q180907
|
PlayerRequest.createPlayerRequest
|
test
|
static PlayerRequest createPlayerRequest(Playlist playlist, boolean permanent, Identification player, Capabilities capabilities, Context context, Identifiable identifiable) {
return new PlayerRequest(null, playlist, permanent, player, capabilities, context, identifiable);
}
|
java
|
{
"resource": ""
}
|
q180908
|
LastEncountered.getTimePassed
|
test
|
@SuppressWarnings("unused")
public static Optional<Long> getTimePassed(EventModel eventModel) {
if (eventModel.getListResourceContainer().containsResourcesFromSource(ID)) {
return eventModel
.getListResourceContainer()
.provideResource(ID)
.stream()
.map(ResourceModel::getResource)
.filter(ob -> ob instanceof Long)
.map(ob -> (Long) ob)
.findAny();
} else {
return Optional.empty();
}
}
|
java
|
{
"resource": ""
}
|
q180909
|
PropertiesAssistant.registerUpdateListener
|
test
|
public void registerUpdateListener(Consumer<PropertiesAssistant> listener) {
if (listener != null)
listeners.add(new WeakReference<>(listener));
}
|
java
|
{
"resource": ""
}
|
q180910
|
PropertiesAssistant.initProperties
|
test
|
public void initProperties() {
propertiesPath = getContext().getFiles().getPropertiesLocation() + File.separator
+ getContext().getAddOns().getAddOn().getID() + ".properties";
this.propertiesFile = new File(propertiesPath);
if (!this.propertiesFile.exists()) try {
this.propertiesFile.createNewFile();
} catch (IOException e) {
error("Error while trying to create the new Properties file", e);
}
try {
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(this.propertiesFile),
"UTF8"));
try {
properties.load(in);
} catch (IOException e) {
error("unable to load the InputStream for the PropertiesFile",e);
}
} catch (FileNotFoundException | UnsupportedEncodingException e) {
error("Error while trying to read Properties-File", e);
}
if (defaultPropertiesPath != null && new File(defaultPropertiesPath).exists()) {
@SuppressWarnings("unchecked")
Enumeration<String> keys = (Enumeration<String>)properties.propertyNames();
if (!keys.hasMoreElements()) {
try {
createDefaultPropertyFile(defaultPropertiesPath);
} catch (IOException e) {
error("Error while trying to copy the Default-Properties File", e);
}
if (new File(defaultPropertiesPath).exists() && !writeToPropertiesFile(defaultPropertiesPath)) return;
reloadProperties();
}
}
}
|
java
|
{
"resource": ""
}
|
q180911
|
PropertiesAssistant.reloadProperties
|
test
|
private void reloadProperties() {
Properties temp = new Properties();
BufferedReader bufferedReader = null;
try {
File properties = new File(propertiesPath);
bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(properties), "UTF8"));
temp.load(bufferedReader);
this.properties = temp;
listeners.removeIf(weakReference -> weakReference.get() == null);
listeners.forEach(weakReference -> {
Consumer<PropertiesAssistant> consumer = weakReference.get();
if (consumer != null)
consumer.accept(this);
});
} catch (IOException e) {
error("Error while trying to load the Properties-File: "
+ propertiesPath, e);
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (IOException e) {
error("Unable to close input stream", e);
}
}
}
}
|
java
|
{
"resource": ""
}
|
q180912
|
PacketParserUtils.parseStreamError
|
test
|
public static StreamError parseStreamError(Element el) throws IOException,
XmlPullParserException {
String code = null;
Element condEl = (Element) el.elements().iterator().next();
if (condEl.getNamespace().getURI().equals(StreamError.NAMESPACE)) {
code = condEl.getName();
}
String text = condEl.elementText("text");
return new StreamError(code, text);
}
|
java
|
{
"resource": ""
}
|
q180913
|
PacketParserUtils.parseMechanisms
|
test
|
@SuppressWarnings("unchecked")
public static Collection<String> parseMechanisms(Element mechanismsEl)
throws Exception {
List<Element> mechanisms = mechanismsEl.elements("mechanism");
List<String> mechanismsStr = new LinkedList<String>();
for (Element mechanismEl : mechanisms) {
mechanismsStr.add(mechanismEl.getText());
}
return mechanismsStr;
}
|
java
|
{
"resource": ""
}
|
q180914
|
PacketParserUtils.parseCompressionMethods
|
test
|
@SuppressWarnings("unchecked")
public static Collection<String> parseCompressionMethods(
Element compressionEl) throws IOException, XmlPullParserException {
List<Element> methodsEls = compressionEl.elements("method");
List<String> methodsStr = new LinkedList<String>();
for (Element methodEl : methodsEls) {
methodsStr.add(methodEl.getText());
}
return methodsStr;
}
|
java
|
{
"resource": ""
}
|
q180915
|
PacketParserUtils.parsePacketExtension
|
test
|
public static PacketExtension parsePacketExtension(String elementName,
String namespace, XmlPullParser parser) throws Exception {
DefaultPacketExtension extension = new DefaultPacketExtension(
elementName, namespace);
boolean done = false;
while (!done) {
int eventType = parser.next();
if (eventType == XmlPullParser.START_TAG) {
String name = parser.getName();
// If an empty element, set the value with the empty string.
if (parser.isEmptyElementTag()) {
extension.setValue(name, "");
}
// Otherwise, get the the element text.
else {
eventType = parser.next();
if (eventType == XmlPullParser.TEXT) {
String value = parser.getText();
extension.setValue(name, value);
}
}
} else if (eventType == XmlPullParser.END_TAG) {
if (parser.getName().equals(elementName)) {
done = true;
}
}
}
return extension;
}
|
java
|
{
"resource": ""
}
|
q180916
|
PacketParserUtils.decode
|
test
|
private static Object decode(Class<?> type, String value) throws Exception {
if (type.getName().equals("java.lang.String")) {
return value;
}
if (type.getName().equals("boolean")) {
return Boolean.valueOf(value);
}
if (type.getName().equals("int")) {
return Integer.valueOf(value);
}
if (type.getName().equals("long")) {
return Long.valueOf(value);
}
if (type.getName().equals("float")) {
return Float.valueOf(value);
}
if (type.getName().equals("double")) {
return Double.valueOf(value);
}
if (type.getName().equals("java.lang.Class")) {
return Class.forName(value);
}
return null;
}
|
java
|
{
"resource": ""
}
|
q180917
|
StartMusicRequest.verify
|
test
|
public static boolean verify(EventModel eventModel, Capabilities capabilities, Identifiable player, List<Identifiable> activators) {
if (!eventModel.containsDescriptor(StartMusicRequest.ID))
return false;
if (!capabilities.handlesPlayRequestFromOutside()) {
if (activators.stream()
.noneMatch(identifiable -> identifiable.isOwner(eventModel.getSource())))
return false;
}
if (!PlaylistResource.getPlaylist(eventModel).map(playlist -> playlist.verify(capabilities)).orElse(true)) {
return false;
}
return SelectorResource.isTarget(eventModel, player)
.orElse(false);
}
|
java
|
{
"resource": ""
}
|
q180918
|
PlaybackStateResource.getPlaybackStateFromResource
|
test
|
public static Optional<PlaybackState> getPlaybackStateFromResource(ResourceModel x) {
if (!x.getResourceID().equals(ID))
return Optional.empty();
Object resource = x.getResource();
if (resource instanceof String) {
String state = (String) resource;
try {
return Optional.of(PlaybackState.valueOf(state));
} catch (IllegalArgumentException e) {
return Optional.empty();
}
} else {
return Optional.empty();
}
}
|
java
|
{
"resource": ""
}
|
q180919
|
ExternalComponentManager.getSecretKey
|
test
|
public String getSecretKey(String subdomain) {
// Find the proper secret key to connect as the subdomain.
String secretKey = secretKeys.get(subdomain);
if (secretKey == null) {
secretKey = defaultSecretKey;
}
return secretKey;
}
|
java
|
{
"resource": ""
}
|
q180920
|
ExternalComponentManager.isMultipleAllowed
|
test
|
public boolean isMultipleAllowed(String subdomain) {
Boolean allowed = allowMultiple.get(subdomain);
return allowed != null && allowed;
}
|
java
|
{
"resource": ""
}
|
q180921
|
AbstractReferenceMap.put
|
test
|
public V put(K key, V value) {
if (key == null) {
throw new NullPointerException("null keys not allowed");
}
if (value == null) {
throw new NullPointerException("null values not allowed");
}
purgeBeforeWrite();
return super.put(key, value);
}
|
java
|
{
"resource": ""
}
|
q180922
|
AbstractReferenceMap.keySet
|
test
|
public Set<K> keySet() {
if (keySet == null) {
keySet = new ReferenceKeySet<K, V>(this);
}
return keySet;
}
|
java
|
{
"resource": ""
}
|
q180923
|
AbstractReferenceMap.values
|
test
|
public Collection<V> values() {
if (values == null) {
values = new ReferenceValues<K, V>(this);
}
return values;
}
|
java
|
{
"resource": ""
}
|
q180924
|
AbstractReferenceMap.purge
|
test
|
protected void purge(Reference ref) {
// The hashCode of the reference is the hashCode of the
// mapping key, even if the reference refers to the
// mapping value...
int hash = ref.hashCode();
int index = hashIndex(hash, data.length);
HashEntry<K, V> previous = null;
HashEntry<K, V> entry = data[index];
while (entry != null) {
if (((ReferenceEntry<K, V>) entry).purge(ref)) {
if (previous == null) {
data[index] = entry.next;
} else {
previous.next = entry.next;
}
this.size--;
return;
}
previous = entry;
entry = entry.next;
}
}
|
java
|
{
"resource": ""
}
|
q180925
|
AbstractReferenceMap.getEntry
|
test
|
protected HashEntry<K, V> getEntry(Object key) {
if (key == null) {
return null;
} else {
return super.getEntry(key);
}
}
|
java
|
{
"resource": ""
}
|
q180926
|
AbstractReferenceMap.hashEntry
|
test
|
protected int hashEntry(Object key, Object value) {
return (key == null ? 0 : key.hashCode())
^ (value == null ? 0 : value.hashCode());
}
|
java
|
{
"resource": ""
}
|
q180927
|
AbstractReferenceMap.createEntry
|
test
|
public HashEntry<K, V> createEntry(HashEntry<K, V> next, int hashCode,
K key, V value) {
return new ReferenceEntry<K, V>(this, (ReferenceEntry<K, V>) next,
hashCode, key, value);
}
|
java
|
{
"resource": ""
}
|
q180928
|
PresenceConstant.controlEvents
|
test
|
@Override
public boolean controlEvents(EventModel eventModel) {
if (level.compareTo(PresenceIndicatorLevel.WEAK) >= 0) {
return present;
} else //noinspection SimplifiableIfStatement
if (level.compareTo(PresenceIndicatorLevel.WEAK) < 0 && mostVague.get()) {
return present;
} else {
return true;
}
}
|
java
|
{
"resource": ""
}
|
q180929
|
PresenceConstant.setPresence
|
test
|
public void setPresence(boolean present) {
if (this.present == present)
return;
this.present = present;
updateVague();
if (present) {
firePresence(true);
} else {
fireLeaving();
}
}
|
java
|
{
"resource": ""
}
|
q180930
|
PresenceConstant.updateVague
|
test
|
private void updateVague() {
generateResource(PresenceResource.ID)
.orElse(CompletableFuture.completedFuture(new ArrayList<>()))
.thenAccept(list -> mostVague.set(list.stream()
.map(Presence::importPresence)
.filter(Optional::isPresent)
.map(Optional::get)
.map(Presence::getLevel)
.noneMatch(level -> level.compareTo(getLevel()) > 0))
);
}
|
java
|
{
"resource": ""
}
|
q180931
|
Chat.deliver
|
test
|
void deliver(Message message) {
// Because the collector and listeners are expecting a thread ID with
// a specific value, set the thread ID on the message even though it
// probably never had one.
message.setThread(threadID);
for (MessageListener listener : listeners) {
listener.processMessage(this, message);
}
}
|
java
|
{
"resource": ""
}
|
q180932
|
Gen_RunScripts.generateScript
|
test
|
protected final ST generateScript(String clazz, HashMap<String, Boolean> targetMap){
ST ret = this.stg.getInstanceOf("generateExec");
ret.add("target", targetMap);
ret.add("applicationHome", this.applicationDir);
ret.add("runName", this.configuration.get(PROP_RUN_SCRIPT_NAME));
ret.add("class", clazz);
return ret;
}
|
java
|
{
"resource": ""
}
|
q180933
|
Gen_RunScripts.initOutputDir
|
test
|
protected final int initOutputDir(){
String parent = System.getProperty("user.dir");
String target = parent + File.separator + this.target;
File targetDir = new File(target);
File parentDir = targetDir.getParentFile();
if(targetDir.exists()){
//target dir exists, let's see if it is what we want it to be
if(!targetDir.isDirectory()){
System.err.println(this.getAppName() + ": target dir <" + target + "> exists but is not a directory, exiting");
return -1;
}
if(!targetDir.canWrite()){
System.err.println(this.getAppName() + ": target dir <" + target + "> exists but but cannot write into it, exiting");
return -1;
}
}
else{
//target dir does not exist, let's see if we can create it the way we need
if(!parentDir.isDirectory()){
System.err.println(this.getAppName() + ": target dir parent <" + parent + "> exists but is not a directory, exiting");
return -1;
}
if(!parentDir.canWrite()){
System.err.println(this.getAppName() + ": target dir parent <" + parent + "> exists but but cannot write into it, exiting");
return -1;
}
if(!targetDir.mkdir()){
System.err.println(this.getAppName() + ": could not create target dir <" + target + ">, exiting");
return -1;
}
}
this.outputDir = target;
return 0;
}
|
java
|
{
"resource": ""
}
|
q180934
|
Gen_RunScripts.loadProperties
|
test
|
protected final Properties loadProperties(String filename){
Properties ret = new Properties();
URL url = null;
File f = new File(filename.toString());
if(f.exists()){
try{
url = f.toURI().toURL();
}
catch(Exception ignore){}
}
else{
ClassLoader loader = Thread.currentThread().getContextClassLoader();
url = loader.getResource(filename);
if(url==null){
loader = Gen_RunScripts.class.getClassLoader();
url = loader.getResource(filename);
}
}
try{
ret.load(url.openStream());
}
catch (IOException e){
System.err.println(this.getAppName() + ": cannot load property file <" + filename + ">, IO exception\n--><" + e + ">");
}
catch (Exception e){
System.err.println(this.getAppName() + ": cannot load property file <" + filename + ">, general exception\n--><" + e + ">");
}
return ret;
}
|
java
|
{
"resource": ""
}
|
q180935
|
Gen_RunScripts.writeFile
|
test
|
protected final int writeFile(String fn, ST st){
try {
FileWriter fs = new FileWriter(fn);
BufferedWriter bw = new BufferedWriter(fs);
bw.write(st.render());
bw.close();
}
catch (IOException e) {
e.printStackTrace();
return -1;
}
return 0;
}
|
java
|
{
"resource": ""
}
|
q180936
|
ProgressResource.getProgress
|
test
|
public static Optional<Progress> getProgress(EventModel eventModel) {
if (eventModel.getListResourceContainer().containsResourcesFromSource(ID)) {
return eventModel
.getListResourceContainer()
.provideResource(ID)
.stream()
.findAny()
.flatMap(Progress::importResource);
} else {
return Optional.empty();
}
}
|
java
|
{
"resource": ""
}
|
q180937
|
SynchronizedCollection.decorate
|
test
|
public static <E> Collection<E> decorate(Collection<E> coll) {
return new SynchronizedCollection<E>(coll);
}
|
java
|
{
"resource": ""
}
|
q180938
|
ServiceResolver.discover
|
test
|
public static Collection<ServiceResolver> discover(InetAddress start, int count, int msTimeout) {
Collection<ServiceResolver> result = new ArrayList<ServiceResolver>();
Collection<InetAddress> hosts = IPv4Scanner.scanRange(start, count, msTimeout);
for (InetAddress host: hosts) {
ServiceResolver resolver = new ServiceResolver(host);
logger.info("resolving {} {}", host.getHostAddress(), host.getCanonicalHostName());
JSONResult config = resolver.getConfig();
if (config != null) {
result.add(resolver);
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q180939
|
ServiceResolver.getConfig
|
test
|
public JSONResult getConfig() {
if (attempts == 0) {
try {
resolve();
} catch(Exception e) {
// discard exception
}
}
if (config == null) {
logger.info("{} => no response", url);
return null;
}
logger.info("{} => {}", url, config.get("FireREST").getString());
return config;
}
|
java
|
{
"resource": ""
}
|
q180940
|
Context.getThreadPool
|
test
|
@Override
public org.intellimate.izou.sdk.specification.context.ThreadPool getThreadPool() {
return threadPool;
}
|
java
|
{
"resource": ""
}
|
q180941
|
StopMusic.createStopMusic
|
test
|
public static Optional<StopMusic> createStopMusic(Identification source, Identification target) {
if (target == null || target.equals(source))
return Optional.empty();
try {
StopMusic stopRequest = new StopMusic(source);
stopRequest.addResource(new SelectorResource(source, target));
return Optional.of(stopRequest);
} catch (IllegalArgumentException e) {
return Optional.empty();
}
}
|
java
|
{
"resource": ""
}
|
q180942
|
StopMusic.verify
|
test
|
public static boolean verify(EventModel eventModel, Identifiable player) {
if (!eventModel.containsDescriptor(StopMusic.ID))
return false;
return SelectorResource.isTarget(eventModel, player)
.orElse(true);
}
|
java
|
{
"resource": ""
}
|
q180943
|
DseSessionManager.getCluster
|
test
|
public DseCluster getCluster(String hostsAndPorts, String username, String password,
String authorizationId) {
return getCluster(
ClusterIdentifier.getInstance(hostsAndPorts, username, password, authorizationId));
}
|
java
|
{
"resource": ""
}
|
q180944
|
Connection.addConnectionListener
|
test
|
public void addConnectionListener(ConnectionListener connectionListener) {
if (connectionListener == null) {
return;
}
if (!connectionListeners.contains(connectionListener)) {
connectionListeners.add(connectionListener);
}
}
|
java
|
{
"resource": ""
}
|
q180945
|
Connection.addPacketListener
|
test
|
public void addPacketListener(PacketListener packetListener,
PacketFilter packetFilter) {
if (packetListener == null) {
throw new NullPointerException("Packet listener is null.");
}
ListenerWrapper wrapper = new ListenerWrapper(packetListener,
packetFilter);
recvListeners.put(packetListener, wrapper);
}
|
java
|
{
"resource": ""
}
|
q180946
|
Connection.addPacketSendingListener
|
test
|
public void addPacketSendingListener(PacketListener packetListener,
PacketFilter packetFilter) {
if (packetListener == null) {
throw new NullPointerException("Packet listener is null.");
}
ListenerWrapper wrapper = new ListenerWrapper(packetListener,
packetFilter);
sendListeners.put(packetListener, wrapper);
}
|
java
|
{
"resource": ""
}
|
q180947
|
Connection.firePacketSendingListeners
|
test
|
protected void firePacketSendingListeners(Packet packet) {
// Notify the listeners of the new sent packet
for (ListenerWrapper listenerWrapper : sendListeners.values()) {
listenerWrapper.notifyListener(packet);
}
}
|
java
|
{
"resource": ""
}
|
q180948
|
Connection.addPacketInterceptor
|
test
|
public void addPacketInterceptor(PacketInterceptor packetInterceptor,
PacketFilter packetFilter) {
if (packetInterceptor == null) {
throw new NullPointerException("Packet interceptor is null.");
}
interceptors.put(packetInterceptor, new InterceptorWrapper(
packetInterceptor, packetFilter));
}
|
java
|
{
"resource": ""
}
|
q180949
|
Connection.firePacketInterceptors
|
test
|
protected void firePacketInterceptors(Packet packet) {
if (packet != null) {
for (InterceptorWrapper interceptorWrapper : interceptors.values()) {
interceptorWrapper.notifyListener(packet);
}
}
}
|
java
|
{
"resource": ""
}
|
q180950
|
RequestUtils.toValue
|
test
|
public static Object toValue(String name, Object value) {
String[] parts = StringUtils.split(name, "@", 2);
String fieldName = null;
String fieldType = "String";
if (parts.length == 2) {
fieldType = parts[1];
fieldName = parts[0];
} else if (parts.length == 1) {
fieldName = parts[0];
} else {
throw new IllegalArgumentException("Invalid property name");
}
try {
int l = Array.getLength(value);
RequestParameterType<?> rpt = TYPES.get(fieldType);
if (rpt == null) {
rpt = TYPES.get(RequestParameterType.STRING);
}
if (!fieldName.endsWith("[]") && l == 1) {
return rpt.newInstance(Array.get(value, 0));
}
Class<?> componentType = rpt.getComponentType();
Object[] a = (Object[]) Array.newInstance(componentType, l);
for (int i = 0; i < l; i++) {
a[i] = rpt.newInstance(Array.get(value, i));
}
return a;
} catch (IllegalArgumentException e) {
RequestParameterType<?> rpt = TYPES.get(fieldType);
if (rpt == null) {
rpt = TYPES.get(RequestParameterType.STRING);
}
return rpt.newInstance(value);
}
}
|
java
|
{
"resource": ""
}
|
q180951
|
ExternalComponent.connectionLost
|
test
|
public void connectionLost() {
// Ensure that only one thread will try to reconnect.
synchronized (this) {
if (reconnecting) {
return;
}
reconnecting = true;
}
readerThread = null;
boolean isConnected = false;
if (!shutdown) {
// Notify the component that connection was lost so it needs to
// shutdown. The component is
// still registered in the local component manager but just not
// connected to the server
component.shutdown();
}
while (!isConnected && !shutdown) {
try {
connect(host, port, subdomain);
isConnected = true;
// It may be possible that while a new connection was being
// established the
// component was required to shutdown so in this case we need to
// close the new
// connection
if (shutdown) {
disconnect();
} else {
// Component is back again working so start it up again
start();
}
} catch (ComponentException e) {
manager.getLog().error(
"Error trying to reconnect with the server", e);
// Wait for 5 seconds until the next retry
try {
Thread.sleep(5000);
} catch (InterruptedException e1) {
// Do nothing
}
}
}
reconnecting = false;
}
|
java
|
{
"resource": ""
}
|
q180952
|
TransactionalBidiTreeMap.getCurrentThreadId
|
test
|
protected String getCurrentThreadId() {
String attach_id = (String)ThreadSession.getValue(getThreadSessionKey());
if (attach_id != null)
return attach_id;
Thread thread = Thread.currentThread();
return thread.toString() + "(" + thread.hashCode() + ")";
}
|
java
|
{
"resource": ""
}
|
q180953
|
TransactionalBidiTreeMap.validNode
|
test
|
private boolean validNode(final Node<K,V> node, final String thread_id) {
if (auto_commit || node == null)
return (node != null);
return !((node.is(Node.DELETED, thread_id)) ||
(node.is(Node.ADDED, null) && node.is(Node.NO_CHANGE, thread_id)));
}
|
java
|
{
"resource": ""
}
|
q180954
|
TransactionalBidiTreeMap.getKeyForValue
|
test
|
public K getKeyForValue(final Object value)
throws ClassCastException, NullPointerException {
return (K)doGet(value, VALUE);
}
|
java
|
{
"resource": ""
}
|
q180955
|
TransactionalBidiTreeMap.doGet
|
test
|
private Object doGet(final Object o, final int index) {
checkNonNullComparable(o, index);
Node<K,V> node = lookupValid(o, index, getCurrentThreadId());
return (node==null)
? null
: node.getData(oppositeIndex(index));
}
|
java
|
{
"resource": ""
}
|
q180956
|
TransactionalBidiTreeMap.lookupValid
|
test
|
private Node<K,V> lookupValid(final Object data, final int index, final String thread_id) {
return nextEqualValid(getFloorEqualNode(lookup(data, index), index), index, thread_id);
}
|
java
|
{
"resource": ""
}
|
q180957
|
TransactionalBidiTreeMap.lookup
|
test
|
private Node<K,V> lookup(final Object data, final int index) {
Node<K,V> rval = null;
Node<K,V> node = rootNode[index];
while (node != null) {
int cmp = compare(Node.NO_CHANGE, data, node.getStatus(), node.getData(index), index);
if (cmp == 0) {
rval = node;
break;
} else {
node = (cmp < 0)
? node.getLeft(index)
: node.getRight(index);
}
}
return rval;
}
|
java
|
{
"resource": ""
}
|
q180958
|
TransactionalBidiTreeMap.compare
|
test
|
private int compare(final int o1_status, final Object o1, final int o2_status, final Object o2, final int index) {
if (comparators[index]==null) {
if (o1 instanceof TransactionalComparable)
return ((TransactionalComparable)o1).compareTo(o1_status, o2, o2_status);
else
return ((Comparable)o1).compareTo(o2);
} else {
return comparators[index].compare(o1, o2);
}
}
|
java
|
{
"resource": ""
}
|
q180959
|
TransactionalBidiTreeMap.leastNode
|
test
|
private Node<K,V> leastNode(final Node<K,V> node, final int index) {
Node<K,V> lval = node;
if (lval != null) {
while (lval.getLeft(index) != null) {
lval = lval.getLeft(index);
}
}
return lval;
}
|
java
|
{
"resource": ""
}
|
q180960
|
TransactionalBidiTreeMap.mostNode
|
test
|
private Node<K,V> mostNode(final Node<K,V> node, final int index) {
Node<K,V> rval = node;
if (rval != null) {
while (rval.getRight(index) != null) {
rval = rval.getRight(index);
}
}
return rval;
}
|
java
|
{
"resource": ""
}
|
q180961
|
TransactionalBidiTreeMap.nextGreater
|
test
|
private Node<K,V> nextGreater(final Node<K,V> node, final int index) {
Node<K,V> rval;
if (node == null) {
rval = null;
} else if (node.getRight(index) != null) {
// everything to the node's right is larger. The least of
// the right node's descendants is the next larger node
rval = leastNode(node.getRight(index), index);
} else {
// traverse up our ancestry until we find an ancestor that
// is null or one whose left child is our ancestor. If we
// find a null, then this node IS the largest node in the
// tree, and there is no greater node. Otherwise, we are
// the largest node in the subtree on that ancestor's left
// ... and that ancestor is the next greatest node
Node<K,V> parent = node.getParent(index);
Node<K,V> child = node;
while ((parent != null) && (child == parent.getRight(index))) {
child = parent;
parent = parent.getParent(index);
}
rval = parent;
}
return rval;
}
|
java
|
{
"resource": ""
}
|
q180962
|
TransactionalBidiTreeMap.mostValidNode
|
test
|
private Node<K,V> mostValidNode(final Node<K,V> node, final int index, final String thread_id) {
Node<K,V> rval = node;
while (rval != null && !validNode(rval, thread_id)) {
rval = nextGreater(rval, index);
}
return rval;
}
|
java
|
{
"resource": ""
}
|
q180963
|
TransactionalBidiTreeMap.leastValidNode
|
test
|
private Node<K,V> leastValidNode(final Node<K,V> node, final int index, final String thread_id) {
Node<K,V> lval = node;
while (lval != null && !validNode(lval, thread_id)) {
lval = nextSmaller(lval, index);
}
return lval;
}
|
java
|
{
"resource": ""
}
|
q180964
|
TransactionalBidiTreeMap.copyColor
|
test
|
private static <K,V> void copyColor(final Node<K,V> from, final Node<K,V> to,
final int index) {
if (to != null) {
if (from == null) {
// by default, make it black
to.setBlack(index);
} else {
to.copyColor(from, index);
}
}
}
|
java
|
{
"resource": ""
}
|
q180965
|
TransactionalBidiTreeMap.isRed
|
test
|
private static <K,V> boolean isRed(final Node<K,V> node, final int index) {
return ((node == null)
? false
: node.isRed(index));
}
|
java
|
{
"resource": ""
}
|
q180966
|
TransactionalBidiTreeMap.isBlack
|
test
|
private static <K,V> boolean isBlack(final Node<K,V> node, final int index) {
return ((node == null)
? true
: node.isBlack(index));
}
|
java
|
{
"resource": ""
}
|
q180967
|
TransactionalBidiTreeMap.getGrandParent
|
test
|
private static <K,V> Node<K,V> getGrandParent(final Node<K,V> node, final int index) {
return getParent(getParent(node, index), index);
}
|
java
|
{
"resource": ""
}
|
q180968
|
TransactionalBidiTreeMap.getParent
|
test
|
private static <K,V> Node<K,V> getParent(final Node<K,V> node, final int index) {
return ((node == null)
? null
: node.getParent(index));
}
|
java
|
{
"resource": ""
}
|
q180969
|
TransactionalBidiTreeMap.getRightChild
|
test
|
private static <K,V> Node<K,V> getRightChild(final Node<K,V> node, final int index) {
return (node == null)
? null
: node.getRight(index);
}
|
java
|
{
"resource": ""
}
|
q180970
|
TransactionalBidiTreeMap.getLeftChild
|
test
|
private static <K,V> Node<K,V> getLeftChild(final Node<K,V> node, final int index) {
return (node == null)
? null
: node.getLeft(index);
}
|
java
|
{
"resource": ""
}
|
q180971
|
TransactionalBidiTreeMap.rotateLeft
|
test
|
private void rotateLeft(final Node<K,V> node, final int index) {
Node<K,V> rightChild = node.getRight(index);
node.setRight(rightChild.getLeft(index), index);
if (rightChild.getLeft(index) != null) {
rightChild.getLeft(index).setParent(node, index);
}
rightChild.setParent(node.getParent(index), index);
if (node.getParent(index) == null) {
// node was the root ... now its right child is the root
rootNode[index] = rightChild;
} else if (node.getParent(index).getLeft(index) == node) {
node.getParent(index).setLeft(rightChild, index);
} else {
node.getParent(index).setRight(rightChild, index);
}
rightChild.setLeft(node, index);
node.setParent(rightChild, index);
}
|
java
|
{
"resource": ""
}
|
q180972
|
TransactionalBidiTreeMap.rotateRight
|
test
|
private void rotateRight(final Node<K,V> node, final int index) {
Node<K,V> leftChild = node.getLeft(index);
node.setLeft(leftChild.getRight(index), index);
if (leftChild.getRight(index) != null) {
leftChild.getRight(index).setParent(node, index);
}
leftChild.setParent(node.getParent(index), index);
if (node.getParent(index) == null) {
// node was the root ... now its left child is the root
rootNode[index] = leftChild;
} else if (node.getParent(index).getRight(index) == node) {
node.getParent(index).setRight(leftChild, index);
} else {
node.getParent(index).setLeft(leftChild, index);
}
leftChild.setRight(node, index);
node.setParent(leftChild, index);
}
|
java
|
{
"resource": ""
}
|
q180973
|
TransactionalBidiTreeMap.doRedBlackInsert
|
test
|
private void doRedBlackInsert(final Node<K,V> insertedNode, final int index) {
Node<K,V> currentNode = insertedNode;
makeRed(currentNode, index);
while ((currentNode != null) && (currentNode != rootNode[index])
&& (isRed(currentNode.getParent(index), index))) {
if (isLeftChild(getParent(currentNode, index), index)) {
Node<K,V> y = getRightChild(getGrandParent(currentNode, index),
index);
if (isRed(y, index)) {
makeBlack(getParent(currentNode, index), index);
makeBlack(y, index);
makeRed(getGrandParent(currentNode, index), index);
currentNode = getGrandParent(currentNode, index);
} else {
if (isRightChild(currentNode, index)) {
currentNode = getParent(currentNode, index);
rotateLeft(currentNode, index);
}
makeBlack(getParent(currentNode, index), index);
makeRed(getGrandParent(currentNode, index), index);
if (getGrandParent(currentNode, index) != null) {
rotateRight(getGrandParent(currentNode, index),
index);
}
}
} else {
// just like clause above, except swap left for right
Node<K,V> y = getLeftChild(getGrandParent(currentNode, index),
index);
if (isRed(y, index)) {
makeBlack(getParent(currentNode, index), index);
makeBlack(y, index);
makeRed(getGrandParent(currentNode, index), index);
currentNode = getGrandParent(currentNode, index);
} else {
if (isLeftChild(currentNode, index)) {
currentNode = getParent(currentNode, index);
rotateRight(currentNode, index);
}
makeBlack(getParent(currentNode, index), index);
makeRed(getGrandParent(currentNode, index), index);
if (getGrandParent(currentNode, index) != null) {
rotateLeft(getGrandParent(currentNode, index), index);
}
}
}
}
makeBlack(rootNode[index], index);
}
|
java
|
{
"resource": ""
}
|
q180974
|
TransactionalBidiTreeMap.doRedBlackDelete
|
test
|
private void doRedBlackDelete(final Node<K,V> deletedNode) {
for (int index = FIRST_INDEX; index < NUMBER_OF_INDICES; index++) {
// if deleted node has both left and children, swap with
// the next greater node
if ((deletedNode.getLeft(index) != null)
&& (deletedNode.getRight(index) != null)) {
swapPosition(nextGreater(deletedNode, index), deletedNode,
index);
}
Node<K,V> replacement = ((deletedNode.getLeft(index) != null)
? deletedNode.getLeft(index)
: deletedNode.getRight(index));
if (replacement != null) {
replacement.setParent(deletedNode.getParent(index), index);
if (deletedNode.getParent(index) == null) {
rootNode[index] = replacement;
} else if (deletedNode
== deletedNode.getParent(index).getLeft(index)) {
deletedNode.getParent(index).setLeft(replacement, index);
} else {
deletedNode.getParent(index).setRight(replacement, index);
}
deletedNode.setLeft(null, index);
deletedNode.setRight(null, index);
deletedNode.setParent(null, index);
if (isBlack(deletedNode, index)) {
doRedBlackDeleteFixup(replacement, index);
}
} else {
// replacement is null
if (deletedNode.getParent(index) == null) {
// empty tree
rootNode[index] = null;
} else {
// deleted node had no children
if (isBlack(deletedNode, index)) {
doRedBlackDeleteFixup(deletedNode, index);
}
if (deletedNode.getParent(index) != null) {
if (deletedNode
== deletedNode.getParent(index)
.getLeft(index)) {
deletedNode.getParent(index).setLeft(null, index);
} else {
deletedNode.getParent(index).setRight(null,
index);
}
deletedNode.setParent(null, index);
}
}
}
}
shrink();
}
|
java
|
{
"resource": ""
}
|
q180975
|
TransactionalBidiTreeMap.checkNonNullComparable
|
test
|
private void checkNonNullComparable(final Object o,
final int index) {
if (o == null) {
throw new NullPointerException(dataName[index]
+ " cannot be null");
}
if (comparators[index] == null && !(o instanceof Comparable)) {
throw new ClassCastException(dataName[index]
+ " must be Comparable");
}
}
|
java
|
{
"resource": ""
}
|
q180976
|
TransactionalBidiTreeMap.insertValue
|
test
|
private void insertValue(final Node<K,V> newNode, final String thread_id)
throws IllegalArgumentException {
Node<K,V> node = rootNode[VALUE];
while (true) {
int cmp = compare(Node.ADDED, newNode.getData(VALUE), node.getStatus(), node.getData(VALUE), VALUE);
if (cmp == 0)
{
if (nextEqualValid(getFloorEqualNode(node, VALUE), VALUE, thread_id) != null)
{
String debug_message = "Cannot store a duplicate value (\"" + newNode.getData(VALUE)
+ "\") in this Map. Value already exists for key " + node.getKey();
log.debug (debug_message);
throw new IllegalArgumentException(debug_message);
}
if (node.is(Node.ADDED, null))
throw new ConcurrentModificationException();
if (node.getRight(VALUE) != null) {
node = node.getRight(VALUE);
} else if (node.getLeft(VALUE) != null) {
node = node.getLeft(VALUE);
} else {
node.setRight(newNode, VALUE);
newNode.setParent(node, VALUE);
doRedBlackInsert(newNode, VALUE);
break;
}
}
else if (cmp < 0) {
if (node.getLeft(VALUE) != null) {
node = node.getLeft(VALUE);
} else {
node.setLeft(newNode, VALUE);
newNode.setParent(node, VALUE);
doRedBlackInsert(newNode, VALUE);
break;
}
} else { // cmp > 0
if (node.getRight(VALUE) != null) {
node = node.getRight(VALUE);
} else {
node.setRight(newNode, VALUE);
newNode.setParent(node, VALUE);
doRedBlackInsert(newNode, VALUE);
break;
}
}
}
}
|
java
|
{
"resource": ""
}
|
q180977
|
TransactionalBidiTreeMap.containsKey
|
test
|
@Override
public boolean containsKey(final Object key)
throws ClassCastException, NullPointerException {
checkKey(key);
return lookupValid(key, KEY, getCurrentThreadId()) != null;
}
|
java
|
{
"resource": ""
}
|
q180978
|
TransactionalBidiTreeMap.containsValue
|
test
|
@Override
public boolean containsValue(final Object value) {
checkValue(value);
return lookupValid(value, VALUE, getCurrentThreadId()) != null;
}
|
java
|
{
"resource": ""
}
|
q180979
|
TransactionalBidiTreeMap.get
|
test
|
@Override
public V get(final Object key)
throws ClassCastException, NullPointerException {
checkKey(key);
return (V)doGet(key, KEY);
}
|
java
|
{
"resource": ""
}
|
q180980
|
TransactionalBidiTreeMap.remove
|
test
|
@Override
public V remove(final Object key)
throws ConcurrentModificationException {
checkKey(key);
return (V)doRemove(key, KEY);
}
|
java
|
{
"resource": ""
}
|
q180981
|
TransactionalBidiTreeMap.clear
|
test
|
@Override
public void clear() {
if (auto_commit)
{
modify();
nodeCount = 0;
rootNode[KEY] = null;
rootNode[VALUE] = null;
}
else
{
String thread_id = getCurrentThreadId();
ArrayList<Entry<K,V>> list = new ArrayList<Entry<K,V>>(entrySet());
for (Iterator<Entry<K,V>> i = list.iterator(); i.hasNext(); ) {
Node<K,V> node = (Node<K,V>)i.next();
if (node.is(Node.ADDED, thread_id))
doRedBlackDelete(node);
else {
node.setStatus(Node.DELETED, thread_id);
}
}
}
}
|
java
|
{
"resource": ""
}
|
q180982
|
TransactionalBidiTreeMap.keySet
|
test
|
@Override
public Set<K> keySet() {
if (setOfKeysByKey == null) {
setOfKeysByKey = new AbstractFilterableSet<K>() {
@Override
public Iterator<K> iterator() {
return new TransactionalBidiTreeMapIterator<K>(KEY) {
@Override
protected K doGetNext() {
return (K)lastReturnedNode.getData(KEY);
}
};
}
@Override
public int size() {
return TransactionalBidiTreeMap.this.size();
}
@Override
public boolean contains(Object o) {
return containsKey(o);
}
@Override
public boolean remove(Object o) {
int oldNodeCount = nodeCount;
TransactionalBidiTreeMap.this.remove(o);
return nodeCount != oldNodeCount;
}
@Override
public void clear() {
TransactionalBidiTreeMap.this.clear();
}
};
}
return setOfKeysByKey;
}
|
java
|
{
"resource": ""
}
|
q180983
|
TransactionalBidiTreeMap.values
|
test
|
@Override
public Collection<V> values() {
if (collectionOfValuesByKey == null) {
collectionOfValuesByKey = new AbstractFilterableCollection<V>() {
@Override
public Iterator<V> iterator() {
return new TransactionalBidiTreeMapIterator<V>(KEY) {
@Override
protected V doGetNext() {
return (V)lastReturnedNode.getData(VALUE);
}
};
}
@Override
public int size() {
return TransactionalBidiTreeMap.this.size();
}
@Override
public boolean contains(Object o) {
return containsValue(o);
}
@Override
public boolean remove(Object o) {
int oldNodeCount = nodeCount;
removeValue(o);
return nodeCount != oldNodeCount;
}
@Override
public boolean removeAll(Collection<?> c) {
boolean modified = false;
Iterator<?> iter = c.iterator();
while (iter.hasNext()) {
if (removeValue(iter.next()) != null) {
modified = true;
}
}
return modified;
}
@Override
public void clear() {
TransactionalBidiTreeMap.this.clear();
}
};
}
return collectionOfValuesByKey;
}
|
java
|
{
"resource": ""
}
|
q180984
|
TransactionalBidiTreeMap.allEntrySet
|
test
|
public FilterableSet<Entry<K,V>> allEntrySet() {
if (setOfAllEntries == null) {
setOfAllEntries = new AbstractFilterableSet<Entry<K,V>>() {
@Override
public Iterator<Entry<K,V>> iterator() {
return new TransactionalBidiTreeMapIterator<Entry<K,V>>(KEY) {
@Override
protected Entry<K,V> doGetNext() {
return lastReturnedNode;
}
@Override
protected Node<K,V> getNextValidNode(Node<K,V> node, String thread_id) {
return node;
}
};
}
//cannot have contains or remove methods
//as we have ALL the nodes and so may have duplicates
//which are in the provess of being deleted
@Override
public boolean contains(Object o) {
throw new UtilsjException("method not supported");
}
@Override
public boolean remove(Object o) {
throw new UtilsjException("method not supported");
}
@Override
public int size() {
return TransactionalBidiTreeMap.this.size(true);
}
@Override
public void clear() {
TransactionalBidiTreeMap.this.clear();
}
};
}
return setOfAllEntries;
}
|
java
|
{
"resource": ""
}
|
q180985
|
TransactionalBidiTreeMap.copyEntries
|
test
|
public final void copyEntries(TransactionalBidiTreeMap<K,V> new_map)
{
K key;
V val;
int transaction_status;
String transaction_id;
new_map.setAutoCommit(isAutoCommit());
if (!isAutoCommit())
{
// Do committed and deleted first
for(Iterator<Entry<K,V>> i = allEntrySet().iterator(); i.hasNext(); ) {
TransactionalBidiTreeMap.Node<K,V> entry = (TransactionalBidiTreeMap.Node<K,V>)i.next();
key=entry.getKey();
val=entry.getValue();
transaction_status=entry.getStatus();
transaction_id=entry.getTransactionId();
if (transaction_status != TransactionalBidiTreeMap.Node.ADDED)
{
try
{
// Put the value against the key
new_map.put(key, val);
// As the transaction status is deleted or no change then we need to commit the entry now.
new_map.commit();
}
catch (Exception e) {} // Duplicate keys can be ignored, this means we already have the value
try
{
// If transaction status is deleted we need to now attach to the transaction id and remove.
if (transaction_status == TransactionalBidiTreeMap.Node.DELETED)
{
new_map.attach(transaction_id);
new_map.remove(key);
}
}
catch (Exception e) {} // The entry may have already been deleted
// Finally detach
new_map.detach();
}
}
// Then do added
for(Iterator<Entry<K,V>> i = allEntrySet().iterator(); i.hasNext(); ) {
TransactionalBidiTreeMap.Node<K,V> entry = (TransactionalBidiTreeMap.Node<K,V>)i.next();
key=entry.getKey();
val=entry.getValue();
transaction_status=entry.getStatus();
transaction_id=entry.getTransactionId();
if (transaction_status == TransactionalBidiTreeMap.Node.ADDED)
{
// As the transaction status is added then attach to the transaction id before putting.
new_map.attach(transaction_id);
try
{
// Put the value against the key
new_map.put(key, val);
}
catch (Exception e) {} // Duplicate keys can be ignored, this means we already have the value
// Finally detach
new_map.detach();
}
}
}
else
{
for(Iterator<Entry<K,V>> i = allEntrySet().iterator(); i.hasNext(); ) {
TransactionalBidiTreeMap.Node<K,V> entry = (TransactionalBidiTreeMap.Node<K,V>)i.next();
key=entry.getKey();
val=entry.getValue();
try
{
new_map.put(key, val);
}
catch (Exception e) {} // Duplicate keys can be ignored, this means we already have the value
}
}
}
|
java
|
{
"resource": ""
}
|
q180986
|
Cache.deleteExpiredEntries
|
test
|
protected synchronized void deleteExpiredEntries() {
// Check if expiration is turned on.
if (maxLifetime <= 0) {
return;
}
// Remove all old entries. To do this, we remove objects from the end
// of the linked list until they are no longer too old. We get to avoid
// any hash lookups or looking at any more objects than is strictly
// neccessary.
LinkedListNode node = ageList.getLast();
// If there are no entries in the age list, return.
if (node == null) {
return;
}
// Determine the expireTime, which is the moment in time that elements
// should expire from cache. Then, we can do an easy check to see
// if the expire time is greater than the expire time.
long expireTime = System.currentTimeMillis() - maxLifetime;
while (expireTime > node.timestamp) {
if (remove(node.object, true) == null) {
log.warn("Error attempting to remove(" + node.object.toString()
+ ") - cacheObject not found in cache!");
// remove from the ageList
node.remove();
}
// Get the next node.
node = ageList.getLast();
// If there are no more entries in the age list, return.
if (node == null) {
return;
}
}
}
|
java
|
{
"resource": ""
}
|
q180987
|
Cache.cullCache
|
test
|
protected synchronized void cullCache() {
// Check if a max cache size is defined.
if (maxCacheSize < 0) {
return;
}
// See if the cache is too big. If so, clean out cache until it's 10%
// free.
if (map.size() > maxCacheSize) {
// First, delete any old entries to see how much memory that frees.
deleteExpiredEntries();
// Next, delete the least recently used elements until 10% of the
// cache
// has been freed.
int desiredSize = (int) (maxCacheSize * .90);
for (int i = map.size(); i > desiredSize; i--) {
// Get the key and invoke the remove method on it.
if (remove(lastAccessedList.getLast().object, true) == null) {
log.warn("Error attempting to cullCache with remove("
+ lastAccessedList.getLast().object.toString()
+ ") - cacheObject not found in cache!");
lastAccessedList.getLast().remove();
}
}
}
}
|
java
|
{
"resource": ""
}
|
q180988
|
TrustedLoginTokenProxyPreProcessor.activate
|
test
|
protected void activate(Map<String, Object> props) {
// Get the properties from the console.
sharedSecret = toString(props.get("sharedSecret"),
"e2KS54H35j6vS5Z38nK40");
hostname = toString(props.get("hostname"), "localhost");
LOGGER.info(" Trusted hostname: " + hostname);
port = toInteger(props.get("port"), 80);
LOGGER.info("Trusted port: " + port);
}
|
java
|
{
"resource": ""
}
|
q180989
|
PlaylistSelector.getPlayerRequest
|
test
|
public Optional<PlayerRequest> getPlayerRequest(String playlistName, boolean permanent) {
return getPlaylist(playlistName)
.map(playlist -> PlayerRequest.createPlayerRequest(playlist, permanent, player, capabilities, context, identifiable));
}
|
java
|
{
"resource": ""
}
|
q180990
|
DefaultRosterStore.init
|
test
|
public static DefaultRosterStore init(final File baseDir) {
DefaultRosterStore store = new DefaultRosterStore(baseDir);
if (store.setRosterVersion("")) {
return store;
} else {
return null;
}
}
|
java
|
{
"resource": ""
}
|
q180991
|
DefaultRosterStore.open
|
test
|
public static DefaultRosterStore open(final File baseDir) {
DefaultRosterStore store = new DefaultRosterStore(baseDir);
String s = store.readFile(store.getVersionFile());
if (s != null && s.startsWith(STORE_ID + "\n")) {
return store;
} else {
return null;
}
}
|
java
|
{
"resource": ""
}
|
q180992
|
IPv4Scanner.scanRange
|
test
|
public static Collection<InetAddress> scanRange(InetAddress addr, int count, int msTimeout) {
Collection<InetAddress> addresses = new ArrayList<InetAddress>();
Collection<InetAddress> result = new ArrayList<InetAddress>();
if (addr == null) {
try {
addresses.addAll(localhostNetworkAddresses());
} catch (Exception e) {
throw new FireRESTException(e); // Should not happen
}
} else {
addresses.add(addr);
}
for (InetAddress a: addresses) {
if (a instanceof Inet4Address) {
InetAddress start = subnetAddress0(a, 24);
result.addAll(scanRangeCore(start, count, msTimeout));
}
}
return result;
}
|
java
|
{
"resource": ""
}
|
q180993
|
IPv4Scanner.subnetAddress0
|
test
|
public static InetAddress subnetAddress0(InetAddress addr, int subnetBits) {
if (subnetBits < 1 || 32 <= subnetBits) {
throw new FireRESTException("Expected subnetBits 1..31");
}
long mask = 1;
for (int i = 0; i < 32; i++) {
mask <<= 1;
mask |= i < subnetBits ? 1 : 0;
}
long host0 = asLongAddress(addr) & mask;
try {
return asInetAddress(host0);
} catch (UnknownHostException e) {
throw new FireRESTException(e);
}
}
|
java
|
{
"resource": ""
}
|
q180994
|
TrackInfo.export
|
test
|
public HashMap<String, Object> export() {
HashMap<String, Object> data = new HashMap<>();
data.put(nameDescriptor, name);
data.put(artistDescriptor, artist);
data.put(albumDescriptor, albumDescriptor);
data.put(albumCoverDescriptor, albumCover);
data.put(albumCoverFormatDescriptor, albumCoverFormatDescriptor);
data.put(dataDescriptor, this.data);
data.put(yearDescriptor, this.year);
data.put(genreDescriptor, this.genre);
data.put(durationDescriptor, this.duration);
data.put(bmpDescriptor, this.bmp);
return data;
}
|
java
|
{
"resource": ""
}
|
q180995
|
TrackInfo.importFromHashMap
|
test
|
public static Optional<TrackInfo> importFromHashMap(HashMap<String, Object> hashMap) {
try {
String name = (String) hashMap.get(nameDescriptor);
String album = (String) hashMap.get(albumDescriptor);
String artist = (String) hashMap.get(artistDescriptor);
byte[] albumCover = (byte[]) hashMap.get(albumCoverDescriptor);
String albumCoverFormat = (String) hashMap.get(albumCoverFormatDescriptor);
String data = (String) hashMap.get(dataDescriptor);
String year = (String) hashMap.get(yearDescriptor);
String genre = (String) hashMap.get(genreDescriptor);
long duration = (Long) hashMap.get(durationDescriptor);
String bmp = (String) hashMap.get(bmpDescriptor);
return Optional.of(new TrackInfo(name, artist, album, albumCover, albumCoverFormat, data, year, genre, bmp, duration));
} catch (ClassCastException e) {
return Optional.empty();
}
}
|
java
|
{
"resource": ""
}
|
q180996
|
ExecS.addAllApplications
|
test
|
protected final void addAllApplications(Set<Class<?>> set){
for(Class<?> cls:set){
if(!cls.isInterface() && !Modifier.isAbstract(cls.getModifiers())){
if(!this.classmap.containsValue(cls)){
this.classNames.add(cls.getName());
}
}
}
}
|
java
|
{
"resource": ""
}
|
q180997
|
ExecS.executeApplication
|
test
|
protected int executeApplication(Object svc, String[] args, String orig){
if(svc!=null && (svc instanceof ExecS_Application)){
if(svc instanceof Gen_RunScripts){
//hook for GenRunScripts to get current class map - registered applications
((Gen_RunScripts)svc).setClassMap(this.classmap);
}
if(svc instanceof Gen_ExecJarScripts){
//hook for Gen_ExecJarScripts to get current class map - registered applications
((Gen_ExecJarScripts)svc).setClassMap(this.classmap);
}
return ((ExecS_Application)svc).executeApplication(ArrayUtils.remove(args, 0));
}
else if(svc==null){
System.err.println("could not create object for class or application name <" + orig + ">");
return -1;
}
else if(!(svc instanceof ExecS_Application)){
System.err.println("given class or application name <" + orig + "> is not instance of " + ExecS_Application.class.getName());
return -2;
}
else{
System.err.println("unexpected error processing for class or application name <" + orig + ">");
return -3;
}
}
|
java
|
{
"resource": ""
}
|
q180998
|
ExecS.printList
|
test
|
protected final void printList(){
ST list = this.stg.getInstanceOf("list");
list.add("appName", this.appName);
if(this.classmap.size()>0){
List<Map<String, String>> l = new ArrayList<>();
for(String key : this.classmap.keySet()){
Map<String, String> m = new HashMap<>();
m.put("key", key);
m.put("val", this.classmap.get(key).getName());
l.add(m);
}
list.add("classMap", l);
}
list.add("className", this.classNames);
System.out.println(list.render());
}
|
java
|
{
"resource": ""
}
|
q180999
|
ExecS.printUsage
|
test
|
protected final void printUsage(){
ST usage = this.stg.getInstanceOf("usage");
usage.add("appName", this.appName);
usage.add("packageFilter", this.packageFilter);
usage.add("jarFilter", this.jarFilter);
usage.add("excludedNames", new TreeSet<>(Arrays.asList(new CF().excludedNames)));
System.out.println(usage.render());
}
|
java
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.