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; }