ObjectWrapper (FreeMarker 2.3.35 API)
Description: declaration: package: freemarker.template, interface: ObjectWrapper

Package 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
  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

  Modifier and Type
  Method
  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 Details

  - ### 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 Details

  - ### 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`