org.modeshape.jcr.index.local

## Class IndexChangeAdapters

- java.lang.Object
- - org.modeshape.jcr.index.local.IndexChangeAdapters

-     public class IndexChangeAdapters
      extends Object

  Utility for creating `IndexChangeAdapter` instances.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected static class` | `IndexChangeAdapters.AbstractPropertyChangeAdapter<T>`
    `protected static class` | `IndexChangeAdapters.EnumeratedPropertyChangeAdapter`
    `protected static class` | `IndexChangeAdapters.MixinTypesChangeAdatper`
    `protected static class` | `IndexChangeAdapters.MultiValuedEnumeratedPropertyChangeAdapter`
    `protected static class` | `IndexChangeAdapters.MultiValuedPropertyChangeAdapter<T>`
    `protected static class` | `IndexChangeAdapters.NodeDepthChangeAdapter`
    `protected static class` | `IndexChangeAdapters.NodeLocalNameChangeAdapter`
    `protected static class` | `IndexChangeAdapters.NodeNameChangeAdapter`
    `protected static class` | `IndexChangeAdapters.NodePathChangeAdapter`
    `protected static class` | `IndexChangeAdapters.NodeTypesChangeAdapter`
    `protected static class` | `IndexChangeAdapters.PathBasedChangeAdapter<T>`
    `protected static class` | `IndexChangeAdapters.PrimaryTypeChangeAdatper`
    `protected static class` | `IndexChangeAdapters.PropertyChangeAdapter<T>`
    `protected static class` | `IndexChangeAdapters.SingleValuedEnumeratedPropertyChangeAdapter`
    `protected static class` | `IndexChangeAdapters.SingleValuedPropertyChangeAdapter<T>`
    `protected static class` | `IndexChangeAdapters.UniquePropertyChangeAdapter<T>`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static IndexChangeAdapter` | `forMixinTypes(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, org.modeshape.jcr.index.local.LocalDuplicateIndex<Name> index)` Create an `IndexChangeAdapter` implementation that handles the "jcr:mixinTypes" property.
    `static IndexChangeAdapter` | `forMultiValuedEnumeratedProperty(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, Name propertyName, org.modeshape.jcr.index.local.LocalEnumeratedIndex index)` Create an `IndexChangeAdapter` implementation that handles a multi-valued enumerated property.
    `static <T> IndexChangeAdapter` | `forMultiValuedProperty(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, Name propertyName, ValueFactory<T> factory, org.modeshape.jcr.index.local.LocalDuplicateIndex<T> index)` Create an `IndexChangeAdapter` implementation that handles a multi-valued property.
    `static IndexChangeAdapter` | `forNodeDepth(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, org.modeshape.jcr.index.local.LocalDuplicateIndex<Long> index)` Create an `IndexChangeAdapter` implementation that handles the "mode:nodeDepth" property.
    `static IndexChangeAdapter` | `forNodeLocalName(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, org.modeshape.jcr.index.local.LocalDuplicateIndex<String> index)` Create an `IndexChangeAdapter` implementation that handles the "mode:localName" property.
    `static IndexChangeAdapter` | `forNodeName(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, org.modeshape.jcr.index.local.LocalDuplicateIndex<Name> index)` Create an `IndexChangeAdapter` implementation that handles the "jcr:name" property.
    `static IndexChangeAdapter` | `forNodePath(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, org.modeshape.jcr.index.local.LocalDuplicateIndex<Path> index)` Create an `IndexChangeAdapter` implementation that handles the "jcr:path" property.
    `static IndexChangeAdapter` | `forNodeTypes(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, LocalIndex<String> index)` Create an `IndexChangeAdapter` implementation that handles node type information.
    `static IndexChangeAdapter` | `forPrimaryType(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, org.modeshape.jcr.index.local.LocalDuplicateIndex<Name> index)` Create an `IndexChangeAdapter` implementation that handles the "jcr:primaryType" property.
    `static IndexChangeAdapter` | `forSingleValuedEnumeratedProperty(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, Name propertyName, org.modeshape.jcr.index.local.LocalEnumeratedIndex index)` Create an `IndexChangeAdapter` implementation that handles a single-valued enumerated property.
    `static <T> IndexChangeAdapter` | `forSingleValuedProperty(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, Name propertyName, ValueFactory<T> factory, org.modeshape.jcr.index.local.LocalDuplicateIndex<T> index)` Create an `IndexChangeAdapter` implementation that handles a single-valued property.
    `static <T> IndexChangeAdapter` | `forUniqueValuedProperty(ExecutionContext context, ChangeSetAdapter.NodeTypePredicate matcher, String workspaceName, Name propertyName, ValueFactory<T> factory, org.modeshape.jcr.index.local.LocalUniqueIndex<T> index)` Create an `IndexChangeAdapter` implementation that handles a unique-valued property, where every property value is unique across all nodes.
    `protected static String` | `nodeKey(NodeKey key)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### forNodeDepth

          public static IndexChangeAdapter forNodeDepth(ExecutionContext context,
                                        ChangeSetAdapter.NodeTypePredicate matcher,
                                        String workspaceName,
                                        org.modeshape.jcr.index.local.LocalDuplicateIndex<Long> index)

      Create an `IndexChangeAdapter` implementation that handles the "mode:nodeDepth" property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forNodeName

          public static IndexChangeAdapter forNodeName(ExecutionContext context,
                                       ChangeSetAdapter.NodeTypePredicate matcher,
                                       String workspaceName,
                                       org.modeshape.jcr.index.local.LocalDuplicateIndex<Name> index)

      Create an `IndexChangeAdapter` implementation that handles the "jcr:name" property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forNodeLocalName

          public static IndexChangeAdapter forNodeLocalName(ExecutionContext context,
                                            ChangeSetAdapter.NodeTypePredicate matcher,
                                            String workspaceName,
                                            org.modeshape.jcr.index.local.LocalDuplicateIndex<String> index)

      Create an `IndexChangeAdapter` implementation that handles the "mode:localName" property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forNodePath

          public static IndexChangeAdapter forNodePath(ExecutionContext context,
                                       ChangeSetAdapter.NodeTypePredicate matcher,
                                       String workspaceName,
                                       org.modeshape.jcr.index.local.LocalDuplicateIndex<Path> index)

      Create an `IndexChangeAdapter` implementation that handles the "jcr:path" property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forPrimaryType

          public static IndexChangeAdapter forPrimaryType(ExecutionContext context,
                                          ChangeSetAdapter.NodeTypePredicate matcher,
                                          String workspaceName,
                                          org.modeshape.jcr.index.local.LocalDuplicateIndex<Name> index)

      Create an `IndexChangeAdapter` implementation that handles the "jcr:primaryType" property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forMixinTypes

          public static IndexChangeAdapter forMixinTypes(ExecutionContext context,
                                         ChangeSetAdapter.NodeTypePredicate matcher,
                                         String workspaceName,
                                         org.modeshape.jcr.index.local.LocalDuplicateIndex<Name> index)

      Create an `IndexChangeAdapter` implementation that handles the "jcr:mixinTypes" property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forSingleValuedProperty

          public static <T> IndexChangeAdapter forSingleValuedProperty(ExecutionContext context,
                                                       ChangeSetAdapter.NodeTypePredicate matcher,
                                                       String workspaceName,
                                                       Name propertyName,
                                                       ValueFactory<T> factory,
                                                       org.modeshape.jcr.index.local.LocalDuplicateIndex<T> index)

      Create an `IndexChangeAdapter` implementation that handles a single-valued property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `propertyName` - the name of the property; may not be null
        `factory` - the value factory for the property's value type; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forMultiValuedProperty

          public static <T> IndexChangeAdapter forMultiValuedProperty(ExecutionContext context,
                                                      ChangeSetAdapter.NodeTypePredicate matcher,
                                                      String workspaceName,
                                                      Name propertyName,
                                                      ValueFactory<T> factory,
                                                      org.modeshape.jcr.index.local.LocalDuplicateIndex<T> index)

      Create an `IndexChangeAdapter` implementation that handles a multi-valued property.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `propertyName` - the name of the property; may not be null
        `factory` - the value factory for the property's value type; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forUniqueValuedProperty

          public static <T> IndexChangeAdapter forUniqueValuedProperty(ExecutionContext context,
                                                       ChangeSetAdapter.NodeTypePredicate matcher,
                                                       String workspaceName,
                                                       Name propertyName,
                                                       ValueFactory<T> factory,
                                                       org.modeshape.jcr.index.local.LocalUniqueIndex<T> index)

      Create an `IndexChangeAdapter` implementation that handles a unique-valued property, where every property value is unique across all nodes.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `propertyName` - the name of the property; may not be null
        `factory` - the value factory for the property's value type; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forSingleValuedEnumeratedProperty

          public static IndexChangeAdapter forSingleValuedEnumeratedProperty(ExecutionContext context,
                                                             ChangeSetAdapter.NodeTypePredicate matcher,
                                                             String workspaceName,
                                                             Name propertyName,
                                                             org.modeshape.jcr.index.local.LocalEnumeratedIndex index)

      Create an `IndexChangeAdapter` implementation that handles a single-valued enumerated property. Because all enumerated values are distinct, they are treated as strings.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `propertyName` - the name of the property; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forMultiValuedEnumeratedProperty

          public static IndexChangeAdapter forMultiValuedEnumeratedProperty(ExecutionContext context,
                                                            ChangeSetAdapter.NodeTypePredicate matcher,
                                                            String workspaceName,
                                                            Name propertyName,
                                                            org.modeshape.jcr.index.local.LocalEnumeratedIndex index)

      Create an `IndexChangeAdapter` implementation that handles a multi-valued enumerated property. Because all enumerated values are distinct, they are treated as strings.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `propertyName` - the name of the property; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### forNodeTypes

          public static IndexChangeAdapter forNodeTypes(ExecutionContext context,
                                        ChangeSetAdapter.NodeTypePredicate matcher,
                                        String workspaceName,
                                        LocalIndex<String> index)

      Create an `IndexChangeAdapter` implementation that handles node type information.
      Parameters:
        `context` - the execution context; may not be null
        `matcher` - the node type matcher used to determine which nodes should be included in the index; may not be null
        `workspaceName` - the name of the workspace; may not be null
        `index` - the local index that should be used; may not be null
      Returns:
        the new `IndexChangeAdapter`; never null

    - #### nodeKey

          protected static String nodeKey(NodeKey key)

Copyright © 2008-2014 JBoss, a division of Red Hat. All Rights Reserved.