org.modeshape.graph.connector.federation
Class Projection

java.lang.Object
  org.modeshape.graph.connector.federation.Projection

All Implemented Interfaces:

Serializable, Comparable<Projection>

@Immutable
public class Projection
extends Object
implements Comparable<Projection>, Serializable

A projection of content from a source into the integrated/federated repository. Each project consists of a set of rules for a particular source, where each rule defines how content within a source is is project into the repository and how the repository content is projected into the source. Different rule subclasses are used for different types.

See Also:

Serialized Form

Nested Class Summary

static class	Projection.PathRule A rule that is defined with a single path in source and a single path in repository, and which has a set of path exceptions (relative paths below the path in source).
static class	Projection.Rule A rule used within a project do define how content within a source is projected into the federated repository.

Field Summary

protected static List<Method>	parserMethods
protected static Pattern	PATH_RULE_PATTERN
protected static String	PATH_RULE_PATTERN_STRING Pattern that identifies the form: repository_path => source_path [$ exception ]* where the following groups are captured on the first call to Matcher.find(): repository_path source_path and the following groups are captured on subsequent calls to Matcher.find(): exception The regular expression is: ((?

Constructor Summary

Projection(String sourceName, String workspaceName, boolean readOnly, Projection.Rule... rules)
Create a new federated projection for the supplied source, using the supplied rules.

Method Summary

static void	addRuleParser(ClassLoader classLoader, String className, String methodName) Add a static method that can be used to parse rule definition strings.
static void	addRuleParser(Method method) Add a static method that can be used to parse rule definition strings.
int	compareTo(Projection that)
protected boolean	computeSimpleProjection(List<Projection.Rule> rules)
boolean	equals(Object obj)
static Projection.Rule	fromString(String definition, ExecutionContext context) Parse the string form of a rule definition and return the rule
Set<Path>	getPathsInRepository(Path canonicalPathInSource, PathFactory factory) Get the paths in the repository that correspond to the supplied path within the source.
Set<Path>	getPathsInSource(Path canonicalPathInRepository, PathFactory factory) Get the paths in the source that correspond to the supplied path within the repository.
List<Projection.Rule>	getRules() Get the rules that define this projection.
String	getSourceName() Get the name of the source to which this projection applies.
List<Path>	getTopLevelPathsInRepository(PathFactory factory) Get the paths in the repository that serve as top-level nodes exposed by this projection.
String	getWorkspaceName() Get the name of the workspace in the source to which this projection applies.
int	hashCode()
boolean	isReadOnly() Determine whether the content projected by this projection is read-only.
boolean	isSimple() Determine whether this project is a simple projection that only involves for any one repository path no more than a single source path.
boolean	isTopLevelPath(Path repositoryPath) Determine whether the supplied repositoryPath is considered one of the top-level nodes in this projection.
static Projection.PathRule	parsePathRule(String definition, ExecutionContext context) Parse the string definition of a Projection.PathRule.
static boolean	removeRuleParser(Method method) Remove the rule parser method.
static boolean	removeRuleParser(String declaringClassName, String methodName) Remove the rule parser method.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

parserMethods

protected static final List<Method> parserMethods

PATH_RULE_PATTERN_STRING

protected static final String PATH_RULE_PATTERN_STRING

Pattern that identifies the form:

    repository_path => source_path [$ exception ]*
 

where the following groups are captured on the first call to Matcher.find():

1. repository_path
2. source_path

and the following groups are captured on subsequent calls to Matcher.find():

1. exception

The regular expression is:

 ((?:[ˆ=$]|=(?!>))+)(?:(?:=>((?:[ˆ=$]|=(?!>))+))( \$ (?:(?:[ˆ=]|=(?!>))+))*)?
 

See Also:

Constant Field Values

PATH_RULE_PATTERN

protected static final Pattern PATH_RULE_PATTERN

Constructor Detail

Projection

public Projection(String sourceName,
                  String workspaceName,
                  boolean readOnly,
                  Projection.Rule... rules)

Create a new federated projection for the supplied source, using the supplied rules.

Parameters:

sourceName - the name of the source

workspaceName - the name of the workspace in the source; may be null if the default workspace is to be used

readOnly - true if this projection is considered read-only, or false if the content of the projection may be modified by the federated clients

rules - the projection rules

Throws:

IllegalArgumentException - if the source name or rule array is null, empty, or contains all nulls

Method Detail

addRuleParser

public static void addRuleParser(Method method)

Add a static method that can be used to parse rule definition strings. These methods must be static, must accept a String definition as the first parameter and an ExecutionContext environment reference as the second parameter, and should return the resulting Projection.Rule (or null if the definition format could not be understood by the method. Any exceptions during invocation will be logged at the trace level.

Parameters:

method - the method to be added

See Also:

addRuleParser(ClassLoader, String, String)

addRuleParser

public static void addRuleParser(ClassLoader classLoader,
                                 String className,
                                 String methodName)
                          throws SecurityException,
                                 NoSuchMethodException,
                                 ClassNotFoundException

Add a static method that can be used to parse rule definition strings. These methods must be static, must accept a String definition as the first parameter and an ExecutionContext environment reference as the second parameter, and should return the resulting Projection.Rule (or null if the definition format could not be understood by the method. Any exceptions during invocation will be logged at the trace level.

Parameters:

classLoader - the class loader that should be used to load the class on which the method is defined; may not be null

className - the name of the class on which the static method is defined; may not be null

methodName - the name of the method

Throws:

SecurityException - if there is a security exception while loading the class or getting the method

NoSuchMethodException - if the method does not exist on the class

ClassNotFoundException - if the class could not be found given the supplied class loader

IllegalArgumentException - if the class loader reference is null, or if the class name or method name are null or empty

See Also:

addRuleParser(Method)

removeRuleParser

public static boolean removeRuleParser(Method method)

Remove the rule parser method.

Parameters:

method - the method to remove

Returns:

true if the method was removed, or false if the method was not a registered rule parser method

removeRuleParser

public static boolean removeRuleParser(String declaringClassName,
                                       String methodName)

Remove the rule parser method.

Parameters:

declaringClassName - the name of the class on which the static method is defined; may not be null

methodName - the name of the method

Returns:

true if the method was removed, or false if the method was not a registered rule parser method

Throws:

IllegalArgumentException - if the class loader reference is null, or if the class name or method name are null or empty

fromString

public static Projection.Rule fromString(String definition,
                                         ExecutionContext context)

Parse the string form of a rule definition and return the rule

Parameters:

definition - the definition of the rule that is to be parsed

context - the environment in which this method is being executed; may not be null

Returns:

the rule, or null if the definition could not be parsed

parsePathRule

public static Projection.PathRule parsePathRule(String definition,
                                                ExecutionContext context)

Parse the string definition of a Projection.PathRule. This method is automatically registered in the parser methods by the static initializer of Projection.

Parameters:

definition - the definition

context - the environment

Returns:

the path rule, or null if the definition is not in the right form

getSourceName

public String getSourceName()

Get the name of the source to which this projection applies.

Returns:

the source name

See Also:

RepositorySource.getName()

getWorkspaceName

public String getWorkspaceName()

Get the name of the workspace in the source to which this projection applies.

Returns:

the workspace name, or null if the default workspace of the source is to be used

getRules

public List<Projection.Rule> getRules()

Get the rules that define this projection.

Returns:

the unmodifiable list of immutable rules; never null

getPathsInSource

public Set<Path> getPathsInSource(Path canonicalPathInRepository,
                                  PathFactory factory)

Get the paths in the source that correspond to the supplied path within the repository. This method computes the paths given all of the rules. In general, most sources will probably project a node onto a single repository node. However, some sources may be configured such that the same node in the repository is a projection of multiple nodes within the source.

Parameters:

canonicalPathInRepository - the canonical path of the node within the repository; may not be null

factory - the path factory; may not be null

Returns:

the set of unique paths in the source projected from the repository path; never null

Throws:

IllegalArgumentException - if the factory reference is null

getPathsInRepository

public Set<Path> getPathsInRepository(Path canonicalPathInSource,
                                      PathFactory factory)

Get the paths in the repository that correspond to the supplied path within the source. This method computes the paths given all of the rules. In general, most sources will probably project a node onto a single repository node. However, some sources may be configured such that the same node in the source is projected into multiple nodes within the repository.

Parameters:

canonicalPathInSource - the canonical path of the node within the source; may not be null

factory - the path factory; may not be null

Returns:

the set of unique paths in the repository projected from the source path; never null

Throws:

IllegalArgumentException - if the factory reference is null

getTopLevelPathsInRepository

public List<Path> getTopLevelPathsInRepository(PathFactory factory)

Get the paths in the repository that serve as top-level nodes exposed by this projection.

Parameters:

factory - the path factory that can be used to create new paths; may not be null

Returns:

the list of top-level paths, in the proper order and containing no duplicates; never null

isTopLevelPath

public boolean isTopLevelPath(Path repositoryPath)

Determine whether the supplied repositoryPath is considered one of the top-level nodes in this projection.

Parameters:

repositoryPath - path in the repository; may not be null

Returns:

true if the supplied repository path is one of the top-level nodes exposed by this projection, or false otherwise

isSimple

public boolean isSimple()

Determine whether this project is a simple projection that only involves for any one repository path no more than a single source path.

Returns:

true if this projection is a simple projection, or false if the projection is not simple (or it cannot be determined if it is simple)

isReadOnly

public boolean isReadOnly()

Determine whether the content projected by this projection is read-only.

Returns:

true if the content is read-only, or false if it can be modified

computeSimpleProjection

protected boolean computeSimpleProjection(List<Projection.Rule> rules)

hashCode

public int hashCode()

Overrides:

hashCode in class Object

See Also:

Object.hashCode()

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

See Also:

Object.equals(java.lang.Object)

compareTo

public int compareTo(Projection that)

Specified by:

compareTo in interface Comparable<Projection>

See Also:

Comparable.compareTo(java.lang.Object)

toString

public String toString()

Overrides:

toString in class Object

See Also:

Object.toString()