public Object compile(String expression) throws OgnlException 
{
        Object o = expressions.get(expression);
        if (o == null) {
            o = Ognl.parseExpression(expression);
            expressions.put(expression, o);
        }
        return o;
}

 public  void copy(Object from,
    Object to,
    Map context) 
{
        copy(from, to, context, null, null);
}

Copies the properties in the object "from" and sets them in the object "to" using specified type converter, or com.opensymphony.xwork2.conversion.impl.XWorkConverter if none is specified.

 public  void copy(Object from,
    Object to,
    Map context,
    Collection exclusions,
    Collection inclusions) 
{
        if (from == null || to == null) {
            LOG.warn("Attempting to copy from or to a null source. This is illegal and is bein skipped. This may be due to an error in an OGNL expression, action chaining, or some other event.");
            return;
        }
        TypeConverter conv = getTypeConverterFromContext(context);
        Map contextFrom = Ognl.createDefaultContext(from);
        Ognl.setTypeConverter(contextFrom, conv);
        Map contextTo = Ognl.createDefaultContext(to);
        Ognl.setTypeConverter(contextTo, conv);
        PropertyDescriptor[] fromPds;
        PropertyDescriptor[] toPds;
        try {
            fromPds = getPropertyDescriptors(from);
            toPds = getPropertyDescriptors(to);
        } catch (IntrospectionException e) {
            LOG.error("An error occured", e);
            return;
        }
        Map toPdHash = new HashMap();
        for (int i = 0; i <  toPds.length; i++) {
            PropertyDescriptor toPd = toPds[i];
            toPdHash.put(toPd.getName(), toPd);
        }
        for (int i = 0; i <  fromPds.length; i++) {
            PropertyDescriptor fromPd = fromPds[i];
            if (fromPd.getReadMethod() != null) {
                boolean copy = true;
                if (exclusions != null && exclusions.contains(fromPd.getName())) {
                    copy = false;
                } else if (inclusions != null && !inclusions.contains(fromPd.getName())) {
                    copy = false;
                }
                if (copy == true) {
                    PropertyDescriptor toPd = (PropertyDescriptor) toPdHash.get(fromPd.getName());
                    if ((toPd != null) && (toPd.getWriteMethod() != null)) {
                        try {
                            Object expr = compile(fromPd.getName());
                            Object value = Ognl.getValue(expr, contextFrom, from);
                            Ognl.setValue(expr, contextTo, to, value);
                        } catch (OgnlException e) {
                            // ignore, this is OK
                        }
                    }
                }
            }
        }
}

Copies the properties in the object "from" and sets them in the object "to" using specified type converter, or com.opensymphony.xwork2.conversion.impl.XWorkConverter if none is specified.

 public BeanInfo getBeanInfo(Object from) throws IntrospectionException 
{
        return getBeanInfo(from.getClass());
}

Get's the java bean info for the given source object. Calls getBeanInfo(Class c).

 public BeanInfo getBeanInfo(Class clazz) throws IntrospectionException 
{
        synchronized (beanInfoCache) {
            BeanInfo beanInfo;
            beanInfo = beanInfoCache.get(clazz);
            if (beanInfo == null) {
                beanInfo = Introspector.getBeanInfo(clazz, Object.class);
                beanInfoCache.put(clazz, beanInfo);
            }
            return beanInfo;
        }
}

Get's the java bean info for the given source.

 public Map getBeanMap(Object source) throws IntrospectionException, OgnlException 
{
        Map beanMap = new HashMap();
        Map sourceMap = Ognl.createDefaultContext(source);
        PropertyDescriptor[] propertyDescriptors = getPropertyDescriptors(source);
        for (int i = 0; i <  propertyDescriptors.length; i++) {
            PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
            String propertyName = propertyDescriptor.getDisplayName();
            Method readMethod = propertyDescriptor.getReadMethod();
            if (readMethod != null) {
                Object expr = compile(propertyName);
                Object value = Ognl.getValue(expr, sourceMap, source);
                beanMap.put(propertyName, value);
            } else {
                beanMap.put(propertyName, "There is no read method for " + propertyName);
            }
        }
        return beanMap;
}

Creates a Map with read properties for the given source object.

If the source object does not have a read property (i.e. write-only) then the property is added to the map with the value here is no read method for property-name.

 public PropertyDescriptor[] getPropertyDescriptors(Object source) throws IntrospectionException 
{
        BeanInfo beanInfo = getBeanInfo(source);
        return beanInfo.getPropertyDescriptors();
}

Get's the java beans property descriptors for the given source.

 public PropertyDescriptor[] getPropertyDescriptors(Class clazz) throws IntrospectionException 
{
        BeanInfo beanInfo = getBeanInfo(clazz);
        return beanInfo.getPropertyDescriptors();
}

Get's the java beans property descriptors for the given class.

 public Object getRealTarget(String property,
    Map context,
    Object root) throws OgnlException 
{
        //special keyword, they must be cutting the stack
        if ("top".equals(property)) {
            return root;
        }
        if (root instanceof CompoundRoot) {
            // find real target
            CompoundRoot cr = (CompoundRoot) root;
            try {
                for (Iterator iterator = cr.iterator(); iterator.hasNext();) {
                    Object target = iterator.next();
                    if (
                            OgnlRuntime.hasSetProperty((OgnlContext) context, target, property)
                                    ||
                                    OgnlRuntime.hasGetProperty((OgnlContext) context, target, property)
                                    ||
                                    OgnlRuntime.getIndexedPropertyType((OgnlContext) context, target.getClass(), property) != OgnlRuntime.INDEXED_PROPERTY_NONE
                            ) {
                        return target;
                    }
                }
            } catch (IntrospectionException ex) {
                throw new OgnlException("Cannot figure out real target class", ex);
            }
            return null;
        }
        return root;
}

Looks for the real target with the specified property given a root Object which may be a CompoundRoot.

 TypeConverter getTypeConverterFromContext(Map context) 
{
        /*ValueStack stack = (ValueStack) context.get(ActionContext.VALUE_STACK);
        Container cont = (Container)stack.getContext().get(ActionContext.CONTAINER);
        if (cont != null) {
            return new OgnlTypeConverterWrapper(cont.getInstance(XWorkConverter.class));
        } else {
            throw new IllegalArgumentException("Cannot find type converter in context map");
        }
        */
        return defaultConverter;
}

 public Object getValue(String name,
    Map context,
    Object root) throws OgnlException 
{
        return Ognl.getValue(compile(name), context, root);
}

 public Object getValue(String name,
    Map context,
    Object root,
    Class resultType) throws OgnlException 
{
        return Ognl.getValue(compile(name), context, root, resultType);
}

  void internalSetProperty(String name,
    Object value,
    Object o,
    Map context,
    boolean throwPropertyExceptions) 
{
        try {
            setValue(name, context, o, value);
        } catch (OgnlException e) {
            Throwable reason = e.getReason();
            String msg = "Caught OgnlException while setting property '" + name + "' on type '" + o.getClass().getName() + "'.";
            Throwable exception = (reason == null) ? e : reason;
            if (throwPropertyExceptions) {
                throw new XWorkException(msg, exception);
            } else {
                LOG.warn(msg, exception);
            }
        }
}

 public  void setProperties(Map properties,
    Object o) 
{
        setProperties(properties, o, false);
}

Sets the properties on the object using the default context, defaulting to not throwing exceptions for problems setting the properties.

 public  void setProperties(Map props,
    Object o,
    Map context) 
{
        setProperties(props, o, context, false);
}

Sets the object's properties using the default type converter, defaulting to not throw exceptions for problems setting the properties.

 public  void setProperties(Map properties,
    Object o,
    boolean throwPropertyExceptions) 
{
        Map context = Ognl.createDefaultContext(o);
        setProperties(properties, o, context, throwPropertyExceptions);
}

Sets the properties on the object using the default context.

 public  void setProperties(Map props,
    Object o,
    Map context,
    boolean throwPropertyExceptions) 
{
        if (props == null) {
            return;
        }
        Ognl.setTypeConverter(context, getTypeConverterFromContext(context));
        Object oldRoot = Ognl.getRoot(context);
        Ognl.setRoot(context, o);
        for (Iterator iterator = props.entrySet().iterator();
             iterator.hasNext();) {
            Map.Entry entry = (Map.Entry) iterator.next();
            String expression = (String) entry.getKey();
            internalSetProperty(expression, entry.getValue(), o, context, throwPropertyExceptions);
        }
        Ognl.setRoot(context, oldRoot);
}

Sets the object's properties using the default type converter.

 public  void setProperty(String name,
    Object value,
    Object o,
    Map context) 
{
        setProperty(name, value, o, context, false);
}

Sets the named property to the supplied value on the Object, defaults to not throwing property exceptions.

 public  void setProperty(String name,
    Object value,
    Object o,
    Map context,
    boolean throwPropertyExceptions) 
{
        Ognl.setTypeConverter(context, getTypeConverterFromContext(context));
        Object oldRoot = Ognl.getRoot(context);
        Ognl.setRoot(context, o);
        internalSetProperty(name, value, o, context, throwPropertyExceptions);
        Ognl.setRoot(context, oldRoot);
}

Sets the named property to the supplied value on the Object.

 public  void setValue(String name,
    Map context,
    Object root,
    Object value) throws OgnlException 
{
        Ognl.setValue(compile(name), context, root, value);
}

Wrapper around Ognl.setValue() to handle type conversion for collection elements. Ideally, this should be handled by OGNL directly.

 public  void setXWorkConverter(XWorkConverter conv) 
{
    
        this.defaultConverter = new OgnlTypeConverterWrapper(conv);
}