/**
* Closes given {@link #transportManagers} of this <tt>Conference</tt> and removes corresponding
* channel bundle.
*/
void closeTransportManager(TransportManager transportManager) {
synchronized (transportManagers) {
for (Iterator<IceUdpTransportManager> i = transportManagers.values().iterator();
i.hasNext(); ) {
if (i.next() == transportManager) {
i.remove();
// Presumably, we have a single association for
// transportManager.
break;
}
}
// Close manager
try {
transportManager.close();
} catch (Throwable t) {
logger.warn(
"Failed to close an IceUdpTransportManager of" + " conference " + getID() + "!", t);
// The whole point of explicitly closing the
// transportManagers of this Conference is to prevent memory
// leaks. Hence, it does not make sense to possibly leave
// TransportManagers open because a TransportManager has
// failed to close.
if (t instanceof InterruptedException) Thread.currentThread().interrupt();
else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
}
}
}
static {
try {
Map<String, Method> orderedMethods = new TreeMap<String, Method>();
for (Method m : MBeanServerConnection.class.getDeclaredMethods()) {
orderedMethods.put(m.toGenericString(), m);
}
Method[] methods = orderedMethods.values().toArray(new Method[orderedMethods.size()]);
Map<String, Method> asynchMethods = new TreeMap<String, Method>();
for (Method asynchMethod : AsynchJMXResponseListener.class.getDeclaredMethods()) {
asynchMethods.put(asynchMethod.getName(), asynchMethod);
}
Map<Method, Byte> m2k = new HashMap<Method, Byte>(methods.length);
Map<Byte, Method> k2m = new HashMap<Byte, Method>(methods.length);
Map<Byte, Method> k2am = new HashMap<Byte, Method>(methods.length);
for (int i = 0; i < methods.length; i++) {
m2k.put(methods[i], (byte) i);
k2m.put((byte) i, methods[i]);
Method asynchMethod = asynchMethods.get(methods[i].getName() + "Response");
if (asynchMethod == null)
throw new RuntimeException(
"Failed to find asynch handler for [" + methods[i].toGenericString() + "]",
new Throwable());
k2am.put((byte) i, asynchMethod);
}
methodToKey = Collections.unmodifiableMap(m2k);
keyToMethod = Collections.unmodifiableMap(k2m);
keyToAsynchMethod = Collections.unmodifiableMap(k2am);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
public JavaType[] typesAsArray() {
if (_bindings == null) {
_resolve();
}
if (_bindings.size() == 0) {
return NO_TYPES;
}
return _bindings.values().toArray(new JavaType[_bindings.size()]);
}
void decode(final T o, final Entry e) throws LDAPPersistException {
if (superclassHandler != null) {
superclassHandler.decode(o, e);
}
setDNAndEntryFields(o, e);
final ArrayList<String> failureReasons = new ArrayList<String>(5);
boolean successful = true;
for (final FieldInfo i : fieldMap.values()) {
successful &= i.decode(o, e, failureReasons);
}
for (final SetterInfo i : setterMap.values()) {
successful &= i.invokeSetter(o, e, failureReasons);
}
Throwable cause = null;
if (postDecodeMethod != null) {
try {
postDecodeMethod.invoke(o);
} catch (final Throwable t) {
debugException(t);
if (t instanceof InvocationTargetException) {
cause = ((InvocationTargetException) t).getTargetException();
} else {
cause = t;
}
successful = false;
failureReasons.add(
ERR_OBJECT_HANDLER_ERROR_INVOKING_POST_DECODE_METHOD.get(
postDecodeMethod.getName(), type.getName(), getExceptionMessage(t)));
}
}
if (!successful) {
throw new LDAPPersistException(concatenateStrings(failureReasons), o, cause);
}
}
/**
* @param cls Component class.
* @param <T> Component type.
* @return Component class instance or {@code null} if no one plugin override this component.
*/
public <T> T createComponent(Class<T> cls) {
for (PluginProvider plugin : plugins.values()) {
PluginContext ctx = pluginContextForProvider(plugin);
T comp = (T) plugin.createComponent(ctx, cls);
if (comp != null) return comp;
}
return null;
}
/** Closes the {@link #transportManagers} of this <tt>Conference</tt>. */
private void closeTransportManagers() {
synchronized (transportManagers) {
for (Iterator<IceUdpTransportManager> i = transportManagers.values().iterator();
i.hasNext(); ) {
IceUdpTransportManager transportManager = i.next();
i.remove();
closeTransportManager(transportManager);
}
}
}
public Map defaultArguments() {
Map defaults = new LinkedHashMap();
Collection values = defaultArguments.values();
Iterator iter = values.iterator();
while (iter.hasNext()) {
ArgumentImpl argument = (ArgumentImpl) iter.next();
defaults.put(argument.name(), argument.clone());
}
return defaults;
}
Map<String, FieldAndMethods> getFieldAndMethodsObjects(
Scriptable scope, Object javaObject, boolean isStatic) {
Map<String, FieldAndMethods> ht = isStatic ? staticFieldAndMethods : fieldAndMethods;
if (ht == null) return null;
int len = ht.size();
Map<String, FieldAndMethods> result = new HashMap<String, FieldAndMethods>(len);
for (FieldAndMethods fam : ht.values()) {
FieldAndMethods famNew = new FieldAndMethods(scope, fam.methods, fam.field);
famNew.javaObject = javaObject;
result.put(fam.field.getName(), famNew);
}
return result;
}
/** Print plugins information. */
private void ackPluginsInfo() {
U.quietAndInfo(log, "Configured plugins:");
if (plugins.isEmpty()) {
U.quietAndInfo(log, " ^-- None");
U.quietAndInfo(log, "");
} else {
for (PluginProvider plugin : plugins.values()) {
U.quietAndInfo(log, " ^-- " + plugin.name() + " " + plugin.version());
U.quietAndInfo(log, " ^-- " + plugin.copyright());
U.quietAndInfo(log, "");
}
}
}
public Query bind(final Object pojo) {
Class clazz = pojo.getClass();
Map<String, PojoIntrospector.ReadableProperty> propertyMap =
PojoIntrospector.readableProperties(clazz);
for (PojoIntrospector.ReadableProperty property : propertyMap.values()) {
try {
if (this.getParamNameToIdxMap().containsKey(property.name)) {
@SuppressWarnings("unchecked")
final Class<Object> type = (Class<Object>) property.type;
this.addParameter(property.name, type, property.get(pojo));
}
} catch (IllegalArgumentException ex) {
logger.debug("Ignoring Illegal Arguments", ex);
} catch (IllegalAccessException | InvocationTargetException ex) {
throw new RuntimeException(ex);
}
}
return this;
}
List<Modification> getModifications(
final T o, final boolean deleteNullValues, final String... attributes)
throws LDAPPersistException {
final ReadOnlyEntry originalEntry;
if (entryField != null) {
originalEntry = getEntry(o);
} else {
originalEntry = null;
}
if (originalEntry != null) {
try {
final T decodedOrig = decode(originalEntry);
final Entry reEncodedOriginal = encode(decodedOrig, originalEntry.getParentDNString());
final Entry newEntry = encode(o, originalEntry.getParentDNString());
final List<Modification> mods =
Entry.diff(reEncodedOriginal, newEntry, true, false, attributes);
if (!deleteNullValues) {
final Iterator<Modification> iterator = mods.iterator();
while (iterator.hasNext()) {
final Modification m = iterator.next();
if (m.getRawValues().length == 0) {
iterator.remove();
}
}
}
HashSet<String> stripAttrs = null;
for (final FieldInfo i : fieldMap.values()) {
if (!i.includeInModify()) {
if (stripAttrs == null) {
stripAttrs = new HashSet<String>(10);
}
stripAttrs.add(toLowerCase(i.getAttributeName()));
}
}
for (final GetterInfo i : getterMap.values()) {
if (!i.includeInModify()) {
if (stripAttrs == null) {
stripAttrs = new HashSet<String>(10);
}
stripAttrs.add(toLowerCase(i.getAttributeName()));
}
}
if (stripAttrs != null) {
final Iterator<Modification> iterator = mods.iterator();
while (iterator.hasNext()) {
final Modification m = iterator.next();
if (stripAttrs.contains(toLowerCase(m.getAttributeName()))) {
iterator.remove();
}
}
}
return mods;
} catch (final Exception e) {
debugException(e);
} finally {
setDNAndEntryFields(o, originalEntry);
}
}
final HashSet<String> attrSet;
if ((attributes == null) || (attributes.length == 0)) {
attrSet = null;
} else {
attrSet = new HashSet<String>(attributes.length);
for (final String s : attributes) {
attrSet.add(toLowerCase(s));
}
}
final ArrayList<Modification> mods = new ArrayList<Modification>(5);
for (final Map.Entry<String, FieldInfo> e : fieldMap.entrySet()) {
final String attrName = toLowerCase(e.getKey());
if ((attrSet != null) && (!attrSet.contains(attrName))) {
continue;
}
final FieldInfo i = e.getValue();
if (!i.includeInModify()) {
continue;
}
final Attribute a = i.encode(o, false);
if (a == null) {
if (!deleteNullValues) {
continue;
}
if ((originalEntry != null) && (!originalEntry.hasAttribute(attrName))) {
continue;
}
mods.add(new Modification(ModificationType.REPLACE, i.getAttributeName()));
continue;
}
if (originalEntry != null) {
final Attribute originalAttr = originalEntry.getAttribute(attrName);
if ((originalAttr != null) && originalAttr.equals(a)) {
continue;
}
}
mods.add(new Modification(ModificationType.REPLACE, i.getAttributeName(), a.getRawValues()));
}
for (final Map.Entry<String, GetterInfo> e : getterMap.entrySet()) {
final String attrName = toLowerCase(e.getKey());
if ((attrSet != null) && (!attrSet.contains(attrName))) {
continue;
}
final GetterInfo i = e.getValue();
if (!i.includeInModify()) {
continue;
}
final Attribute a = i.encode(o);
if (a == null) {
if (!deleteNullValues) {
continue;
}
if ((originalEntry != null) && (!originalEntry.hasAttribute(attrName))) {
continue;
}
mods.add(new Modification(ModificationType.REPLACE, i.getAttributeName()));
continue;
}
if (originalEntry != null) {
final Attribute originalAttr = originalEntry.getAttribute(attrName);
if ((originalAttr != null) && originalAttr.equals(a)) {
continue;
}
}
mods.add(new Modification(ModificationType.REPLACE, i.getAttributeName(), a.getRawValues()));
}
if (superclassHandler != null) {
final List<Modification> superMods =
superclassHandler.getModifications(o, deleteNullValues, attributes);
final ArrayList<Modification> modsToAdd = new ArrayList<Modification>(superMods.size());
for (final Modification sm : superMods) {
boolean add = true;
for (final Modification m : mods) {
if (m.getAttributeName().equalsIgnoreCase(sm.getAttributeName())) {
add = false;
break;
}
}
if (add) {
modsToAdd.add(sm);
}
}
mods.addAll(modsToAdd);
}
return Collections.unmodifiableList(mods);
}
ObjectClassDefinition constructObjectClass(
final String name, final String sup, final ObjectClassType type, final OIDAllocator a) {
final TreeMap<String, String> requiredAttrs = new TreeMap<String, String>();
final TreeMap<String, String> optionalAttrs = new TreeMap<String, String>();
for (final FieldInfo i : fieldMap.values()) {
boolean found = false;
for (final String s : i.getObjectClasses()) {
if (name.equalsIgnoreCase(s)) {
found = true;
break;
}
}
if (!found) {
continue;
}
final String attrName = i.getAttributeName();
final String lowerName = toLowerCase(attrName);
if (i.includeInRDN() || (i.isRequiredForDecode() && i.isRequiredForEncode())) {
requiredAttrs.put(lowerName, attrName);
} else {
optionalAttrs.put(lowerName, attrName);
}
}
for (final GetterInfo i : getterMap.values()) {
boolean found = false;
for (final String s : i.getObjectClasses()) {
if (name.equalsIgnoreCase(s)) {
found = true;
break;
}
}
if (!found) {
continue;
}
final String attrName = i.getAttributeName();
final String lowerName = toLowerCase(attrName);
if (i.includeInRDN()) {
requiredAttrs.put(lowerName, attrName);
} else {
optionalAttrs.put(lowerName, attrName);
}
}
if (name.equalsIgnoreCase(structuralClass)) {
for (final SetterInfo i : setterMap.values()) {
final String attrName = i.getAttributeName();
final String lowerName = toLowerCase(attrName);
if (requiredAttrs.containsKey(lowerName) || optionalAttrs.containsKey(lowerName)) {
continue;
}
optionalAttrs.put(lowerName, attrName);
}
}
final String[] reqArray = new String[requiredAttrs.size()];
requiredAttrs.values().toArray(reqArray);
final String[] optArray = new String[optionalAttrs.size()];
optionalAttrs.values().toArray(optArray);
return new ObjectClassDefinition(
a.allocateObjectClassOID(name),
new String[] {name},
null,
false,
new String[] {sup},
type,
reqArray,
optArray,
null);
}
public static String generateProxy(Class interfaceClass) throws Exception {
StringBuilder b = new StringBuilder();
b.append("#include <jni.h>\n");
b.append("#ifdef _WIN32\n");
b.append("#define PROXY_EXPORT __declspec(dllexport)\n");
b.append("#else\n");
b.append("#define PROXY_EXPORT\n");
b.append("#endif\n");
b.append(
"#define FIND_GLOBAL_CLASS(name) (*env)->NewGlobalRef(env, (*env)->FindClass(env, name))\n");
List<ProxiedMethod> methods = new ArrayList<ProxiedMethod>();
int iClassName = 0, iMethodName = 0;
Map<Class, String> classVarNames = new HashMap<Class, String>();
for (Method m : interfaceClass.getDeclaredMethods()) {
try {
ProxiedMethod pm = getProxiedMethod(m);
String classVarName = classVarNames.get(pm.owner);
if (classVarName == null)
classVarNames.put(pm.owner, classVarName = "gClass" + (++iClassName));
pm.classVarName = classVarName;
pm.methodVarName = "gMethod" + (++iMethodName);
methods.add(pm);
} catch (Throwable th) {
// th.printStackTrace();
}
}
b.append("jboolean inited = JNI_FALSE;\n");
String instanceVarName = "gProxiedInstance";
b.append("JNIEnv* env = NULL;\n");
b.append("JavaVM* jvm = NULL;\n");
b.append("jobject ").append(instanceVarName).append(" = NULL;\n");
for (String n : classVarNames.values()) b.append("jclass ").append(n).append(" = NULL;\n");
for (ProxiedMethod pm : methods)
b.append("jmethodID ").append(pm.methodVarName).append(" = NULL;\n");
String jniInit = "jni_init";
b.append("void ").append(jniInit).append("(JNIEnv* env) {\n");
b.append("\tif (inited) return; else inited = JNI_TRUE;\n");
for (Map.Entry<Class, String> e : classVarNames.entrySet()) {
String n = e.getValue();
Class c = e.getKey();
b.append("\t")
.append(n)
.append(" = ")
.append("FIND_GLOBAL_CLASS(\"")
.append(name(c))
.append("\");\n");
}
for (ProxiedMethod pm : methods) {
int mods = pm.method.getModifiers();
b.append("\t")
.append(pm.methodVarName)
.append(" = ")
.append("(*env)->")
.append(Modifier.isStatic(mods) ? "GetStaticMethodID" : "GetMethodID")
.append("(env, ")
.append(pm.classVarName)
.append(", \"")
.append(pm.name)
.append("\", \"")
.append(pm.jni_signature)
.append("\");\n");
}
b.append("}\n");
for (ProxiedMethod pm : methods) {
b.append("PROXY_EXPORT ").append(pm.c_signature).append(" {\n");
int mods = pm.method.getModifiers();
b.append("\t").append(jniInit).append("();\n");
b.append("\t");
if (pm.method.getReturnType() != null && !pm.method.getReturnType().equals(void.class))
b.append("return ");
StringBuilder r = new StringBuilder();
boolean stat = Modifier.isStatic(mods);
r.append("(*env)->")
.append("Call" + (stat ? "Static" : "") + pm.retCapitalized + "Method")
.append("(env, ");
if (stat) r.append(pm.classVarName);
else r.append(instanceVarName);
for (String argValue : pm.argValues) {
r.append(", \n\t\t");
r.append(argValue);
}
// TODO...
r.append("\n\t)");
b.append(c_signature(pm.method.getReturnType(), r.toString())[2]);
b.append(";\n");
b.append("}\n");
}
return b.toString();
}
/** @return All plugin providers. */
public Collection<PluginProvider> allProviders() {
return plugins.values();
}
/**
* Retrieves mapping of methods to accessible methods for a class. In case the class is not
* public, retrieves methods with same signature as its public methods from public superclasses
* and interfaces (if they exist). Basically upcasts every method to the nearest accessible
* method.
*/
private static Method[] discoverAccessibleMethods(
Class<?> clazz, boolean includeProtected, boolean includePrivate) {
Map<MethodSignature, Method> map = new HashMap<MethodSignature, Method>();
discoverAccessibleMethods(clazz, map, includeProtected, includePrivate);
return map.values().toArray(new Method[map.size()]);
}
/**
* Process each package and the classes/interfaces within it.
*
* @param pd an array of PackageDoc objects
*/
public void processPackages(RootDoc root) {
PackageDoc[] specified_pd = root.specifiedPackages();
Map pdl = new TreeMap();
for (int i = 0; specified_pd != null && i < specified_pd.length; i++) {
pdl.put(specified_pd[i].name(), specified_pd[i]);
}
// Classes may be specified separately, so merge their packages into the
// list of specified packages.
ClassDoc[] cd = root.specifiedClasses();
// This is lists of the specific classes to document
Map classesToUse = new HashMap();
for (int i = 0; cd != null && i < cd.length; i++) {
PackageDoc cpd = cd[i].containingPackage();
if (cpd == null && !packagesOnly) {
// If the RootDoc object has been created from a jar file
// this duplicates classes, so we have to be able to disable it.
// TODO this is still null?
cpd = root.packageNamed("anonymous");
}
String pkgName = cpd.name();
String className = cd[i].name();
if (trace) System.out.println("Found package " + pkgName + " for class " + className);
if (!pdl.containsKey(pkgName)) {
if (trace) System.out.println("Adding new package " + pkgName);
pdl.put(pkgName, cpd);
}
// Keep track of the specific classes to be used for this package
List classes;
if (classesToUse.containsKey(pkgName)) {
classes = (ArrayList) classesToUse.get(pkgName);
} else {
classes = new ArrayList();
}
classes.add(cd[i]);
classesToUse.put(pkgName, classes);
}
PackageDoc[] pd = (PackageDoc[]) pdl.values().toArray(new PackageDoc[0]);
for (int i = 0; pd != null && i < pd.length; i++) {
String pkgName = pd[i].name();
// Check for an exclude tag in the package doc block, but not
// in the package.htm[l] file.
if (!shownElement(pd[i], null)) continue;
if (trace) System.out.println("PROCESSING PACKAGE: " + pkgName);
outputFile.println("<package name=\"" + pkgName + "\">");
int tagCount = pd[i].tags().length;
if (trace) System.out.println("#tags: " + tagCount);
List classList;
if (classesToUse.containsKey(pkgName)) {
// Use only the specified classes in the package
System.out.println("Using the specified classes");
classList = (ArrayList) classesToUse.get(pkgName);
} else {
// Use all classes in the package
classList = new LinkedList(Arrays.asList(pd[i].allClasses()));
}
Collections.sort(classList);
ClassDoc[] classes = new ClassDoc[classList.size()];
classes = (ClassDoc[]) classList.toArray(classes);
processClasses(classes, pkgName);
addPkgDocumentation(root, pd[i], 2);
outputFile.println("</package>");
}
} // processPackages
