HippoItem (Hippo Site Toolkit 4.1.0 API)

java.lang.Object
- org.hippoecm.hst.content.beans.standard.HippoItem

All Implemented Interfaces:

Comparable<HippoBean>, ObjectConverterAware, NodeAware, ContentBean, HippoBean, IdentifiableContentBean

Direct Known Subclasses:

HippoCompound, HippoDocument, HippoFolder, HippoHtml, HippoResource, HippoStdPubWfRequest, HippoTranslation
```
public class HippoItem
extends Object
implements HippoBean
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class HippoItem.ComparatorMap

Nested Classes
Modifier and Type	Class and Description
`class`	`HippoItem.ComparatorMap`

Field Summary

Fields
Modifier and Type	Field and Description
`protected String`	`comparePath`
`protected boolean`	`detached`
`protected String`	`displayName`
`protected String`	`localizedName`
`protected String`	`name`
`protected javax.jcr.Node`	`node`
`protected ObjectConverter`	`objectConverter`
`protected String`	`path`
`protected JCRValueProvider`	`valueProvider`

Constructor Summary

Constructors
Constructor and Description

HippoItem()

Constructors
Constructor and Description
`HippoItem()`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`attach(javax.jcr.Session session)` Try to attach the jcr Node again with this session.
`int`	`compareTo(HippoBean hippoBean)` The standard HippoItem has a natural ordering based on node name.
`void`	`detach()` Detach the jcr Node.
`boolean`	`equalCompare(Object compare)` A convenience method capable of comparing two HippoBean instances for you for the underlying jcr node.
`boolean`	`equals(Object obj)` equality is based on the absolute path of the backing jcr node.
`<T extends HippoBean> HippoAvailableTranslationsBean<T>`	`getAvailableTranslations()` In general, only a `HippoDocumentBean` and `HippoFolderBean` can have a `HippoAvailableTranslationsBean`.
`<T> T`	`getBean(String relPath)` This methods fetches a child `HippoBean` with the relative path relPath.
`<T extends HippoBean> T`	`getBean(String relPath, Class<T> beanMappingClass)` Only if a bean found of type `beanMappingClass`, it is returned, and otherwise `null` is returned.
`<T extends HippoBean> T`	`getBeanByUUID(String uuid, Class<T> beanMappingClass)`
`<T extends HippoBean> T`	`getCanonicalBean()` Returns the canonical version of the current `HippoBean` or `null` in case that the backing `Node` is pure virtual, which is the case for example for some faceted navigation nodes.
`String`	`getCanonicalPath()` Returns the jcr path of the backing canonical (physical) jcr node or `null` when
`String`	`getCanonicalUUID()` Returns the jcr uuid of the backing canonical (physical) jcr node or `null` when
`<T extends HippoBean> List<T>`	`getChildBeans(Class<T> beanMappingClass)` Returns all the child beans as a `List` with elements of type `T`.
`<T> List<T>`	`getChildBeans(String jcrPrimaryNodeType)` Returns all the child beans of this bean, where the backing jcr node primary node type equals jcrPrimaryNodeType.
`<T> List<T>`	`getChildBeansByName(String childNodeName)` Returns all the child beans of name `childNodeName` as a `List` with elements of type `T`.
`<T extends HippoBean> List<T>`	`getChildBeansByName(String childNodeName, Class<T> beanMappingClass)` Returns all the child beans of name `childNodeName` as a `List` with elements of type `T`.
`String`	`getComparePath()`
`String`	`getDisplayName()` Returns the display name of the backing jcr node for this bean as determined by its `hippo:name` property or the node name of the backing jcr node if no such property exists
`Map<Object,Object>`	`getEqualComparator()` A convenience method capable of comparing two HippoBean instances for you for the underlying jcr node.
`String`	`getIdentifier()` This returns the identifier of the backing provider for this bean, for example some UUID or /documents/content/myprojec/news/article or http://www.example.com/foo/bar, or a RDBMS id, etc It is not allowed for any implementation to return `null`
`<T extends HippoBean> T`	`getLinkedBean(String relPath, Class<T> beanMappingClass)` This method returns the `HippoBean` linked by `relPath` of type beanMappingClass.
`<T extends HippoBean> List<T>`	`getLinkedBeans(String relPath, Class<T> beanMappingClass)` Same as `HippoBean.getLinkedBean(String, Class)` only now all linked beans found at `relPath` are returned.
`String`	`getLocalizedName()` Deprecated. use `getDisplayName()` instead. Deprecated since 4.0.0
`String`	`getName()` This returns the node name of the backing jcr node for this bean
`javax.jcr.Node`	`getNode()` This returns the backing jcr node for this bean.
`ObjectConverter`	`getObjectConverter()`
`HippoBean`	`getParentBean()` Returns the parent bean wrt this bean.
`String`	`getPath()` This returns the absolute path of the backing jcr node for this bean, for example /documents/content/myprojec/news/article When the jcr node is virtual, it returns the virtual path.
`Map<String,Object>`	`getProperties()` values in the map can be of type String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[] Same as `HippoBean.getProperty(String)`, where getProperty is only there for having a nice .getProperty['propname'] in jsp expression language
`Map<String,Object>`	`getProperty()`
`<T> T`	`getProperty(String name)` Return types can be of type String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[]
`<T> T`	`getProperty(String name, T defaultValue)` If the property does not exist, return the `defaultValue`.
`JCRValueProvider`	`getValueProvider()`
`int`	`hashCode()` hashcode is based on the absolute path of the backing jcr node.
`boolean`	`isAncestor(HippoBean compare)` Returns `true` when this `HippoBean` is an ancestor of the `compare` HippoBean.
`boolean`	`isDescendant(HippoBean compare)` Returns `true` when this `HippoBean` is an descendant of the `compare` HippoBean.
`boolean`	`isHippoDocumentBean()`
`boolean`	`isHippoFolderBean()`
`boolean`	`isLeaf()`
`boolean`	`isSelf(HippoBean compare)` Returns `true` when this `HippoBean` has a underlying jcr node with the same jcr path as the `compare` HippoBean.
`void`	`setComparePath(String comparePath)`
`void`	`setDisplayName(String displayName)`
`void`	`setIdentifier(String identifier)`
`void`	`setLocalizedName(String localizedName)` Deprecated. use `setDisplayName(String)` instead. Deprecated since 4.0.0
`void`	`setName(String name)`
`void`	`setNode(javax.jcr.Node node)` Callback that supplies the originating JCR node.
`void`	`setObjectConverter(ObjectConverter objectConverter)` Callback that supplies the object converter.
`void`	`setPath(String path)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - node
```
protected transient javax.jcr.Node node
```
  - comparePath
```
protected String comparePath
```
  - path
```
protected String path
```
  - name
```
protected String name
```
  - localizedName
```
protected String localizedName
```
  - displayName
```
protected String displayName
```
  - valueProvider
```
protected JCRValueProvider valueProvider
```
  - objectConverter
```
protected transient ObjectConverter objectConverter
```
  - detached
```
protected boolean detached
```
- Constructor Detail
  - HippoItem
```
public HippoItem()
```
- Method Detail
  - setObjectConverter
```
public void setObjectConverter(ObjectConverter objectConverter)
```
    Description copied from interface: ObjectConverterAware
    
    Callback that supplies the object converter.
    
    Specified by:
    
    setObjectConverter in interface ObjectConverterAware
  - getObjectConverter
```
public ObjectConverter getObjectConverter()
```
    Specified by:
    
    getObjectConverter in interface ObjectConverterAware
    
    Returns:
    
    the ObjectConverter
  - setNode
```
public void setNode(javax.jcr.Node node)
```
    Description copied from interface: NodeAware
    
    Callback that supplies the originating JCR node.
    
    Specified by:
    
    setNode in interface NodeAware
  - getNode
```
public javax.jcr.Node getNode()
```
    Description copied from interface: HippoBean
    
    This returns the backing jcr node for this bean.
    
    Specified by:
    
    getNode in interface HippoBean
    
    Returns:
    
    the backing jcr node for this bean. null if the bean is detached
  - getValueProvider
```
public JCRValueProvider getValueProvider()
```
    Specified by:
    
    getValueProvider in interface HippoBean
  - getIdentifier
```
public String getIdentifier()
```
    Description copied from interface: IdentifiableContentBean
    
    This returns the identifier of the backing provider for this bean, for example some UUID or /documents/content/myprojec/news/article or http://www.example.com/foo/bar, or a RDBMS id, etc It is not allowed for any implementation to return null
    
    Since the return value for this method is used as the index document identifier, it must be unique for every bean that must be indexed
    
    Specified by:
    
    getIdentifier in interface IdentifiableContentBean
    
    Returns:
    
    the identifier for this IdentifiableContentBean
  - setIdentifier
```
public void setIdentifier(String identifier)
```
    Specified by:
    
    setIdentifier in interface IdentifiableContentBean
    
    Parameters:
    
    identifier - sets the identifier for this IdentifiableContentBean
    
    See Also:
    
    IdentifiableContentBean.getIdentifier()
  - getName
```
@IndexField(ignoreInCompound=true)
public String getName()
```
    Description copied from interface: HippoBean
    
    This returns the node name of the backing jcr node for this bean
    
    Specified by:
    
    getName in interface HippoBean
    
    Returns:
    
    the node name of the backing jcr node. This method never returns null
  - setName
```
public void setName(String name)
```
  - getDisplayName
```
@IndexField(ignoreInCompound=true)
public String getDisplayName()
```
    Description copied from interface: HippoBean
    
    Returns the display name of the backing jcr node for this bean as determined by its hippo:name property or the node name of the backing jcr node if no such property exists
    
    Specified by:
    
    getDisplayName in interface HippoBean
    
    Returns:
    
    the display name of the backing jcr node for this bean as determined by its hippo:name property or the node name of the backing jcr node if no such proeprty exists
  - setDisplayName
```
public void setDisplayName(String displayName)
```
  - getLocalizedName
```
@Deprecated
 @IndexField(ignoreInCompound=true)
public String getLocalizedName()
```
    Deprecated. use getDisplayName() instead. Deprecated since 4.0.0
    
    Description copied from interface: HippoBean
    
    This returns the localized node name of the backing jcr node for this bean. If it is a HippoNode is returns HippoNode.getDisplayName() ()}, otherwise Item.getName()
    
    Specified by:
    
    getLocalizedName in interface HippoBean
    
    Returns:
    
    the localized node name of the backing jcr node and null when some RepositoryException happens
  - setLocalizedName
```
@Deprecated
public void setLocalizedName(String localizedName)
```
    Deprecated. use setDisplayName(String) instead. Deprecated since 4.0.0
  - getPath
```
public String getPath()
```
    Description copied from interface: HippoBean
    
    This returns the absolute path of the backing jcr node for this bean, for example /documents/content/myprojec/news/article When the jcr node is virtual, it returns the virtual path.
    
    Specified by:
    
    getPath in interface HippoBean
    
    Returns:
    
    the absolute jcr path of the backing jcr node.
  - setPath
```
public void setPath(String path)
```
  - getComparePath
```
@IndexField(ignoreInCompound=true)
public String getComparePath()
```
  - setComparePath
```
public void setComparePath(String comparePath)
```
  - getCanonicalUUID
```
public String getCanonicalUUID()
```
    Description copied from interface: HippoBean
    Returns the jcr uuid of the backing canonical (physical) jcr node or null when
    - there is no canonical node (for example this might be the case for faceted navigation folders)
    - the jcr node is detached
    - a repository exception happened
    For HippoDocumentBean's, the uuid of the handle might be more valuable, which you can get with HippoDocumentBean.getCanonicalHandleUUID().
    Specified by:
    
    getCanonicalUUID in interface HippoBean
    
    Returns:
    
    the jcr uuid of the backing canonical (physical) jcr node or null
    
    See Also:
    
    HippoDocumentBean.getCanonicalHandleUUID()
  - getCanonicalPath
```
public String getCanonicalPath()
```
    Description copied from interface: HippoBean
    Returns the jcr path of the backing canonical (physical) jcr node or null when
    - there is no canonical node (for example this might be the case for faceted navigation folders)
    - the jcr node is detached
    - a repository exception happened
    For HippoDocumentBean's, the uuid of the handle might be more valuable, which you can get with HippoDocumentBean.getCanonicalHandleUUID().
    Specified by:
    
    getCanonicalPath in interface HippoBean
    
    Returns:
    
    the jcr path of the backing canonical (physical) jcr node or null
    
    See Also:
    
    HippoDocumentBean.getCanonicalHandlePath()
  - getProperties
```
public Map<String,Object> getProperties()
```
    values in the map can be of type String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[]
    Same as HippoBean.getProperty(String), where getProperty is only there for having a nice .getProperty['propname'] in jsp expression language
    
    Specified by:
    
    getProperties in interface HippoBean
  - getProperty
```
public <T> T getProperty(String name)
```
    Description copied from interface: HippoBean
    
    Return types can be of type String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[]
    
    Specified by:
    
    getProperty in interface HippoBean
    
    Parameters:
    
    name - the name of the property
    
    Returns:
    
    The value of the property and null if it does not exist. The return type is either String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[]
  - getProperty
```
public <T> T getProperty(String name,
                         T defaultValue)
```
    Description copied from interface: HippoBean
    
    If the property does not exist, return the defaultValue. If the property does exist, the same value as HippoBean.getProperty(String) will be returned Return types can be of type String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[]
    
    Specified by:
    
    getProperty in interface HippoBean
    
    Parameters:
    
    name - the name of the property
    
    Returns:
    
    The value of the property and defaultValue if it does not exist. The return type is either String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[]
  - getProperty
```
public Map<String,Object> getProperty()
```
    Specified by:
    
    getProperty in interface HippoBean
    
    Returns:
    
    Map of all properties, where the values can be of type String, String[], Boolean, Boolean[], Long, Long[], Double, Double[] or Calendar, Calendar[]
    
    See Also:
    
    #getProperties()}, HippoBean.getProperty()
  - getBean
```
public <T> T getBean(String relPath)
```
    Description copied from interface: HippoBean
    
    This methods fetches a child HippoBean with the relative path relPath. A relPath is not allowed to start with a "/", as this is considered to be an absolute path. For example getBean("x/y") is a valid relative path. "../x" is also supported, but dis-encouraged as the "../" works directly on jcr level, which does not take the hippo:handle intermediate node into account in case of a HippoDocument bean. Always preferred to use is HippoBean.getParentBean() instead of using "../". In case of a HippoDocument kind of bean, the HippoBean.getParentBean() jumps to the parent of the handle, while ../ jumps to the handle, resulting in the exact same bean in case of a HippoDocument
    
    Specified by:
    
    getBean in interface HippoBean
    
    Parameters:
    
    relPath - a path that does not start with a "/"
    
    Returns:
    
    returns the HippoBean with relative path relPath to this bean, or null when it does not exist, or when the relPath is not a valid relative path
  - getBean
```
public <T extends HippoBean> T getBean(String relPath,
                                       Class<T> beanMappingClass)
```
    Description copied from interface: HippoBean
    
    Only if a bean found of type beanMappingClass, it is returned, and otherwise null is returned.
    
    Specified by:
    
    getBean in interface HippoBean
    
    Parameters:
    
    relPath - a path that does not start with a "/"
    
    beanMappingClass - the class T that the child bean must inherit from
    
    Returns:
    
    returns the HippoBean of (sub)type beanMappingClass with relative path relPath to this bean, or null when it does not exist, is not of (sub)type beanMappingClass, or when the relPath is not a valid relative path
    
    See Also:
    
    HippoBean.getBean(String)
  - getChildBeans
```
public <T extends HippoBean> List<T> getChildBeans(Class<T> beanMappingClass)
```
    Description copied from interface: HippoBean
    
    Returns all the child beans as a List with elements of type T. When a child bean is found that is not of type beanMappingClass, it is skipped
    
    If you want all child beans that can be mapped to a HippoBean, just call List beans = getBeans(HippoBean.class);
    
    Specified by:
    
    getChildBeans in interface HippoBean
    
    Type Parameters:
    
    T - the return type of the child bean
    
    Parameters:
    
    beanMappingClass - the class T that the child beans must inherit from
    
    Returns:
    
    List where the backing jcr nodes have the name childNodeName
  - getChildBeansByName
```
public <T> List<T> getChildBeansByName(String childNodeName)
```
    Description copied from interface: HippoBean
    
    Returns all the child beans of name childNodeName as a List with elements of type T. When a found bean is not of type T a ClassCastException is thrown.
    
    Specified by:
    
    getChildBeansByName in interface HippoBean
    
    Type Parameters:
    
    T - the return type of the child bean
    
    Returns:
    
    List where the backing jcr nodes have the name childNodeName
  - getChildBeansByName
```
public <T extends HippoBean> List<T> getChildBeansByName(String childNodeName,
                                                         Class<T> beanMappingClass)
```
    Description copied from interface: HippoBean
    
    Returns all the child beans of name childNodeName as a List with elements of type T. When a child bean is found that is not of type beanMappingClass, it is skipped
    
    If the beanMappingClass is null, it is ignored. Then, this method returns the same a HippoBean.getChildBeansByName(String) and can throw a ClassCastException
    
    Specified by:
    
    getChildBeansByName in interface HippoBean
    
    Type Parameters:
    
    T - the return type of the child bean
    
    beanMappingClass - the class T that the child beans must inherit from
    
    Returns:
    
    List where the backing jcr nodes have the name childNodeName
  - getChildBeans
```
public <T> List<T> getChildBeans(String jcrPrimaryNodeType)
```
    Description copied from interface: HippoBean
    
    Returns all the child beans of this bean, where the backing jcr node primary node type equals jcrPrimaryNodeType. If a jcr child node is of primary nodetype 'hippo:handle', we look whether the underlying 'Document' has the corresponding jcrPrimaryNodeType. If so, we return the bean for this 'Document'.
    
    Specified by:
    
    getChildBeans in interface HippoBean
    
    Type Parameters:
    
    T - the return type of the List elements
    
    Parameters:
    
    jcrPrimaryNodeType - the primary type the child beans should inherit from
    
    Returns:
    
    List where the backing jcr nodes are of type jcrPrimaryNodeType
  - getLinkedBean
```
public <T extends HippoBean> T getLinkedBean(String relPath,
                                             Class<T> beanMappingClass)
```
    Description copied from interface: HippoBean
    This method returns the HippoBean linked by relPath of type beanMappingClass. It returns a HippoBean if and only if
    1. relPath points to a node of (sub)type hippo:mirror or of (sub)type hippo:facetselect
    2. the hippo:docbase of the mirror points to an existing node that results in a HippoBean of type beanMappingClass
    In all other case, null is returned.
    Specified by:
    
    getLinkedBean in interface HippoBean
    
    Type Parameters:
    
    T - the expected type of the linked bean
    
    Parameters:
    
    relPath - (path not starting with a "/")
    
    beanMappingClass - the expected class of the linked bean
    
    Returns:
    
    The linked HippoBean or null
  - getLinkedBeans
```
public <T extends HippoBean> List<T> getLinkedBeans(String relPath,
                                                    Class<T> beanMappingClass)
```
    Description copied from interface: HippoBean
    
    Same as HippoBean.getLinkedBean(String, Class) only now all linked beans found at relPath are returned. When no linked beans found, an empty list is returned.
    
    Specified by:
    
    getLinkedBeans in interface HippoBean
    
    See Also:
    
    HippoBean.getLinkedBean(String, Class)
  - getBeanByUUID
```
public <T extends HippoBean> T getBeanByUUID(String uuid,
                                             Class<T> beanMappingClass)
```
    Specified by:
    
    getBeanByUUID in interface HippoBean
    
    Type Parameters:
    
    T - the type of the returned bean
    
    Parameters:
    
    uuid - the uuid of the node for which to get the HippoBean
    
    beanMappingClass - the expected class of the linked bean
    
    Returns:
    
    The HippoBean of type T for uuid or null if no node for uuid found or not of correct type
  - getParentBean
```
public HippoBean getParentBean()
```
    Description copied from interface: HippoBean
    
    Returns the parent bean wrt this bean. Note that this does not automatically imply a bean with the parent jcr node of this bean. When the parent node is of type "hippo:handle", the parent of the handle must be taken
    
    Specified by:
    
    getParentBean in interface HippoBean
    
    Returns:
    
    the parent bean wrt this bean, or if this bean backing jcr node is null or object converter cannot create a bean for the parent, return null
  - getCanonicalBean
```
public <T extends HippoBean> T getCanonicalBean()
```
    Description copied from interface: HippoBean
    
    Returns the canonical version of the current HippoBean or null in case that the backing Node is pure virtual, which is the case for example for some faceted navigation nodes. When an exception happens null can be returned
    
    Specified by:
    
    getCanonicalBean in interface HippoBean
    
    Returns:
    
    the canonical version of the current HippoBean or null in case that the backing Node is pure virtual or when some exception happened
  - isAncestor
```
public boolean isAncestor(HippoBean compare)
```
    Description copied from interface: HippoBean
    
    Returns true when this HippoBean is an ancestor of the compare HippoBean. Note that this is done by the jcr path of the backing jcr node. In case of a virtual node, the virtual path is taken.
    
    Specified by:
    
    isAncestor in interface HippoBean
    
    Returns:
    
    true when this HippoBean is an ancestor of the compare HippoBean.
  - isLeaf
```
public boolean isLeaf()
```
    Specified by:
    
    isLeaf in interface HippoBean
    
    Returns:
    
    true when the backing jcr Node has no child nodes
  - isDescendant
```
public boolean isDescendant(HippoBean compare)
```
    Description copied from interface: HippoBean
    
    Returns true when this HippoBean is an descendant of the compare HippoBean. Note that this is done by the jcr path of the backing jcr node. In case of a virtual node, the virtual path is taken. This means, that although the canonical nodes of the backing jcr nodes might return true for this method, this does not automatically holds for the beans of the virtual nodes.
    
    Specified by:
    
    isDescendant in interface HippoBean
    
    Returns:
    
    true when this HippoBean is an descendant of the compare HippoBean.
  - isSelf
```
public boolean isSelf(HippoBean compare)
```
    Description copied from interface: HippoBean
    
    Returns true when this HippoBean has a underlying jcr node with the same jcr path as the compare HippoBean. This means, that two HippoBeans might have the same canonical underlying jcr node, but do not return true because their virtual node might have different jcr paths.
    
    Specified by:
    
    isSelf in interface HippoBean
    
    Returns:
    
    Returns true when this HippoBean has the same underlying jcr node path as the compare HippoBean.
  - isHippoDocumentBean
```
public boolean isHippoDocumentBean()
```
    Specified by:
    
    isHippoDocumentBean in interface HippoBean
    
    Returns:
    
    true is this HippoBean is an instanceof HippoDocumentBean
  - isHippoFolderBean
```
public boolean isHippoFolderBean()
```
    Specified by:
    
    isHippoFolderBean in interface HippoBean
    
    Returns:
    
    true is this HippoBean is an instanceof HippoFolderBean
  - getAvailableTranslations
```
public <T extends HippoBean> HippoAvailableTranslationsBean<T> getAvailableTranslations()
```
    Description copied from interface: HippoBean
    
    In general, only a HippoDocumentBean and HippoFolderBean can have a HippoAvailableTranslationsBean. However, to make sure that on any HippoBean you can call HippoBean.getAvailableTranslations(), we add it to the base HippoBean as well.
    
    Specified by:
    
    getAvailableTranslations in interface HippoBean
    
    Returns:
    
    A HippoAvailableTranslationsBean.
  - equalCompare
```
public boolean equalCompare(Object compare)
```
    Description copied from interface: HippoBean
    
    A convenience method capable of comparing two HippoBean instances for you for the underlying jcr node. When the nodes being compared have the same canonical node (physical equivalence) this method returns true. If there is no canonical node the virtual jcr path is used to compare the items: if these paths are the same, true is returned Note: this method compares the jcr path of the backing canonical jcr nodes. All implementing classes override Object.equals(Object) to compare the jcr node path, which might be a virtual path. So this method can return true while Object.equals(Object) returns false
    
    Specified by:
    
    equalCompare in interface HippoBean
    
    Parameters:
    
    compare - the object to compare to
    
    Returns:
    
    true if the object compared has the same canonical node or the same virtual path when they don't have a canonical
  - getEqualComparator
```
public Map<Object,Object> getEqualComparator()
```
    Description copied from interface: HippoBean
    
    A convenience method capable of comparing two HippoBean instances for you for the underlying jcr node. When the nodes being compared have the same canonical node (physical equivalence) the get(Object o) returns true. In expression language, for example jsp, you can use to compare as follows: ${mydocument.equalComparator[otherdocument]} returns true when mydocument and otherdocument have the same canonical node If there is no canonical node the virtual jcr path is used to compare the items: if these paths are the same, true is returned Note: this method compares the jcr path of the backing canonical jcr nodes. All implementing classes override Object.equals(Object) to compare the jcr node path, which might be a virtual path. So this method can return true while Object.equals(Object) returns false
    
    Specified by:
    
    getEqualComparator in interface HippoBean
    
    Returns:
    
    a ComparatorMap in which you can compare HippoBeans via the get(Object o)
  - compareTo
```
public int compareTo(HippoBean hippoBean)
```
    The standard HippoItem has a natural ordering based on node name. if you need ordering on a different basis, override this method
    
    Specified by:
    
    compareTo in interface Comparable<HippoBean>
  - equals
```
public boolean equals(Object obj)
```
    equality is based on the absolute path of the backing jcr node.
    
    Overrides:
    
    equals in class Object
  - detach
```
public void detach()
```
    Detach the jcr Node. Already loaded properties and variables are still available.
  - attach
```
public void attach(javax.jcr.Session session)
```
    Try to attach the jcr Node again with this session.
    
    Parameters:
    
    session -
  - hashCode
```
public int hashCode()
```
    hashcode is based on the absolute path of the backing jcr node.
    
    Overrides:
    
    hashCode in class Object

Class HippoItem

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

node

comparePath

path

name

localizedName

displayName

valueProvider

objectConverter

detached

Constructor Detail

HippoItem

Method Detail

setObjectConverter

getObjectConverter

setNode

getNode

getValueProvider

getIdentifier

setIdentifier

getName

setName

getDisplayName

setDisplayName

getLocalizedName

setLocalizedName

getPath

setPath

getComparePath

setComparePath

getCanonicalUUID

getCanonicalPath

getProperties

getProperty

getProperty

getProperty

getBean

getBean

getChildBeans

getChildBeansByName

getChildBeansByName

getChildBeans

getLinkedBean

getLinkedBeans

getBeanByUUID

getParentBean

getCanonicalBean

isAncestor

isLeaf

isDescendant

isSelf

isHippoDocumentBean

isHippoFolderBean

getAvailableTranslations

equalCompare

getEqualComparator

compareTo

equals

detach

attach

hashCode