code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public RequestViewMetadata cloneInstance()
{
RequestViewMetadata rvm = new RequestViewMetadata();
rvm.initialProcessedClasses = new HashMap<Class<?>, Boolean>(
this.initialProcessedClasses != null ?
this.initialProcessedClasses : this.processedClasses);
if (this.initialAddedResources != null)
{
rvm.initialAddedResources = new HashMap<ResourceDependency, Boolean>(
this.initialAddedResources);
}
else if (this.addedResources != null)
{
rvm.initialAddedResources = new HashMap<ResourceDependency, Boolean>(
this.addedResources);
}
return rvm;
} | java |
public Object get(int accessor) {
try {
return getValue(accessor);
} catch (JMFException ex) {
FFDCFilter.processException(ex, "get", "134", this);
return null;
}
} | java |
@Trivial
private static final boolean containsAll(LinkedHashMap<ThreadContextProvider, ThreadContext> contextProviders, List<ThreadContextProvider> prereqs) {
for (ThreadContextProvider prereq : prereqs)
if (!contextProviders.containsKey(prereq))
return false;
return true;
} | java |
public static void notAvailable(String jeeName, String taskName) {
String message;
int modSepIndex = jeeName.indexOf('#');
if (modSepIndex == -1) {
message = Tr.formatMessage(tc, "CWWKC1011.app.unavailable", taskName, jeeName);
} else {
String application = jeeName.substring(0, modSepIndex);
int compSepIndex = jeeName.indexOf('#', modSepIndex + 1);
if (compSepIndex == -1) {
message = Tr.formatMessage(tc, "CWWKC1012.module.unavailable", taskName, jeeName.substring(modSepIndex + 1), application);
} else {
String module = jeeName.substring(modSepIndex + 1, compSepIndex);
message = Tr.formatMessage(tc, "CWWKC1013.component.unavailable", taskName, jeeName.substring(compSepIndex + 1), module, application);
}
}
throw new IllegalStateException(message);
} | java |
@Override
public @Sensitive byte[] serialize() throws IOException {
// Captured thread context
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int size = threadContext.size();
byte[][] contextBytes = new byte[size][];
for (int i = 0; i < size; i++) {
bout.reset();
ObjectOutputStream oout = new ObjectOutputStream(bout);
oout.writeObject(threadContext.get(i));
oout.flush();
contextBytes[i] = bout.toByteArray();
oout.close();
}
bout.reset();
ObjectOutputStream oout = new ObjectOutputStream(bout);
// Number of serialized fields (list of thread context counts as one)
oout.writeShort(3);
// 1) Bytes for captured thread context
oout.writeObject(contextBytes);
// 2) Metadata identifier
oout.writeObject(metaDataIdentifier);
// 3) Thread context provider names
oout.writeShort(providerNames.size());
for (String providerName : providerNames)
if (providerName.startsWith("com.ibm.ws.") && providerName.endsWith(".context.provider"))
oout.writeObject(providerName.substring(10, providerName.length() - 16));
else
oout.writeObject(providerName);
// Only add primitive or compatible Java types in the future. If necessary, pre-serialize to byte[]
oout.flush();
oout.close();
return bout.toByteArray();
} | java |
public boolean isActive()
{
FacesContext facesContext = FacesContext.getCurrentInstance();
if (facesContext != null)
{
return facesContext.getViewRoot() != null;
}
else
{
// No FacesContext means no view scope active.
return false;
}
} | java |
public String getSubscriberID()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getSubscriberID");
SibTr.exit(this, tc, "getSubscriberID", subscriptionID);
}
return subscriptionID;
} | java |
public String[] getTopics()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getTopics");
SibTr.exit(this, tc, "getTopics", topics);
}
return topics;
} | java |
public void removeTopic(String topic)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "removeTopic", topic);
SelectionCriteria[] tmp = selectionCriteriaList;
// Loop through the selectionCriteriaList
for (int i = 0; i < selectionCriteriaList.length; ++i)
{
if ((selectionCriteriaList[i].getDiscriminator() == null && topic == null) ||
(topic != null && selectionCriteriaList[i].getDiscriminator().equals(topic)))
{
// If there was only one criteria and we have removed it then
// nullify lists
if (selectionCriteriaList.length == 1)
{
selectionCriteriaList = null;
topics = null;
}
else
{
// The criteria match, so resize the array without this
// criteria in it.
tmp = new SelectionCriteria[selectionCriteriaList.length - 1];
System.arraycopy(selectionCriteriaList, 0, tmp, 0, i);
System.arraycopy(selectionCriteriaList, i + 1, tmp, i, selectionCriteriaList.length - i - 1);
selectionCriteriaList = tmp;
// And copy into the topics array so that they always match
this.topics = new String[selectionCriteriaList.length];
for (int t = 0; t < selectionCriteriaList.length; t++)
{
topics[t] = (selectionCriteriaList[t] == null) ? null : selectionCriteriaList[t].getDiscriminator();
}
}
break;
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "removeTopic");
} | java |
public void setTopicSpaceUuid(SIBUuid12 topicSpace)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setTopicSpaceUuid", topicSpace);
this.topicSpaceUuid = topicSpace;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setTopicSpaceUuid");
} | java |
public void setSubscriberID(String subscriptionID)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setSubscriberID", subscriptionID);
this.subscriptionID = subscriptionID;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setSubscriberID");
} | java |
public boolean isSIBServerSubject()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isSIBServerSubject");
SibTr.exit(this, tc, "isSIBServerSubject", Boolean.valueOf(isSIBServerSubject));
}
return isSIBServerSubject;
} | java |
protected boolean isDurable()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isDurable");
SibTr.exit(this, tc, "isDurable", Boolean.valueOf(durable));
}
return durable; // F001333-14610
} | java |
public void setDurable(boolean isDurable)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setDurable", Boolean.valueOf(isDurable));
durable = isDurable;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setDurable");
} | java |
public boolean equalUser(ConsumerDispatcherState subState)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "equalUser");
/* Check user */
boolean equal = equalUser(subState.getUser(), subState.isSIBServerSubject());
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "equalUser", Boolean.valueOf(equal));
return equal;
} | java |
public void setReady(boolean ready)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setReady", Boolean.valueOf(ready));
this.ready = ready;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setReady");
} | java |
public boolean isNoLocal()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isNoLocal");
SibTr.exit(this, tc, "isNoLocal", Boolean.valueOf(noLocal));
}
return noLocal;
} | java |
public void setNoLocal(boolean noLocal)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setNoLocal", Boolean.valueOf(noLocal));
this.noLocal = noLocal;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setNoLocal");
} | java |
public void setDurableHome(String val)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setDurableHome", val);
durableHome = val;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setDurableHome");
} | java |
public void setIsCloned(boolean isCloned)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setIsCloned", Boolean.valueOf(isCloned));
this.isCloned = isCloned;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setIsCloned");
} | java |
public void setTopicSpaceName(String name)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setTopicSpaceName", name);
topicSpaceName = name;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setTopicSpaceName");
} | java |
public String getTopicSpaceBusName()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getTopicSpaceBusName");
SibTr.exit(this, tc, "getTopicSpaceBusName", topicSpaceBusName);
}
return topicSpaceBusName;
} | java |
public void setTopicSpaceBusName(String busname)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setTopicSpaceBusName", busname);
topicSpaceBusName = busname;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setTopicSpaceBusName");
} | java |
public SIBUuid8 getRemoteMEUuid()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getRemoteMEUuid");
SibTr.exit(this, tc, "getRemoteMEUuid", remoteMEUuid);
}
return remoteMEUuid;
} | java |
public void setRemoteMEUuid(SIBUuid8 remoteMEUuid)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setRemoteMEUuid", remoteMEUuid);
this.remoteMEUuid = remoteMEUuid;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setRemoteMEUuid");
} | java |
public static boolean getXMLAsynchronousMethods(boolean[] asynchMethodFlags,
MethodInterface methodInterface,
String[] methodNames,
Class<?>[][] methodParamTypes,
EnterpriseBean wccmEnterpriseBean)
throws EJBConfigurationException {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
boolean asynchMethodFound = false; //d621123
if (isTraceOn && tc.isEntryEnabled()) {
Tr.entry(tc, "getXMLAsynchronousMethods", new Object[] {
asynchMethodFlags, wccmEnterpriseBean, methodInterface });
}
//iterate through the asynch-methodTypes in the deployment descriptor
// and match them with the methods defined in the ejbMethods array.
// then for each match, set the asynchMethodsFlags array at the same
// index to true. all others should be false (or left as they were...)
//first verify if all methods are set to asynch (i.e. if the asynch applies
// to the entire bean)
if (wccmEnterpriseBean.getKindValue() == EnterpriseBean.KIND_SESSION &&
//d599046 - check SERVICE_ENDPOINT
methodInterface != MethodInterface.SERVICE_ENDPOINT)
{
Session sb = (Session) wccmEnterpriseBean;
//F00743.9717
List<AsyncMethod> asynchMethods = sb.getAsyncMethods();
for (AsyncMethod am : asynchMethods) {
String methodName = am.getMethodName(); //d603858
if (methodName == null || "".equals(methodName.trim())) {
//error in ejb-jar.xml! method-name element is required
Tr.error(tc, "INVALID_ASYNC_METHOD_ELEMENT_MISSING_METHOD_NAME_CNTR0203E", sb.getName());
throw new EJBConfigurationException("Async method declared without a required method-name");
}
List<String> parms = am.getMethodParamList();
if ("*".equals(methodName) && parms != null) {
//error in ejb-jar.xml! cannot specify parms with wildcard method
Tr.error(tc, "INVALID_ASYNC_METHOD_ELEMENT_SPECIFIED_PARMS_WITH_WILDCARD_METHOD_CNTR0204E", sb.getName());
throw new EJBConfigurationException("Cannot specify parameters when specifying a wildcard method-name for async methods");
}
//style type 1 - unqualified wildcard:
if ("*".equals(methodName))
{
//in this case, all methods are asynchronous:
for (int i = 0; i < asynchMethodFlags.length; i++) {
asynchMethodFlags[i] = true;
}
asynchMethodFound = true; //d621123
//if this is the case, there is no need for further processing
if (isTraceOn && tc.isEntryEnabled()) {
Tr.exit(tc, "getXMLAsynchronousMethods - all methods are marked async");
}
return asynchMethodFound; //d621123
}
// if we are here, then methodName is not a wildcard - style type 2 (no parms) & 3 (parms)
//iterate over method array and check method name and parms (if specified):
for (int i = 0; i < methodNames.length; i++) {
if (methodNames[i] != null && methodNames[i].equals(methodName)) { //d599046 - null check
if (parms == null || DDUtil.methodParamsMatch(parms, methodParamTypes[i])) { // RTC100828
asynchMethodFlags[i] = true;
asynchMethodFound = true; //d621123
}
}
} // end for (int i=0; i<ejbMethods.length; i++)
} // end for (AsyncMethod am : asynchMethods)
if (isTraceOn && tc.isDebugEnabled()) {
for (int i = 0; i < methodNames.length; i++) {
Tr.debug(tc, methodNames[i] + Arrays.toString(methodParamTypes[i]) + " == " + //d599046 - null check
(asynchMethodFlags[i] ? "Asynchronous" : "Synchronous"));
}
}
} // end if (wccmEnterpriseBean.isSession())
else {
if (isTraceOn && tc.isDebugEnabled())
Tr.debug(tc, "Not a session bean");
}
if (isTraceOn && tc.isEntryEnabled()) {
Tr.exit(tc, "getXMLAsynchronousMethods");
}
return (asynchMethodFound); //d621123
} | java |
static Map<String, List<Method>> getBusinessMethodsByName(BeanMetaData bmd) {
Map<String, List<Method>> methodsByName = new HashMap<String, List<Method>>();
collectBusinessMethodsByName(methodsByName, bmd.methodInfos);
collectBusinessMethodsByName(methodsByName, bmd.localMethodInfos);
return methodsByName;
} | java |
static Method findMatchingMethod(Map<String, List<Method>> methodsByName, com.ibm.ws.javaee.dd.ejb.Method me) {
List<Method> methods = methodsByName.get(me.getMethodName());
if (methods == null) {
return null;
}
List<String> meParms = me.getMethodParamList();
if (meParms == null) {
return methods.get(0);
}
for (Method method : methods) {
if (DDUtil.methodParamsMatch(meParms, method.getParameterTypes())) {
return method;
}
}
return null;
} | java |
public static final boolean methodsEqual(Method remoteMethod, Method beanMethod)
{
if ((remoteMethod == null) || (beanMethod == null)) {
return false;
}
//----------------------
// Compare method names
//----------------------
if (!remoteMethod.getName().equals(beanMethod.getName())) {
return false;
}
//-------------------------
// Compare parameter types
//-------------------------
Class<?> remoteMethodParamTypes[] = remoteMethod.getParameterTypes();
Class<?> beanMethodParamTypes[] = beanMethod.getParameterTypes();
if (remoteMethodParamTypes.length != beanMethodParamTypes.length) {
return false;
}
for (int i = 0; i < remoteMethodParamTypes.length; i++) {
if (!remoteMethodParamTypes[i].equals(beanMethodParamTypes[i])) {
return false;
}
}
//-----------------------------------------------------------------
// If method names are equal and parameter types match then the
// methods are equal for our purposes. Java does not allow methods
// with the same name and parameter types that differ only in
// return type and/or exception signature.
//-----------------------------------------------------------------
return true;
} | java |
public static final boolean homeMethodEquals(Method homeMethod,
Properties beanMethodProps)
{
if ((homeMethod == null) || (beanMethodProps == null)) {
return false;
}
//----------------------
// Compare method names
//----------------------
String homeMethodName = homeMethod.getName();
String beanMethodName = (String) beanMethodProps.get("Name");
if (!homeMethodName.equals(beanMethodName)) {
return false;
}
//-------------------------
// Compare parameter types
//-------------------------
Class<?> homeMethodParamTypes[] = homeMethod.getParameterTypes();
String beanMethodParamTypes[] =
(String[]) beanMethodProps.get("ArgumentTypes");
if (homeMethodParamTypes.length != beanMethodParamTypes.length) {
return false;
}
for (int i = 0; i < homeMethodParamTypes.length; i++) {
if (!homeMethodParamTypes[i].getName().equals(beanMethodParamTypes[i])) {
return false;
}
}
//-----------------------------------------------------------------
// If method names are equal and parameter types match then the
// methods are equal for our purposes. Java does not allow methods
// with the same name and parameter types that differ only in
// return type and/or exception signature.
//-----------------------------------------------------------------
return true;
} | java |
public static long timeUnitToMillis(long value,
TimeUnit unit,
boolean annotation,
BeanMetaData bmd) throws EJBConfigurationException {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled()) {
Tr.entry(tc, "timeUnitToMillis: " + value + unit);
}
// Initialize to input value in case current unit is already in
// javax.util.concurrent.TimeUnit.MILLISECONDS
long timeout = value;
if (timeout > 0) {
timeout = TimeUnit.MILLISECONDS.convert(value, unit);
if (timeout == Long.MAX_VALUE || timeout == Long.MIN_VALUE) {
Tr.error(tc, "STATEFUL_TIMEOUT_OVERFLOW_CNTR0309E",
new Object[] { bmd.getName(), bmd.getModuleMetaData().getName(),
bmd.getModuleMetaData().getApplicationMetaData().getName(),
value, unit });
throw new EJBConfigurationException("Conversion of stateful session timeout value of " +
value + " " + unit + " to milliseconds resulted in overflow.");
}
}
else {
if (timeout == 0) {
// 0 means no wait, represented internally as the nominal 1 millisecond
timeout = 1;
}
else if (timeout == -1) {
// -1 indicates wait forever, represented internally as 0
timeout = 0L;
}
else {
// invalid (negative) timeout value
Object[] parms = new Object[] { bmd.getName(), bmd.getModuleMetaData().getName(), bmd.getModuleMetaData().getApplicationMetaData().getName(), timeout };
if (annotation) {
Tr.error(tc, "NEGATIVE_STATEFUL_TIMEOUT_ANN_CNTR0311E", parms);
}
else {
Tr.error(tc, "NEGATIVE_STATEFUL_TIMEOUT_XML_CNTR0312E", parms);
}
throw new EJBConfigurationException("Stateful session timeout value of " +
value + " " + unit + " is negative.");
}
}
if (isTraceOn && tc.isEntryEnabled()) {
Tr.exit(tc, "timeUnitToMillis: " + timeout);
}
return timeout;
} | java |
protected UserTransaction getUserTransaction(boolean injection, Object injectionContext) throws NamingException
{
final UserTransaction ut = AccessController.doPrivileged(new PrivilegedAction<UserTransaction>() {
@Override
public UserTransaction run() {
return userTranSvcRef.getBundle().getBundleContext().getService(userTranSvcRef);
}
});
final UserTransactionDecorator utd = getUserTransactionDecorator();
if (utd == null) {
return ut;
} else {
return utd.decorateUserTransaction(ut, injection, injectionContext);
}
} | java |
private <T, V> boolean addToMap(Map<Class<?>, Map<T, V>> proxyMap,
T f,
V proxy) {
Map<T, V> proxies = proxyMap.get(serviceClass);
if (proxies == null) {
proxies = new HashMap<T, V>();
proxyMap.put(serviceClass, proxies);
}
if (!proxies.containsKey(f)) {
proxies.put(f, proxy);
return true;
}
return false;
} | java |
public TrustManagerFactory getTrustManagerFactoryInstance(String trustMgr, String ctxtProvider) throws NoSuchAlgorithmException, NoSuchProviderException {
String mgr = trustMgr;
String provider = ctxtProvider;
if (mgr.indexOf('|') != -1) {
String[] trustManagerArray = mgr.split("\\|");
if (trustManagerArray != null && trustManagerArray.length == 2) {
mgr = trustManagerArray[0];
provider = trustManagerArray[1];
}
}
TrustManagerFactory rc = TrustManagerFactory.getInstance(mgr, provider);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getTrustManagerFactory.getInstance(" + mgr + ", " + provider + ")" + rc);
return rc;
} | java |
public KeyManagerFactory getKeyManagerFactoryInstance(String keyMgr, String ctxtProvider) throws NoSuchAlgorithmException, NoSuchProviderException {
String mgr = keyMgr;
String provider = ctxtProvider;
if (mgr.indexOf('|') != -1) {
String[] keyManagerArray = mgr.split("\\|");
if (keyManagerArray != null && keyManagerArray.length == 2) {
mgr = keyManagerArray[0];
provider = keyManagerArray[1];
}
}
KeyManagerFactory rc = KeyManagerFactory.getInstance(mgr, provider);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getKeyManagerFactory.getInstance(" + mgr + ", " + provider + ") " + rc);
return rc;
} | java |
public URLStreamHandler getHandler() throws Exception {
String handlerString = getSSLProtocolPackageHandler() + ".https.Handler";
URLStreamHandler streamHandler = null;
try {
ClassLoader cl = AccessController.doPrivileged(getCtxClassLoader);
if (cl != null) {
streamHandler = (URLStreamHandler) cl.loadClass(handlerString).newInstance();
} else {
streamHandler = (URLStreamHandler) Class.forName(handlerString).newInstance();
}
return streamHandler;
} catch (Exception e) {
FFDCFilter.processException(e, getClass().getName(), "getHandler", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception loading https stream handler.", new Object[] { e });
Tr.error(tc, "ssl.load.https.stream.handler.CWPKI0025E", new Object[] { handlerString, e.getMessage() });
throw e;
}
} | java |
private X509KeyManager loadCustomKeyManager(String kmClass) throws Exception {
X509KeyManager km = null;
try {
ClassLoader cl = AccessController.doPrivileged(getCtxClassLoader);
if (cl != null) {
try {
km = (X509KeyManager) cl.loadClass(kmClass).newInstance();
} catch (Exception e) {
// no ffdc needed
}
}
if (km == null) {
km = (X509KeyManager) Class.forName(kmClass).newInstance();
}
return km;
} catch (Exception e) {
FFDCFilter.processException(e, getClass().getName(), "loadCustomKeyManager", this);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception loading custom KeyManager.", new Object[] { e });
Tr.error(tc, "ssl.load.keymanager.error.CWPKI0021E", new Object[] { kmClass, e.getMessage() });
throw e;
}
} | java |
public static void clearSSLContextCache() {
if (sslContextCacheJAVAX != null && sslContextCacheJAVAX.size() > 0) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Clearing standard javax.net.ssl.SSLContext cache.");
sslContextCacheJAVAX.clear();
}
} | java |
public static void clearSSLContextCache(Collection<File> modifiedFiles) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Clearing standard javax.net.ssl.SSLContext cached object containing keystores: " + new Object[] { modifiedFiles });
for (File modifiedKeystoreFile : modifiedFiles) {
String filePath = null;
try {
filePath = modifiedKeystoreFile.getCanonicalPath();
} catch (IOException e) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "Exception comparing file path.");
continue;
}
removeEntryFromSSLContextMap(filePath);
}
} | java |
public static void removeEntryFromSSLContextMap(String keyStorePath) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "removeEntryFromSSLContextMap: " + new Object[] { keyStorePath });
List<SSLConfig> removeList = new ArrayList<SSLConfig>();
for (Entry<SSLConfig, SSLContext> entry : sslContextCacheJAVAX.entrySet()) {
SSLConfig cachedConfig = entry.getKey();
if (cachedConfig != null) {
String ksPropValue = cachedConfig.getProperty(Constants.SSLPROP_KEY_STORE, null);
boolean ksFileBased = Boolean.parseBoolean(cachedConfig.getProperty(Constants.SSLPROP_KEY_STORE_FILE_BASED));
String tsPropValue = cachedConfig.getProperty(Constants.SSLPROP_TRUST_STORE, null);
boolean tsFileBased = Boolean.parseBoolean(cachedConfig.getProperty(Constants.SSLPROP_TRUST_STORE_FILE_BASED));
if ((ksPropValue != null && keyStorePath.equals(WSKeyStore.getCannonicalPath(ksPropValue, ksFileBased))) ||
(tsPropValue != null && keyStorePath.equals(WSKeyStore.getCannonicalPath(tsPropValue, tsFileBased)))) {
removeList.add(cachedConfig);
}
}
}
if (!removeList.isEmpty()) {
for (SSLConfig removeEntry : removeList) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "removing from sslContext cache: " + removeEntry.toString());
sslContextCacheJAVAX.remove(removeEntry);
}
}
} | java |
public synchronized Entry next()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "next");
// can only do anything if the cursor is still pointing in to a list
checkEntryParent();
Entry nextEntry = null;
synchronized(parentList)
{
//get the next entry in the list
nextEntry = getNextEntry();
//if the next entry is null
if(nextEntry == null)
{
//then hopefully we're at the end of the list
if(current == parentList.last)
{
//so move the cursor to the bottom of the list,
//not pointing to any actual entry
moveToBottom();
}
else if(!atBottom)
{
//it should not be possible for the next entry to be null but the current
//not be the last one in the list or already at the bottom
SIErrorException e = new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0001",
new Object[] { "Cursor", "1:160:1.15" },
null));
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.utils.linkedlist.Cursor.next",
"1:166:1.15",
this);
SibTr.exception(tc, e);
if (tc.isEntryEnabled())
SibTr.exit(tc, "next", e);
throw e;
}
}
else
{
//move the cursor to the next entry
moveCursor(nextEntry);
}
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "next", nextEntry);
return nextEntry;
} | java |
public synchronized Entry previous()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "previous");
// can only do anything if the cursor is still pointing in to a list
checkEntryParent();
Entry previousEntry = null;
synchronized(parentList)
{
//get the previous entry
previousEntry = getPreviousEntry();
//if it is null
if(previousEntry == null)
{
//then hopefully we are at the top of the list
if(current == parentList.first)
{
//so move the cursor to the top
moveToTop();
}
else if(!atTop)
{
//it should not be possible for the previous entry to be null but the current
//not be the first one in the list or already at the top
SIErrorException e = new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.utils.linkedlist.Cursor",
"1:228:1.15" },
null));
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.utils.linkedlist.Cursor.previous",
"1:234:1.15",
this);
SibTr.exception(tc, e);
if (tc.isEntryEnabled())
SibTr.exit(tc, "previous", e);
throw e;
}
}
else
{
//move the cursor to the previous entry
moveCursor(previousEntry);
}
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "previous", previousEntry);
return previousEntry;
} | java |
public synchronized Entry current()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "current");
checkEntryParent();
if (tc.isEntryEnabled())
SibTr.exit(tc, "current", current);
return current;
} | java |
public synchronized void moveToTop()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "moveToTop");
checkEntryParent();
//record the reference to the parent list because the call to forceRemove
//will nullify it.
LinkedList list = parentList;
synchronized(list)
{
//remove the cursor from it's current postion
forceRemove();
//reset the parent list reference
parentList = list;
//mark this cursor as being at the top
atTop = true;
//link this cursor to the first cursor in the list's list of cursors
//which are currently at the top
next = list.firstTopCursor;
//link the old first cursor to this one
if(next != null) next.previous = this;
//mark this one as the first cursor in the list
list.firstTopCursor = this;
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "moveToTop");
} | java |
public synchronized void moveToBottom()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "moveToBottom");
checkEntryParent();
//record the parent list
LinkedList list = parentList;
synchronized(list)
{
//remove the cursor from it current position
forceRemove();
//reset the parent list
parentList = list;
//mark it as at the bottom
atBottom = true;
//insert it in front of the old first bottom cursor
next = list.firstBottomCursor;
if(next != null) next.previous = this;
//mark this on as the first bottom cursor
list.firstBottomCursor = this;
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "moveToBottom");
} | java |
public synchronized void moveCursor(Entry newEntry)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "moveCursor", new Object[] { newEntry });
checkEntryParent();
//if the entry is the same as the current one
//then we don't need to bother doing anything
if(newEntry != current)
{
//make sure we can find the new entry in this list
if(newEntry != null && newEntry.parentList == parentList)
{
LinkedList list = parentList;
synchronized(list)
{
//remove the cursor from it's current postion
forceRemove();
//insert this cursor before the first on for the new entry
next = newEntry.firstCursor;
if(next != null) next.previous = this;
newEntry.firstCursor = this;
previous = null;
parentList = list;
current = newEntry;
}
}
else //if the new entry is not in this list, throw a runtime exception
{
SIErrorException e = new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.utils.linkedlist.Cursor",
"1:457:1.15" },
null));
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.utils.linkedlist.Cursor.moveCursor",
"1:463:1.15",
this);
SibTr.exception(tc, e);
if (tc.isEntryEnabled())
SibTr.exit(tc, "moveCursor", e);
throw e;
}
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "moveCursor");
} | java |
public synchronized void moveCursor(Cursor cursor)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "moveCursor", new Object[] { cursor });
checkEntryParent();
synchronized(parentList)
{
//make sure that the cursor is pointing to an entry in the same list
if(cursor != null && cursor.parentList == parentList)
{
//if we are already pointing to the same entry, we may not have to
//do anything
if(cursor.current != current)
{
if(cursor.atTop)
{
//if the new cursor is at the top, move this one to the top
moveToTop();
}
else if(cursor.atBottom)
{
//if the new cursor is at the bottom, move this one to the bottom
moveToBottom();
}
else
{
//otherwise just move this cursor to point to the same entry as the
//one pointed to by the given cursor
moveCursor(cursor.current);
}
}
else //it is possible that the current entries are both null if they are both
{ //at the top or bottom on the list
if(cursor.current == null)
{
if(cursor.atTop && atBottom)
{
//if the given cursor is at the top but we are at the bottom, move to the top
moveToTop();
}
else if(cursor.atBottom && atTop)
{
//if the given cursor is at the bottom but we are at the top, move to the bottom
moveToBottom();
}
}
}
}
else //if the new entry is not in this list, throw a runtime exception
{
SIErrorException e = new SIErrorException(
nls.getFormattedMessage(
"INTERNAL_MESSAGING_ERROR_CWSIP0002",
new Object[] {
"com.ibm.ws.sib.processor.utils.linkedlist.Cursor",
"1:541:1.15" },
null));
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.utils.linkedlist.Cursor.moveCursor",
"1:547:1.15",
this);
SibTr.exception(tc, e);
if (tc.isEntryEnabled())
SibTr.exit(tc, "moveCursor", e);
throw e;
}
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "moveCursor");
} | java |
Entry forceRemove()
{
Entry removedEntry = null;
checkEntryParent();
if(atTop)
{
//if we are at the top of the list and we are the first top cursor
if(parentList.firstTopCursor == this)
{
//set the first top cursor to be the next one in the list
parentList.firstTopCursor = (Cursor) next;
}
//mark us as not at the top
atTop = false;
}
else if(atBottom)
{
//if we are at the bottom of the list and we are the first bottom cursor
if(parentList.firstBottomCursor == this)
{
//set the first bottom cursor to be the next one in the list
parentList.firstBottomCursor = (Cursor) next;
}
//mark us as not at the bottom
atBottom = false;
}
else
{
//if we are pointing to an actual entry in the list
if(current.firstCursor == this)
{
//and we are the first cursor on that entry
//set the first cursor to be the next one in the list
current.firstCursor = (Cursor) next;
}
//set the current entry to null
current = null;
}
//actually remove this cursor from the list
removedEntry = super.forceRemove();
return removedEntry;
} | java |
public synchronized void finished()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "finished");
checkEntryParent();
synchronized(parentList)
{
//remove the cursor from the list
//this will set the parent list reference to null and make the
//cursor seubsequently unusable
forceRemove();
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "finished");
} | java |
@Override
public JsMessage getMessageIfAvailable()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getMessageIfAvailable");
//If message is not available in the message store do not throw exception
boolean throwExceptionIfNotAvailable = false;
JsMessage localMsg = getJSMessage(throwExceptionIfNotAvailable);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getMessageIfAvailable", localMsg);
return localMsg;
} | java |
@Override
public int getInMemoryDataSize()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getInMemoryDataSize");
JsMessage localMsg = getJSMessage(true);
int msgSize = localMsg.getInMemorySize();
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getInMemoryDataSize", Integer.valueOf(msgSize));
return msgSize;
} | java |
@Override
public Reliability getReliability()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getReliability");
if (msgReliability == null)
{
JsMessage localMsg = getJSMessage(true);
msgReliability = localMsg.getReliability();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getReliability", msgReliability);
return msgReliability;
} | java |
public void setReliability(Reliability reliability)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setReliability", reliability);
JsMessage localMsg = getJSMessage(true);
msgReliability = reliability;
localMsg.setReliability(msgReliability);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setReliability");
} | java |
@Override
public long getMaximumTimeInStore()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "getMaximumTimeInStore");
JsMessage localMsg = getJSMessage(true);
long timeToLive = localMsg.getTimeToLive().longValue();
long maxTime = NEVER_EXPIRES; // 180921
if (timeToLive > 0)
{
maxTime = timeToLive - getAggregateWaitTime();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "getMaximumTimeInStore", Long.valueOf(maxTime));
return maxTime;
} | java |
@Override
public SIBUuid12 getProducerConnectionUuid()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getProducerConnectionUuid");
}
if (producerConnectionUuid == null)
{
JsMessage localMsg = getJSMessage(true);
producerConnectionUuid = localMsg.getConnectionUuid();
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.exit(this, tc, "getProducerConnectionUuid", producerConnectionUuid);
}
return producerConnectionUuid;
} | java |
public void setProducerConnectionUuid(SIBUuid12 producerConnectionUuid)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setProducerConnectionUuid", producerConnectionUuid);
this.producerConnectionUuid = producerConnectionUuid;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setProducerConnectionUuid");
} | java |
@Override
public boolean isTransacted()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "isTransacted");
SibTr.exit(this, tc, "isTransacted", Boolean.valueOf(transacted));
}
return transacted;
} | java |
public void setMaxStorageStrategy(int requestedMaxStrategy)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this,
tc,
"setMaxStorageStrategy",
Integer.valueOf(requestedMaxStrategy));
maxStorageStrategy = requestedMaxStrategy;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setMaxStorageStrategy");
} | java |
public void setPriority(int newPriority)
{
JsMessage localMsg = getJSMessage(true);
msgPriority = newPriority;
localMsg.setPriority(newPriority);
} | java |
public void addPersistentRef()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "addPersistentRef");
// We have at least one durable reference so the message
// must maintain its level of persistence
maintainPersistence = 1;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "addPersistentRef");
} | java |
private void setOriginatingBus(String busName)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "setOriginatingBus", busName);
_busName = busName;
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "setOriginatingBus");
} | java |
public String getOriginatingBus()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "getOriginatingBus");
SibTr.exit(this, tc, "getOriginatingBus", _busName);
}
return _busName;
} | java |
public void forceCurrentMEArrivalTimeToJsMessage()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(this, tc, "forceCurrentMEArrivalTimeToJsMessage");
if (!arrivalTimeStored)
{
JsMessage localMsg = getJSMessage(true);
localMsg.setCurrentMEArrivalTimestamp(currentMEArrivalTimeStamp);
arrivalTimeStored = true;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(this, tc, "forceCurrentMEArrivalTimeToJsMessage");
} | java |
@Override
public void unlockMsg(long lockID, Transaction transaction, boolean incrementUnlock) throws MessageStoreException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "unlockMsg", new Object[] { Long.valueOf(lockID), transaction, Boolean.valueOf(incrementUnlock) });
if (failedInitInRestore)
{
initialiseNonPersistent(true);
}
if (incrementUnlock)
{
// If we do not wish to increment the count, there is no point checking
// against redelivery threshold
redeliveryCountReached = false;
try
{
if (PRE_UNLOCKED_1 != null)
{
PRE_UNLOCKED_1.messageEventOccurred(MessageEvents.PRE_UNLOCKED, this, transaction);
}
if (PRE_UNLOCKED_2 != null)
{
PRE_UNLOCKED_2.messageEventOccurred(MessageEvents.PRE_UNLOCKED, this, transaction);
}
} catch (SIException e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.impl.store.items.MessageItem.unlockMsg",
"1:2955:1.244.1.40",
this);
SibTr.exception(tc, e);
// Something went wrong so make sure we unlock the message
redeliveryCountReached = false;
}
}
// If the pre_unlocked callback redirected the message to the exc dest,
// then unlock the message.
if (!redeliveryCountReached)
{
unlock(lockID, transaction, incrementUnlock);
SIMPItemStream itemStream = (SIMPItemStream) getItemStream();
BaseDestinationHandler bdh = getDestinationHandler(false, itemStream);
// proceede if and only if the redeliverycount column exists
if (bdh.isRedeliveryCountPersisted() && bdh.getMessageProcessor().getMessageStore().isRedeliveryCountColumnAvailable()) {
int rdl_count = guessRedeliveredCount();
persistRedeliveredCount(rdl_count);
//updating the value in MFP.
if (msg != null)
msg.setRedeliveredCount(rdl_count);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "unlockMsg");
} | java |
public void setRegisterForPostEvents(boolean registerEvents)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
{
SibTr.entry(this, tc, "setRegisterForPostEvents", Boolean.valueOf(registerEvents));
SibTr.exit(this, tc, "setRegisterForPostEvents");
}
this.registerEvents = registerEvents;
} | java |
@Trivial
public void addAll(PriorityConverterMap convertersToAdd) {
for (PriorityConverter converter : convertersToAdd.converters.values()) {
_addConverter(converter);
}
} | java |
public PriorityConverter getConverter(Type type) {
PriorityConverter converter = converters.get(type);
return converter;
} | java |
public static Version stringToVersion(String str) {
if (str == null || str.isEmpty() || str.equals("0")) {
return Version.emptyVersion;
}
if (str.equals("1") || str.equals("1.0") || str.equals("1.0.0"))
return VERSION_1_0;
return new Version(str);
} | java |
public static final VersionRange stringToVersionRange(String str) {
if (str == null || str.isEmpty() || "0".equals(str))
return EMPTY_RANGE;
if ("[1,1.0.100)".equals(str) || "[1.0,1.0.100)".equals(str) || "[1.0.0,1.0.100)".equals(str))
return INITIAL_RANGE;
return new VersionRange(str);
} | java |
public void setAttribute(String name, String value) {
this.myAttrs.put(name.toLowerCase(), value);
} | java |
public String getServletURI(HttpServletRequest req) {
String uriName = req.getServletPath();
String pathInfo = req.getPathInfo();
if (pathInfo != null)
uriName = uriName.concat(pathInfo);
if (uriName == null || uriName.length() == 0)
uriName = "/";
uriName = WSUtil.resolveURI(uriName);
int sindex;
if ((sindex = uriName.indexOf(";")) != -1) {
uriName = uriName.substring(0, sindex);
}
//we need to ensure we are following the java EE spec and handle a colon in the uri
if (uriName.indexOf(":") >= 0) {
uriName = uriName.replaceAll(":", "%3A");
}
return uriName;
} | java |
void fireProgressEvent(int state, int progress, String message) {
try {
fireProgressEvent(state, progress, message, false);
} catch (InstallException e) {
}
} | java |
void fireProgressEvent(int state, int progress, String message, boolean allowCancel) throws InstallException {
log(Level.FINEST, message);
if (enableEvent) {
try {
eventManager.fireProgressEvent(state, progress, message);
} catch (CancelException ce) {
if (allowCancel)
throw ce;
else
log(Level.FINEST, "fireProgressEvent caught cancel exception: " + ce.getMessage());
} catch (Exception e) {
log(Level.FINEST, "fireProgressEvent caught exception: " + e.getMessage());
}
}
} | java |
void log(Level level, String msg, Exception e) {
if (e != null)
logger.log(level, msg, e);
} | java |
boolean isEmpty(Map<String, List<List<RepositoryResource>>> installResources) {
if (installResources == null)
return true;
for (List<List<RepositoryResource>> targetList : installResources.values()) {
for (List<RepositoryResource> mrList : targetList) {
if (!mrList.isEmpty())
return false;
}
}
return true;
} | java |
boolean isEmpty(List<List<RepositoryResource>> installResources) {
if (installResources == null)
return true;
for (List<RepositoryResource> mrList : installResources) {
if (!mrList.isEmpty())
return false;
}
return true;
} | java |
boolean containFeature(Map<String, ProvisioningFeatureDefinition> installedFeatures, String feature) {
if (installedFeatures.containsKey(feature))
return true;
for (ProvisioningFeatureDefinition pfd : installedFeatures.values()) {
String shortName = InstallUtils.getShortName(pfd);
if (shortName != null && shortName.equalsIgnoreCase(feature))
return true;
}
return false;
} | java |
Collection<String> getFeaturesToInstall(Collection<String> requiredFeatures, boolean download) {
Collection<String> featuresToInstall = new ArrayList<String>(requiredFeatures.size());
if (!requiredFeatures.isEmpty()) {
Map<String, ProvisioningFeatureDefinition> installedFeatures = product.getFeatureDefinitions();
for (String feature : requiredFeatures) {
if (download || !containFeature(installedFeatures, feature))
featuresToInstall.add(feature);
}
}
return featuresToInstall;
} | java |
boolean containScript(List<File> filesInstalled) {
for (File f : filesInstalled) {
String path = f.getAbsolutePath().toLowerCase();
if (path.contains("/bin/") || path.contains("\\bin\\")) {
return true;
}
}
return false;
} | java |
public static String getNameOfReferenceableItem(Object annotation) {
if (annotation == null) {
return "";
}
String name = "", ref = "";
if (annotation instanceof org.eclipse.microprofile.openapi.annotations.headers.Header) {
name = ((org.eclipse.microprofile.openapi.annotations.headers.Header) annotation).name();
ref = ((org.eclipse.microprofile.openapi.annotations.headers.Header) annotation).ref();
} else if (annotation instanceof ExampleObject) {
name = ((ExampleObject) annotation).name();
ref = ((ExampleObject) annotation).ref();
} else if (annotation instanceof org.eclipse.microprofile.openapi.annotations.links.Link) {
name = ((org.eclipse.microprofile.openapi.annotations.links.Link) annotation).name();
ref = ((org.eclipse.microprofile.openapi.annotations.links.Link) annotation).ref();
} else if (annotation instanceof Callback) {
name = ((Callback) annotation).name();
ref = ((Callback) annotation).ref();
}
if (StringUtils.isBlank(name)) {
if (StringUtils.isNotBlank(ref)) {
//If the item is a reference then use the simple name of reference as the name
int index = ref.lastIndexOf('/');
return index == -1 ? ref : ref.substring(index + 1);
}
}
return name;
} | java |
public int getExactSubsSize(String topicExpression)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getExactSubsSize", topicExpression);
int numSubs = 0;
// Test whether table is now empty
if(!_registeredExactConsumerMonitors.isEmpty())
{
if(_registeredExactConsumerMonitors.containsKey(topicExpression))
{
RegisteredCallbacks rMonitor =
(RegisteredCallbacks)_registeredExactConsumerMonitors.get(topicExpression);
// Get the list of matching consumers
ArrayList consumerList = rMonitor.getMatchingConsumers();
if(consumerList != null && !consumerList.isEmpty())
{
numSubs = consumerList.size();
}
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getExactSubsSize", new Integer(numSubs));
return numSubs;
} | java |
@FFDCIgnore(value = { Exception.class })
public void setSimpleDateFormat(String formatString) {
if (formatString == null) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Null format string provided; date format will not be changed");
}
return;
}
try {
simpleDateFormat = new SimpleDateFormat(formatString);
} catch (Exception e) {
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Exception caught setting date format: " + e.getMessage());
Tr.debug(tc, "Date format will not be changed");
}
}
} | java |
public void cleanUpMaybeDiscriminatorState() {
if (this.dp != null) {
Discriminator d;
Iterator<Discriminator> it = this.dp.getDiscriminators().iterator();
int i = 0;
while (it.hasNext()) {
d = it.next();
if (Discriminator.MAYBE == this.discStatus[i++]) {
d.cleanUpState(this);
}
}
}
} | java |
public void cleanUpAllDiscriminatorState() {
if (this.dp != null) {
Iterator<Discriminator> it = this.dp.getDiscriminators().iterator();
while (it.hasNext()) {
it.next().cleanUpState(this);
}
}
} | java |
public ContextualStorage getContextualStorage(BeanManager beanManager, String flowClientWindowId)
{
ContextualStorage contextualStorage = storageMap.get(flowClientWindowId);
if (contextualStorage == null)
{
synchronized (this)
{
contextualStorage = storageMap.get(flowClientWindowId);
if (contextualStorage == null)
{
contextualStorage = new ContextualStorage(beanManager, true, true);
storageMap.put(flowClientWindowId, contextualStorage);
}
}
}
return contextualStorage;
} | java |
@PreDestroy
public void destroyBeansOnPreDestroy()
{
Map<String, ContextualStorage> oldWindowContextStorages = forceNewStorage();
if (!oldWindowContextStorages.isEmpty())
{
FacesContext facesContext = FacesContext.getCurrentInstance();
ServletContext servletContext = null;
if (facesContext == null)
{
try
{
servletContext = applicationContextBean.getServletContext();
}
catch (Throwable e)
{
Logger.getLogger(FlowScopeBeanHolder.class.getName()).log(Level.WARNING,
"Cannot locate servletContext to create FacesContext on @PreDestroy flow scope beans. "
+ "The beans will be destroyed without active FacesContext instance.");
servletContext = null;
}
}
if (facesContext == null &&
servletContext != null)
{
try
{
ExternalContext externalContext = new StartupServletExternalContextImpl(servletContext, false);
ExceptionHandler exceptionHandler = new ExceptionHandlerImpl();
facesContext = new StartupFacesContextImpl(externalContext,
(ReleaseableExternalContext) externalContext, exceptionHandler, false);
for (ContextualStorage contextualStorage : oldWindowContextStorages.values())
{
FlowScopedContextImpl.destroyAllActive(contextualStorage);
}
}
finally
{
facesContext.release();
}
}
else
{
for (ContextualStorage contextualStorage : oldWindowContextStorages.values())
{
FlowScopedContextImpl.destroyAllActive(contextualStorage);
}
}
}
} | java |
private void printValueIntro(String text) {
if (text != null) {
ffdcLog.print(text);
ffdcLog.print(EQUALS);
}
} | java |
@Sensitive
public static String getCookieValue(Cookie[] cookies, String cookieName) {
if (cookies == null) {
return null;
}
String retVal = null;
for (int i = 0; i < cookies.length; ++i) {
if (cookieName.equalsIgnoreCase(cookies[i].getName())) {
retVal = cookies[i].getValue();
break;
}
}
return retVal;
} | java |
public static String[] getCookieValues(Cookie[] cookies, String cookieName) {
if (cookies == null) {
return null;
}
Vector<String> retValues = new Vector<String>();
for (int i = 0; i < cookies.length; ++i) {
if (cookieName.equalsIgnoreCase(cookies[i].getName())) {
retValues.add(cookies[i].getValue());
}
}
if (retValues.size() > 0) {
return retValues.toArray(new String[retValues.size()]);
} else {
return null;
}
} | java |
public static void addCookiesToResponse(List<Cookie> cookieList, HttpServletResponse resp) {
Iterator<Cookie> iterator = cookieList.listIterator();
while (iterator.hasNext()) {
Cookie cookie = iterator.next();
if (cookie != null) {
resp.addCookie(cookie);
}
}
} | java |
public void setLogHandler(String id, LogHandler ref) {
if (id != null && ref != null) {
logHandlerServices.put(id, ref);
}
} | java |
public synchronized void modified(Properties props) {
for (Object key : props.keySet()) {
String msgId = (String) key;
String logHandlerIds = props.getProperty(msgId);
Set<String> logHandlerIdSet = getOrCreateLogHandlerIdSet(msgId);
// "logHandlerIds" is a comma-separated list of LogHandlers IDs. Each LogHandler ID
// may contain a +/- char in front, to indicate that the LogHandler should be
// added/removed to/from the list for this msgId. If the +/- is not specified,
// assume +.
for (String id : split(logHandlerIds, ",")) {
// Protect against bad input, such as empty IDs.
id = id.trim();
if (id.length() > 0) {
// Check for the +/- in first char.
char plusOrMinus = id.charAt(0);
if (plusOrMinus != '+' && plusOrMinus != '-') {
plusOrMinus = '+'; // + by default.
} else {
id = id.substring(1); // skip over the +/-.
}
// Make sure there's still something left after stripping off the +/-.
if (id.length() > 0) {
if (plusOrMinus == '+') {
logHandlerIdSet.add(id);
} else {
// '-' means remove.
logHandlerIdSet.remove(id);
}
}
}
}
if (logHandlerIdSet.size() == 1 && logHandlerIdSet.contains("DEFAULT")) {
// No entries (other than default) for this msgId. Remove it from the map.
msgIdToLogHandlerIds.remove(msgId);
}
}
} | java |
protected void addMsgToLogHandler(String msgId, String handlerId) {
Set<String> logHandlerIdSet = getOrCreateLogHandlerIdSet(msgId);
logHandlerIdSet.add(handlerId);
} | java |
protected void removeMsgFromLogHandler(String msgId, String handlerId) {
Set<String> logHandlerIdSet = getOrCreateLogHandlerIdSet(msgId);
logHandlerIdSet.remove(handlerId);
} | java |
private String[] filter(String[] candidateCipherSuites, String[] requested, OptionsKey options) {
List<String> candidates = Arrays.asList(candidateCipherSuites);
EnumSet<Options> supports = toOptions(options.supports, true);
EnumSet<Options> requires = toOptions(options.requires, false);
List<String> result = new ArrayList<String>(requested.length);
for (String choice : requested) {
if (!matches(supports, requires, choice)) {
Tr.warning(tc, "CSIv2_COMMON_CIPHER_SUITE_MISMATCH", choice, getOptions(choice), supports, requires);
}
if (candidates.contains(choice)) {
result.add(choice);
}
}
return result.toArray(new String[result.size()]);
} | java |
protected void markStepForFailure() {
StopLock stopLock = getStopLock(); // Store in local variable to facilitate Ctrl+Shift+G search in Eclipse
synchronized (stopLock) {
updateStepBatchStatus(BatchStatus.FAILED);
if (!issuedFailureMessageToJobLog) {
stepThreadHelper.logFailedMessage();
issuedFailureMessageToJobLog = true;
}
}
} | java |
protected boolean wasStopIssuedOnJob() {
StopLock stopLock = getStopLock(); // Store in local variable to facilitate Ctrl+Shift+G search in Eclipse
synchronized (stopLock) {
if (runtimeWorkUnitExecution.getBatchStatus().equals(BatchStatus.STOPPING)) {
return true;
} else {
return false;
}
}
} | java |
protected StepThreadExecutionEntity createStepExecutionIfStepShouldBeExecuted() throws DoNotRestartStepThreadException {
StepThreadExecutionEntity newStepExecution = null;
StepThreadInstanceKey stepThreadInstanceKey = getStepThreadInstanceKey();
stepThreadInstance = getPersistenceManagerService().getStepThreadInstance(stepThreadInstanceKey);
// Note that for a partition thread, we're assuming we won't find a partition-level step thread instance
// in the case that the top-level step is restarting after completing (i.e. in the allow-start-if-complete="true" case).
// We assume that something at the top-level will remove these step thread instances so that we don't see them.
if (stepThreadInstance == null) {
logger.finer("No existing step instance found. Create new step execution and proceed to execution.");
newStepExecution = stepThreadHelper.createStepThreadInstanceAndFirstExecution(stepThreadInstanceKey, runtimeWorkUnitExecution.isRemotePartitionDispatch());
stepThreadInstance = getPersistenceManagerService().getStepThreadInstance(stepThreadInstanceKey);
if (stepThreadInstance == null) {
throw new IllegalStateException("Should have just created step thread instance.");
}
} else {
logger.finer("Existing step instance found.");
newStepExecution = stepThreadHelper.setupStepThreadExecutionForRestartIfNecessary(runtimeWorkUnitExecution.isRemotePartitionDispatch());
}
return newStepExecution;
} | java |
public Selector parseWholeSelector(String selector)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
tc.entry(
cclass,
"parseWholeSelector",
"selector: " + selector);
// Need to set the domain to XPATH1.0
Identifier ident = new IdentifierImpl(selector);
// Set the full name into the identifier. The full name is used in position assignment when
// determining uniqueness of names. Only a full name will do.
ident.setFullName(selector);
ident.setSelectorDomain(2);
// Call XPath to compile the XPath1.0 expression and store the
// resultant XPathExpression in the Identifier.
XPathExpression xpexp = null;
try
{
// Parse an expression up-front
XPath xpath0 = XPathFactory.newInstance().newXPath();
// If a namespace context has been set then set it into the XPath env
if(namespaceContext != null)
xpath0.setNamespaceContext(namespaceContext);
xpexp = xpath0.compile(selector);
}
catch (Exception ex)
{
// No FFDC Code Needed.
// FFDC driven by wrapper class.
// This signals that the XPath compiler encountered a problem
FFDC.processException(cclass,
"com.ibm.ws.sib.matchspace.selector.impl.XPath10ParserImpl",
ex,
"1:143:1.16");
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
tc.debug(this,cclass, "parseWholeSelector", ex);
// Set the identifier object to "invalid"
ident.setType(Selector.INVALID);
}
// Store xpexp in the Identifier
ident.setCompiledExpression(xpexp);
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
tc.exit(this,cclass, "parseWholeSelector", ident);
return ident;
} | java |
private void parseSelector(String selector) throws InvalidXPathSyntaxException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
tc.entry(cclass,
"parseSelector",
"selector: " + selector);
// Set the locationStep to -1
locationStep = -1;
int start = 0;
// find number of path separators
// Pre-check selector for multi-level wildcards. We can't handle these in
// the optimised code. Simply wrap the entire expression
int posWildCard = selector.indexOf("//", start);
if(posWildCard >= 0)
{
// We have a multi-level wildcard, process the whole thing
locationStep = 0;
selOperands.add(createIdentifierForWildExpression(selector));
return;
}
// Locate the first path separator
int posSeparator = selector.indexOf("/", start);
// Handle an initial separator character
if(posSeparator == 0)
{
// An initial slash
String step = selector.substring(start,start+1);
// Add an IdentifierImpl for the location step to the array list
selOperands.add(createIdentifierForSubExpression(step, step, true, false));
// Bump the start counter
start++;
}
// Now iterate over the rest of the selector string attempting to isolate
// Individual location path steps.
int stepEnd = 0;
while (stepEnd >= 0)
{
StepProperties stepProperties = new StepProperties();
// Drive the method that isolates the next step
isolateNextStep(selector,start, stepProperties);
stepEnd = stepProperties.endOfStep;
// Useful debug
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
{
if(stepEnd < 0)
{
tc.debug(this,
cclass,
"parsePredicate",
"isolated Step: " + selector.substring(start) +
" and wrapStep is " + stepProperties.wrapStep);
}
else
{
tc.debug(this,
cclass,
"parsePredicate",
"isolated Step: " + selector.substring(start,stepEnd) +
" and wrapStep is " + stepProperties.wrapStep);
}
}
// Should the entire location step be wrapped in an Identifier
if(stepProperties.wrapStep)
{
if(stepEnd <0)
{
// Wrap entire location step in an Identifier
wrapLastLocationStep(selector, start, true);
}
else
{
// Wrap intermediate location step in an Identifier
wrapLocationStep(selector, start,stepEnd);
}
}
else
{
// We can attempt to parse the step using the MatchParser
if(stepEnd <0)
{
// This is the final location step
parseLastLocationStep(selector, start);
}
else
{
// An intermediate location step
parseLocationStep(selector, start, stepEnd);
}
}
// Bump the start parameter and then look for next step
if(stepEnd >= 0)
start = stepEnd + 1;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
tc.exit(this,cclass, "parseSelector");
} | java |