001 /*
002 * JBoss, Home of Professional Open Source.
003 * Copyright 2008, Red Hat Middleware LLC, and individual contributors
004 * as indicated by the @author tags. See the copyright.txt file in the
005 * distribution for a full listing of individual contributors.
006 *
007 * This is free software; you can redistribute it and/or modify it
008 * under the terms of the GNU Lesser General Public License as
009 * published by the Free Software Foundation; either version 2.1 of
010 * the License, or (at your option) any later version.
011 *
012 * This software is distributed in the hope that it will be useful,
013 * but WITHOUT ANY WARRANTY; without even the implied warranty of
014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015 * Lesser General Public License for more details.
016 *
017 * You should have received a copy of the GNU Lesser General Public
018 * License along with this software; if not, write to the Free
019 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
021 */
022 package org.jboss.dna.connector.federation;
023
024 import java.util.ArrayList;
025 import java.util.Collections;
026 import java.util.Iterator;
027 import java.util.List;
028 import net.jcip.annotations.Immutable;
029 import org.jboss.dna.common.collection.Problems;
030 import org.jboss.dna.common.collection.ThreadSafeProblems;
031 import org.jboss.dna.common.util.CheckArg;
032 import org.jboss.dna.graph.cache.CachePolicy;
033 import org.jboss.dna.graph.connectors.RepositorySource;
034
035 /**
036 * The configuration of a federated repository. The configuration defines, among other things, the set of
037 * {@link #getSourceProjections() source projections} in the federated repository that each specify how and where content from a
038 * {@link RepositorySource source} is federated into the unified repository.
039 *
040 * @author Randall Hauch
041 */
042 @Immutable
043 public class FederatedRepositoryConfig implements Comparable<FederatedRepositoryConfig> {
044
045 private final Projection cacheProjection;
046 private final List<Projection> sourceProjections;
047 private final Problems problems;
048 private final String name;
049 private final CachePolicy defaultCachePolicy;
050
051 /**
052 * Create a federated repository instance.
053 *
054 * @param repositoryName the name of the repository
055 * @param cacheProjection the projection used for the cache; may not be null
056 * @param sourceProjections the source projections; may not be null
057 * @param defaultCachePolicy the default cache policy for this repository; may be null
058 * @throws IllegalArgumentException if the name is null or is blank
059 */
060 public FederatedRepositoryConfig( String repositoryName,
061 Projection cacheProjection,
062 Iterable<Projection> sourceProjections,
063 CachePolicy defaultCachePolicy ) {
064 CheckArg.isNotEmpty(repositoryName, "repositoryName");
065 CheckArg.isNotNull(cacheProjection, "cacheProjection");
066 this.name = repositoryName;
067 this.problems = new ThreadSafeProblems();
068 this.defaultCachePolicy = defaultCachePolicy;
069 this.cacheProjection = cacheProjection;
070 List<Projection> projectionList = new ArrayList<Projection>();
071 for (Projection projection : sourceProjections) {
072 if (projection == null) continue;
073 if (!projectionList.contains(projection)) {
074 projectionList.add(projection);
075 }
076 }
077 this.sourceProjections = Collections.unmodifiableList(projectionList);
078 CheckArg.isNotEmpty(this.sourceProjections, "sourceProjections");
079 }
080
081 /**
082 * Get the name of this repository
083 *
084 * @return name
085 */
086 public String getName() {
087 return this.name;
088 }
089
090 /**
091 * Return the problem associated with this configuration. These problems may change at any time, although the returned
092 * {@link Problems} object is thread-safe.
093 *
094 * @return the thread-safe problems for this configuration
095 */
096 public Problems getProblems() {
097 return problems;
098 }
099
100 /**
101 * Get the projection that defines the cache for this repository. This projection does not exist in the
102 * {@link #getSourceProjections() list of source projections}.
103 *
104 * @return the region used for caching; never null
105 */
106 public Projection getCacheProjection() {
107 return cacheProjection;
108 }
109
110 /**
111 * Return the unmodifiable list of source projections.
112 *
113 * @return the source projections; never null and never empty
114 */
115 public List<Projection> getSourceProjections() {
116 return sourceProjections;
117 }
118
119 /**
120 * Get the default cache policy for the repository with the supplied name
121 *
122 * @return the default cache policy
123 */
124 public CachePolicy getDefaultCachePolicy() {
125 return defaultCachePolicy;
126 }
127
128 /**
129 * {@inheritDoc}
130 *
131 * @see java.lang.Object#hashCode()
132 */
133 @Override
134 public int hashCode() {
135 return this.name.hashCode();
136 }
137
138 /**
139 * {@inheritDoc}
140 *
141 * @see java.lang.Object#equals(java.lang.Object)
142 */
143 @Override
144 public boolean equals( Object obj ) {
145 if (obj == this) return true;
146 if (obj instanceof FederatedRepositoryConfig) {
147 FederatedRepositoryConfig that = (FederatedRepositoryConfig)obj;
148 if (!this.getName().equals(that.getName())) return false;
149 if (!this.getCacheProjection().equals(that.getCacheProjection())) return false;
150 if (!this.getSourceProjections().equals(that.getSourceProjections())) return false;
151 return true;
152 }
153 return false;
154 }
155
156 /**
157 * {@inheritDoc}
158 *
159 * @see java.lang.Comparable#compareTo(java.lang.Object)
160 */
161 public int compareTo( FederatedRepositoryConfig that ) {
162 if (that == this) return 0;
163 int diff = this.getName().compareTo(that.getName());
164 if (diff != 0) return diff;
165 diff = this.getCacheProjection().compareTo(that.getCacheProjection());
166 if (diff != 0) return diff;
167 Iterator<Projection> thisIter = this.getSourceProjections().iterator();
168 Iterator<Projection> thatIter = that.getSourceProjections().iterator();
169 while (thisIter.hasNext() && thatIter.hasNext()) {
170 diff = thisIter.next().compareTo(thatIter.next());
171 if (diff != 0) return diff;
172 }
173 if (thisIter.hasNext()) return 1;
174 if (thatIter.hasNext()) return -1;
175 return 0;
176 }
177 }