freemarker.template

## Interface ObjectWrapper

All Known Subinterfaces:
  ObjectWrapperAndUnwrapper, ObjectWrapperWithAPISupport, RichObjectWrapper

All Known Implementing Classes:
  BeansWrapper, DefaultObjectWrapper, JythonWrapper, RhinoWrapper, SimpleObjectWrapper

    public interface ObjectWrapper

Maps Java objects to the type-system of FreeMarker Template Language (see the `TemplateModel` interfaces). Thus this is what decides what parts of the Java objects will be accessible in the templates and how.

For example, with a `BeansWrapper` both the items of `Map` and the JavaBean properties (the getters) of an object are accessible in template uniformly with the `myObject.foo` syntax, where "foo" is the map key or the property name. This is because both kind of object is wrapped by `BeansWrapper` into a `TemplateHashModel` implementation that will call `Map.get(Object)` or the getter method, transparently to the template language.

See Also:
  `Configuration.setObjectWrapper(ObjectWrapper)`

### Field Summary

Fields
`static ObjectWrapper` `BEANS_WRAPPER` Deprecated. Use `BeansWrapperBuilder.build()` instead; this instance isn't read-only and thus can't be trusted.
`static ObjectWrapper` `DEFAULT_WRAPPER` Deprecated. Use `DefaultObjectWrapperBuilder.build()` instead; this instance isn't read-only and thus can't be trusted.
`static ObjectWrapper` `SIMPLE_WRAPPER` Deprecated. No replacement as it was seldom if ever used by anyone; this instance isn't read-only and thus can't be trusted.

### Method Summary

All Methods Instance Methods Abstract Methods
`TemplateModel` `wrap(Object obj)` Makes a `TemplateModel` out of a non-`TemplateModel` object, usually by "wrapping" it into a `TemplateModel` implementation that delegates to the original object.

### Field Detail

#### BEANS_WRAPPER

    @Deprecated
    static final ObjectWrapper BEANS_WRAPPER

Deprecated. Use `BeansWrapperBuilder.build()` instead; this instance isn't read-only and thus can't be trusted.
An `ObjectWrapper` that exposes the object methods and JavaBeans properties as hash elements, and has custom handling for Java `Map`-s, `ResourceBundle`-s, etc. It doesn't treat `Node`-s and Jython objects specially, however. As of 2.3.22, using `DefaultObjectWrapper` with its `incompatibleImprovements` property set to 2.3.22 (or higher) is recommended instead.

#### DEFAULT_WRAPPER

    @Deprecated
    static final ObjectWrapper DEFAULT_WRAPPER

Deprecated. Use `DefaultObjectWrapperBuilder.build()` instead; this instance isn't read-only and thus can't be trusted.
The legacy default object wrapper implementation, focusing on backward compatibility and out-of-the W3C DOM wrapping box extra features. See `DefaultObjectWrapper` for more information.

#### SIMPLE_WRAPPER

    @Deprecated
    static final ObjectWrapper SIMPLE_WRAPPER

Deprecated. No replacement as it was seldom if ever used by anyone; this instance isn't read-only and thus can't be trusted.
Object wrapper that uses `SimpleXXX` wrappers only. It behaves like the `DEFAULT_WRAPPER`, but for objects that it does not know how to wrap as a `SimpleXXX` it throws an exception. It makes no use of reflection-based exposure of anything, which may makes it a good candidate for security-restricted applications.

### Method Detail

#### wrap

    TemplateModel wrap(Object obj)
                throws TemplateModelException

Makes a `TemplateModel` out of a non-`TemplateModel` object, usually by "wrapping" it into a `TemplateModel` implementation that delegates to the original object.

Parameters:
  `obj` - The object to wrap into a `TemplateModel`. If it already implements `TemplateModel`, it should just return the object as is. If it's `null`, the method should return `null` (however, `BeansWrapper`, has a legacy option for returning a null model object instead, but it's not a good idea).
Returns:
  a `TemplateModel` wrapper of the object passed in. To support un-wrapping, you may consider the return value to implement `WrapperTemplateModel` and `AdapterTemplateModel`. The default expectation is that the `TemplateModel` isn't less thread safe than the wrapped object. If the `ObjectWrapper` returns less thread safe objects, that should be clearly documented, as it restricts how it can be used, like, then it can't be used to wrap "shared variables" (`Configuration.setSharedVaribles(Map)`).
Throws:
  `TemplateModelException`