View Javadoc

1   /*
2    * ModeShape (http://www.modeshape.org)
3    * See the COPYRIGHT.txt file distributed with this work for information
4    * regarding copyright ownership.  Some portions may be licensed
5    * to Red Hat, Inc. under one or more contributor license agreements.
6    * See the AUTHORS.txt file in the distribution for a full listing of 
7    * individual contributors. 
8    *
9    * ModeShape is free software. Unless otherwise indicated, all code in ModeShape
10   * is licensed to you under the terms of the GNU Lesser General Public License as
11   * published by the Free Software Foundation; either version 2.1 of
12   * the License, or (at your option) any later version.
13   *
14   * ModeShape is distributed in the hope that it will be useful,
15   * but WITHOUT ANY WARRANTY; without even the implied warranty of
16   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17   * Lesser General Public License for more details.
18   *
19   * You should have received a copy of the GNU Lesser General Public
20   * License along with this software; if not, write to the Free
21   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
23   */
24  package org.modeshape.repository.sequencer;
25  
26  import java.util.Collection;
27  import java.util.Collections;
28  import java.util.LinkedHashSet;
29  import java.util.Map;
30  import java.util.Set;
31  import net.jcip.annotations.Immutable;
32  import org.modeshape.common.component.ComponentConfig;
33  
34  /**
35   * A configuration for a sequencer.
36   */
37  @Immutable
38  public class SequencerConfig extends ComponentConfig {
39  
40      /**
41       * The name of the property that can be set on any sequencer configuration that specifies whether the output of the sequencer
42       * should replace any existing content that was previously derived from the same input.
43       */
44      public static final String REPLACE_PREVIOUSLY_DERIVED_CONTENT_PROPERTY_NAME = "replacePreviouslyDerivedContent";
45      /**
46       * The default value (of {@value} ) for the {@link #REPLACE_PREVIOUSLY_DERIVED_CONTENT_PROPERTY_NAME property} that controls
47       * whether the output of the sequencer should replace any existing content that was previously derived from the same input.
48       */
49      public static final String DEFAULT_REPLACE_PREVIOUSLY_DERIVED_CONTENT_PROPERTY_VALUE = Boolean.TRUE.toString();
50  
51      private final Set<SequencerPathExpression> pathExpressions;
52  
53      public SequencerConfig( String name,
54                              String description,
55                              String classname,
56                              String[] classpath,
57                              String... pathExpressions ) {
58          this(name, description, System.currentTimeMillis(), null, classname, classpath, pathExpressions);
59      }
60  
61      public SequencerConfig( String name,
62                              String description,
63                              Map<String, Object> properties,
64                              String classname,
65                              String[] classpath,
66                              String... pathExpressions ) {
67          this(name, description, System.currentTimeMillis(), properties, classname, classpath, pathExpressions);
68      }
69  
70      public SequencerConfig( String name,
71                              String description,
72                              long timestamp,
73                              Map<String, Object> properties,
74                              String classname,
75                              String[] classpath,
76                              String... pathExpressions ) {
77          super(name, description, timestamp, properties, classname, classpath);
78          this.pathExpressions = buildPathExpressionSet(pathExpressions);
79      }
80  
81      /* package */static Set<SequencerPathExpression> buildPathExpressionSet( String... pathExpressions ) {
82          Set<SequencerPathExpression> result = null;
83          if (pathExpressions != null) {
84              result = new LinkedHashSet<SequencerPathExpression>();
85              for (String pathExpression : pathExpressions) {
86                  if (pathExpression == null) continue;
87                  pathExpression = pathExpression.trim();
88                  if (pathExpression.length() == 0) continue;
89                  result.add(SequencerPathExpression.compile(pathExpression));
90              }
91              result = Collections.unmodifiableSet(result);
92          } else {
93              result = Collections.emptySet(); // already immutable
94          }
95          return result;
96      }
97  
98      public Collection<SequencerPathExpression> getPathExpressions() {
99          return Collections.unmodifiableSet(this.pathExpressions);
100     }
101 
102     public boolean hasChanged( SequencerConfig that ) {
103         if (super.hasChanged(that)) return true;
104         if (!this.getPathExpressions().equals(that.getPathExpressions())) return true;
105         return false;
106     }
107 
108 }