_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.