@Override public boolean contains(String key) { return context.contains(key); }
@Override public Object get(String key) { return context.get(key); }
public void set(String key, Object value) { context.set(key, value); }
public static Object resolveNamePart(String[] qnParts, int qnLength, Context context) { String objectOrClassName = ArrayFormat.formatPart(".", 0, qnLength, qnParts); if (context.contains(objectOrClassName)) { return context.get(objectOrClassName); } else { try { return DefaultClassProvider.resolveByObjectOrDefaultInstance(objectOrClassName, context); } catch (ConfigurationError e) { // ignore errors signaling that a class was not found } LOGGER.debug("Class not found: {}", objectOrClassName); if (qnLength > 1) { return readField(qnParts, qnLength - 1, qnParts[qnLength - 1], context); } else throw new ObjectNotFoundException("'" + objectOrClassName + "' is not defined"); } }
@Override public Set<Entry<String, Object>> entrySet() { return context.entrySet(); }
public Set<String> keySet() { return context.keySet(); }
@Override public void remove(String key) { context.remove(key); }
private static Object invoke(String[] qn, int qnLength, String methodName, Object[] args, Context context) { String objectOrClassName = ArrayFormat.formatPart(".", 0, qnLength, qn); if (context.contains(objectOrClassName)) { Object target = context.get(objectOrClassName); return BeanUtil.invoke(target, methodName, args); } try { Class<?> type = DefaultClassProvider.resolveByObjectOrDefaultInstance(objectOrClassName, context); return BeanUtil.invokeStatic(type, methodName, false, args); } catch (ConfigurationError e) { if (LOGGER.isDebugEnabled()) LOGGER.debug("Class not found: " + objectOrClassName); } QNExpression ownerEx = new QNExpression(Arrays.copyOfRange(qn, 0, qnLength)); Object owner = ownerEx.evaluate(context); if (owner != null) return BeanUtil.invoke(false, owner, methodName, args); throw new UnsupportedOperationException("Cannot evaluate " + objectOrClassName); }
public Set<Entry<String, Object>> entrySet() { return context.entrySet(); }
@Override public Set<String> keySet() { return context.keySet(); }
public void remove(String key) { context.remove(key); }
public BeanSpec resolve(Context context) { String qn = ArrayFormat.format(".", qnParts); if (context.contains(qn)) { return BeanSpec.createReference(context.get(qn)); } else { try { Class<?> bean = DefaultClassProvider.resolveByObjectOrDefaultInstance(qn, context); return BeanSpec.createConstruction(bean); } catch (ConfigurationError e) { // ignore this } LOGGER.debug("Class not found: {}", qn); Object bean = readField(qnParts, qnParts.length - 1, ArrayUtil.lastElementOf(qnParts), context); return BeanSpec.createReference(bean); } }
public Object get(String key) { return context.get(key); }
@Override public void set(String key, Object value) { context.set(key, value); }
public boolean contains(String key) { return context.contains(key); }
@Override public Set<Entry<String, Object>> entrySet() { Set<Entry<String, Object>> entrySet = new HashSet<Entry<String, Object>>(); for (int i = 0; i < contexts.size(); i++) { Context c = contexts.get(i); entrySet.addAll(c.entrySet()); } return entrySet; }
@Override public Set<String> keySet() { Set<String> keySet = new HashSet<String>(); for (int i = contexts.size() - 1; i >= 0; i--) { Context c = contexts.get(i); keySet.addAll(c.keySet()); } return keySet; }
@Override public void remove(String key) { if (contexts.size() > 0) contexts.peek().remove(key); }
public BeanSpec resolve(Context context) { String objectOrClassName = ArrayFormat.format(".", qn); try { if (context.contains(objectOrClassName)) return BeanSpec.createReference(context.get(objectOrClassName)); String className = objectOrClassName; Class<?> type = DefaultClassProvider.resolveByObjectOrDefaultInstance(className, context); return BeanSpec.createConstruction(BeanUtil.newInstance(type)); } catch (ConfigurationError e) { if (ExceptionUtil.getRootCause(e) instanceof ClassNotFoundException) return new QNExpression(qn).resolve(context); else throw new ConfigurationError("Cannot resolve " + objectOrClassName, e); } }
@Override public synchronized Object get(String key) { Object value = map.get(key); if (value == null && defaults != null) value = defaults.get(key); return value; }