ObjectWrapper (FreeMarker 2.3.23 API)
Date: 2015-07-05

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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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

          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

          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

          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`