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      private final Set<SequencerPathExpression> pathExpressions;
41  
42      public SequencerConfig( String name,
43                              String description,
44                              String classname,
45                              String[] classpath,
46                              String... pathExpressions ) {
47          this(name, description, System.currentTimeMillis(), null, classname, classpath, pathExpressions);
48      }
49  
50      public SequencerConfig( String name,
51                              String description,
52                              Map<String, Object> properties,
53                              String classname,
54                              String[] classpath,
55                              String... pathExpressions ) {
56          this(name, description, System.currentTimeMillis(), properties, classname, classpath, pathExpressions);
57      }
58  
59      public SequencerConfig( String name,
60                              String description,
61                              long timestamp,
62                              Map<String, Object> properties,
63                              String classname,
64                              String[] classpath,
65                              String... pathExpressions ) {
66          super(name, description, timestamp, properties, classname, classpath);
67          this.pathExpressions = buildPathExpressionSet(pathExpressions);
68      }
69  
70      /* package */static Set<SequencerPathExpression> buildPathExpressionSet( String... pathExpressions ) {
71          Set<SequencerPathExpression> result = null;
72          if (pathExpressions != null) {
73              result = new LinkedHashSet<SequencerPathExpression>();
74              for (String pathExpression : pathExpressions) {
75                  if (pathExpression == null) continue;
76                  pathExpression = pathExpression.trim();
77                  if (pathExpression.length() == 0) continue;
78                  result.add(SequencerPathExpression.compile(pathExpression));
79              }
80              result = Collections.unmodifiableSet(result);
81          } else {
82              result = Collections.emptySet(); // already immutable
83          }
84          return result;
85      }
86  
87      public Collection<SequencerPathExpression> getPathExpressions() {
88          return Collections.unmodifiableSet(this.pathExpressions);
89      }
90  
91      public boolean hasChanged( SequencerConfig that ) {
92          if (super.hasChanged(that)) return true;
93          if (!this.getPathExpressions().equals(that.getPathExpressions())) return true;
94          return false;
95      }
96  
97  }