001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: */
018: package org.apache.ivy.core.module.descriptor;
019:
020: import java.util.LinkedHashSet;
021: import java.util.Set;
022:
023: import org.apache.ivy.util.extendable.DefaultExtendableItem;
024:
025: /**
026: * Represents a module configuration
027: */
028: public class Configuration extends DefaultExtendableItem {
029: public static final class Visibility {
030: public static final Visibility PUBLIC = new Visibility("public");
031:
032: public static final Visibility PRIVATE = new Visibility(
033: "private");
034:
035: public static Visibility getVisibility(String name) {
036: if ("private".equals(name)) {
037: return PRIVATE;
038: } else if ("public".equals(name)) {
039: return PUBLIC;
040: } else {
041: throw new IllegalArgumentException(
042: "unknwon visibility " + name);
043: }
044: }
045:
046: private String name;
047:
048: private Visibility(String name) {
049: this .name = name;
050: }
051:
052: public String toString() {
053: return name;
054: }
055: }
056:
057: private String name;
058:
059: private String description;
060:
061: private String[] extendsFrom;
062:
063: private Visibility visibility;
064:
065: private boolean transitive = true;
066:
067: private String deprecated;
068:
069: /**
070: * Creates a new configuration.
071: *
072: * @param name the name of the configuration
073: */
074: public Configuration(String name) {
075: this (name, Visibility.PUBLIC, null, null, true, null);
076: }
077:
078: /**
079: * Creates a new configuration.
080: *
081: * @param name the name of the configuration
082: * @param visibility the visibility of the configuration
083: * @param description a description
084: * @param ext the configurations to extend from
085: * @param transitive indicates if the configuration is transitive
086: * @param deprecated the deprecation message
087: */
088: public Configuration(String name, Visibility visibility,
089: String description, String[] ext, boolean transitive,
090: String deprecated) {
091: if (name == null) {
092: throw new NullPointerException(
093: "null configuration name not allowed");
094: }
095: if (visibility == null) {
096: throw new NullPointerException(
097: "null visibility not allowed");
098: }
099: this .name = name;
100: this .visibility = visibility;
101: this .description = description;
102: if (ext == null) {
103: extendsFrom = new String[0];
104: } else {
105: extendsFrom = new String[ext.length];
106: for (int i = 0; i < ext.length; i++) {
107: extendsFrom[i] = ext[i].trim();
108: }
109: }
110: this .transitive = transitive;
111: this .deprecated = deprecated;
112: }
113:
114: /**
115: * Returns the deprecation message, or <tt>null</tt> if not specified.
116: * @return Returns the deprecation message.
117: */
118: public String getDeprecated() {
119: return deprecated;
120: }
121:
122: /**
123: * @return Returns the description. It may be null.
124: */
125: public String getDescription() {
126: return description;
127: }
128:
129: /**
130: * @return Returns the extends. May be empty, but never null.
131: */
132: public String[] getExtends() {
133: return extendsFrom;
134: }
135:
136: /**
137: * @return Returns the name. Never null;
138: */
139: public String getName() {
140: return name;
141: }
142:
143: /**
144: * @return Returns the visibility. Never null.
145: */
146: public Visibility getVisibility() {
147: return visibility;
148: }
149:
150: /**
151: * @return Returns the transitive.
152: */
153: public final boolean isTransitive() {
154: return transitive;
155: }
156:
157: public String toString() {
158: return name;
159: }
160:
161: public boolean equals(Object obj) {
162: if (!(obj instanceof Configuration)) {
163: return false;
164: }
165: return ((Configuration) obj).getName().equals(getName());
166: }
167:
168: public int hashCode() {
169: return getName().hashCode();
170: }
171:
172: public void replaceWildcards(ModuleDescriptor md) {
173: if (this != md.getConfiguration(name)) {
174: throw new IllegalArgumentException(
175: "The given ModuleDescriptor doesn't own this configuration!");
176: }
177:
178: Configuration[] configs = md.getConfigurations();
179:
180: Set newExtends = new LinkedHashSet();
181: for (int j = 0; j < extendsFrom.length; j++) {
182: if ("*".equals(extendsFrom[j])) {
183: addOther(configs, null, newExtends);
184: } else if ("*(public)".equals(extendsFrom[j])) {
185: addOther(configs, Visibility.PUBLIC, newExtends);
186: } else if ("*(private)".equals(extendsFrom[j])) {
187: addOther(configs, Visibility.PRIVATE, newExtends);
188: } else {
189: newExtends.add(extendsFrom[j]);
190: }
191: }
192:
193: this .extendsFrom = (String[]) newExtends
194: .toArray(new String[newExtends.size()]);
195: }
196:
197: private void addOther(Configuration[] allConfigs,
198: Visibility visibility, Set configs) {
199: for (int i = 0; i < allConfigs.length; i++) {
200: String currentName = allConfigs[i].getName();
201: if (!name.equals(currentName)
202: && ((visibility == null) || visibility
203: .equals(allConfigs[i].getVisibility()))) {
204: configs.add(currentName);
205: }
206: }
207: }
208:
209: }
|