Entry encode(final T o, final String parentDN) throws LDAPPersistException {
// Get the attributes that should be included in the entry.
final LinkedHashMap<String, Attribute> attrMap = new LinkedHashMap<String, Attribute>();
attrMap.put("objectClass", objectClassAttribute);
for (final Map.Entry<String, FieldInfo> e : fieldMap.entrySet()) {
final FieldInfo i = e.getValue();
if (!i.includeInAdd()) {
continue;
}
final Attribute a = i.encode(o, false);
if (a != null) {
attrMap.put(e.getKey(), a);
}
}
for (final Map.Entry<String, GetterInfo> e : getterMap.entrySet()) {
final GetterInfo i = e.getValue();
if (!i.includeInAdd()) {
continue;
}
final Attribute a = i.encode(o);
if (a != null) {
attrMap.put(e.getKey(), a);
}
}
final String dn = constructDN(o, parentDN, attrMap);
final Entry entry = new Entry(dn, attrMap.values());
if (postEncodeMethod != null) {
try {
postEncodeMethod.invoke(o, entry);
} catch (Throwable t) {
debugException(t);
if (t instanceof InvocationTargetException) {
t = ((InvocationTargetException) t).getTargetException();
}
throw new LDAPPersistException(
ERR_OBJECT_HANDLER_ERROR_INVOKING_POST_ENCODE_METHOD.get(
postEncodeMethod.getName(), type.getName(), getExceptionMessage(t)),
t);
}
}
setDNAndEntryFields(o, entry);
if (superclassHandler != null) {
final Entry e = superclassHandler.encode(o, parentDN);
for (final Attribute a : e.getAttributes()) {
entry.addAttribute(a);
}
}
return entry;
}
private void setDNAndEntryFields(final T o, final Entry e) throws LDAPPersistException {
if (dnField != null) {
try {
dnField.set(o, e.getDN());
} catch (Exception ex) {
debugException(ex);
throw new LDAPPersistException(
ERR_OBJECT_HANDLER_ERROR_SETTING_DN.get(
type.getName(), e.getDN(), dnField.getName(), getExceptionMessage(ex)),
ex);
}
}
if (entryField != null) {
try {
entryField.set(o, new ReadOnlyEntry(e));
} catch (Exception ex) {
debugException(ex);
throw new LDAPPersistException(
ERR_OBJECT_HANDLER_ERROR_SETTING_ENTRY.get(
type.getName(), entryField.getName(), getExceptionMessage(ex)),
ex);
}
}
}
@Nullable
public InstanceFactory findInstanceFactory(@Nonnull Type mockedType) {
InstanceFactory instanceFactory = mockedTypesAndInstances.get(mockedType);
if (instanceFactory != null) {
return instanceFactory;
}
Class<?> mockedClass = getClassType(mockedType);
//noinspection ReuseOfLocalVariable
instanceFactory = mockedTypesAndInstances.get(mockedClass);
if (instanceFactory != null) {
return instanceFactory;
}
boolean abstractType = mockedClass.isInterface() || isAbstract(mockedClass.getModifiers());
for (Entry<Type, InstanceFactory> entry : mockedTypesAndInstances.entrySet()) {
Type registeredMockedType = entry.getKey();
Class<?> registeredMockedClass = getClassType(registeredMockedType);
if (abstractType) {
registeredMockedClass = getMockedClassOrInterfaceType(registeredMockedClass);
}
if (mockedClass.isAssignableFrom(registeredMockedClass)) {
instanceFactory = entry.getValue();
break;
}
}
return instanceFactory;
}
/**
* ** Sets the default property value of the property associated with the ** specified key
* ** @param key The key of the property to set ** @param val The value to set the property to
*/
public static void setDefaultProperty(String key, Object val) {
Entry rtKey = RTKey.getRuntimeEntry(key);
if (rtKey != null) {
rtKey.setDefault(val);
} else {
RTKey.addRuntimeEntry(new Entry(key, val));
}
}
/**
* ** Gets all the ddefault properties in <code>RTKey</code> represented ** as an {@link
* RTProperties} instance ** @return The <code>RTProperties</code> instance
*/
public static RTProperties getDefaultProperties() {
if (defaultProperties == null) {
RTProperties rtp = new RTProperties();
for (Iterator<Entry> v = RTKey.getRuntimeEntryMap().values().iterator(); v.hasNext(); ) {
Entry rtk = v.next();
if (!rtk.isHelp()) {
String key = rtk.getKey();
Object val = rtk.getDefault();
rtp.setProperty(key, val);
}
}
defaultProperties = rtp;
}
return defaultProperties;
}
/**
* _more_
*
* @param entry _more_
* @param className _more_
* @param properties _more_
* @return _more_
* @throws Exception _more_
*/
private RecordFile doMakeRecordFile(Entry entry, String className, Hashtable properties)
throws Exception {
Class c = Misc.findClass(className);
Constructor ctor = Misc.findConstructor(c, new Class[] {String.class, Hashtable.class});
if (ctor != null) {
return (RecordFile) ctor.newInstance(new Object[] {entry.getFile().toString(), properties});
}
ctor = Misc.findConstructor(c, new Class[] {String.class});
if (ctor != null) {
return (RecordFile) ctor.newInstance(new Object[] {entry.getResource().getPath()});
}
throw new IllegalArgumentException("Could not find constructor for " + className);
}
/**
* _more_
*
* @param entry _more_
* @return _more_
* @throws Exception On badness
*/
public Hashtable getRecordProperties(Entry entry) throws Exception {
Object[] values = entry.getTypeHandler().getEntryValues(entry);
String propertiesString =
(values[IDX_PROPERTIES] != null) ? values[IDX_PROPERTIES].toString() : "";
String typeProperties = getProperty("record.properties", (String) null);
Hashtable p = null;
if (typeProperties != null) {
if (p == null) {
p = new Hashtable();
}
p.putAll(RecordFile.getProperties(typeProperties));
}
if (propertiesString != null) {
if (p == null) {
p = new Hashtable();
}
p.putAll(RecordFile.getProperties(propertiesString));
}
return p;
}
/**
* _more_
*
* @param entry _more_
* @param originalFile _more_
* @throws Exception _more_
*/
public void initializeEntry(Entry entry, File originalFile) throws Exception {
if (anySuperTypesOfThisType()) {
return;
}
Hashtable existingProperties = getRecordProperties(entry);
if ((existingProperties != null) && (existingProperties.size() > 0)) {
return;
}
// Look around for properties files that define
// the crs, fields for text formats, etc.
Hashtable properties =
RecordFile.getPropertiesForFile(originalFile.toString(), PointFile.DFLT_PROPERTIES_FILE);
// Make the properties string
String contents = makePropertiesString(properties);
Object[] values = entry.getTypeHandler().getEntryValues(entry);
// Append the properties file contents
if (values[IDX_PROPERTIES] != null) {
values[IDX_PROPERTIES] = "\n" + contents;
} else {
values[IDX_PROPERTIES] = contents;
}
}
/** ** Adds an entry ({@link Entry}) to <code>RTKey</code> */
public static void addRuntimeEntry(Entry dftEntry) {
if (dftEntry != null) {
String rtKey = dftEntry.getKey();
if (rtKey != null) {
RTKey.getRuntimeEntryMap().put(rtKey, dftEntry);
defaultProperties = null;
}
}
}
/**
* _more_
*
* @param entry _more_
* @param properties _more_
* @return _more_
* @throws Exception _more_
*/
private RecordFile doMakeRecordFile(Entry entry, Hashtable properties) throws Exception {
String recordFileClass = getProperty("record.file.class", (String) null);
if (recordFileClass != null) {
return doMakeRecordFile(entry, recordFileClass, properties);
}
String path = entry.getFile().toString();
return (RecordFile) getRecordFileFactory().doMakeRecordFile(path, properties);
}
public Entry getRealEntry() {
if (this.dft instanceof EntryReference) {
Entry entry = null;
if (this.ref > 0) {
Print.logStackTrace("Cyclical EntryReference: " + this.getKey());
entry = NullEntry;
} else {
this.ref++;
try {
EntryReference entryRef = (EntryReference) this.dft;
Entry nextEntry = entryRef.getReferencedEntry(); // <-- will display error, if not found
entry = (nextEntry != null) ? nextEntry.getRealEntry() : NullEntry;
} finally {
this.ref--;
}
}
return entry;
} else {
return this;
}
}
/**
* ** Prints all the default values from <code>RTKey</code> and {@link RTConfig} ** to the
* specified <code>PrintStream</code>. Used for debugging/testing ** @param out The <code>
* PrintStream</code>
*/
public static void printDefaults(PrintStream out) {
/* print standard runtime entries */
Set<String> keyList = new OrderedSet<String>();
String keyGrp = null;
for (Iterator<Entry> v = RTKey.getRuntimeEntryMap().values().iterator(); v.hasNext(); ) {
Entry rtk = v.next();
if (rtk.isHelp()) {
out.println("");
out.println("# ===== " + rtk.getHelp());
} else {
Object dft = rtk.getDefault();
out.println("# --- " + rtk.getHelp());
out.println("# " + rtk.toString(dft));
String key = rtk.getKey();
keyList.add(key);
if (!key.equals(CONFIG_FILE) && RTConfig.hasProperty(key)) {
String val = RTConfig.getString(key, null);
// if ((val != null) && ((dft == null) || !val.equals(dft.toString()))) {
out.println(rtk.toString(val));
// }
}
}
}
/* orphaned entries */
RTProperties cmdLineProps = RTConfig.getConfigFileProperties();
if (cmdLineProps != null) {
boolean orphanHeader = false;
for (Iterator i = cmdLineProps.keyIterator(); i.hasNext(); ) {
Object k = i.next();
if (!k.equals(COMMAND_LINE_CONF) && !keyList.contains(k)) {
if (!orphanHeader) {
out.println("");
out.println("# ===== Other entries");
orphanHeader = true;
}
Object v = cmdLineProps.getProperty(k, null);
out.println(k + "=" + ((v != null) ? v : NULL_VALUE));
}
}
}
/* final blank line */
out.println("");
}
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);
}
/**
* ** Gets the default property value associated with the specified key. ** Returns <code>dft
* </code> if none was found ** @param key The key of the property to get ** @param dft The value
* to return if no propetry value was found
*/
public static Object getDefaultProperty(String key, Object dft) {
Entry rtKey = RTKey.getRuntimeEntry(key);
return (rtKey != null) ? rtKey.getDefault() : dft;
}