| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.creadur.whisker.model; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Describes a software license. |
| */ |
| public class License implements Comparable<License> { |
| |
| /** |
| * Is information about source distribution required |
| * by this license? |
| */ |
| private final boolean isSourceRequired; |
| /** Template for license wording. */ |
| private final String baseText; |
| /** Parameters expected by the template. */ |
| private final Collection<String> expectedParameters; |
| /** Identifies this license. */ |
| private final String id; |
| /** Canonical locator for this license. */ |
| private final String url; |
| /** Names this license */ |
| private final String name; |
| |
| /** |
| * Constructs meta-data for a family of licenses. |
| * @param isSourceRequired true if this license requires |
| * information about source distribution to be included |
| * within the distribution |
| * @param baseText a template for the legal text, not null |
| * @param expectedParameters not null |
| * @param id not null |
| * @param url not null |
| * @param name not null |
| */ |
| public License(final boolean isSourceRequired, final String baseText, |
| final Collection<String> expectedParameters, final String id, |
| final String url, final String name) { |
| super(); |
| this.isSourceRequired = isSourceRequired; |
| this.baseText = baseText; |
| this.expectedParameters = Collections |
| .unmodifiableCollection(expectedParameters); |
| this.id = id; |
| this.url = url; |
| this.name = name; |
| } |
| |
| /** |
| * Is source information inclusion required by this |
| * license? |
| * @return true when information about the source |
| * should be included, false otherwise |
| */ |
| public boolean isSourceRequired() { |
| return this.isSourceRequired; |
| } |
| |
| /** |
| * Gets legal text expressing this license. |
| * @return not null |
| * @throws LicenseTemplateException when the text cannot |
| * be created from the template |
| */ |
| public String getText() throws LicenseTemplateException { |
| return getText(null); |
| } |
| |
| /** |
| * Gets legal text expressing this license, |
| * |
| * @param parameters possibly null |
| * @return not null |
| * @throws LicenseTemplateException when the text cannot |
| * be created from the template |
| */ |
| public String getText(final Map<String, String> parameters) |
| throws LicenseTemplateException { |
| return substituteInto(validate(parameters), this.baseText); |
| } |
| |
| /** |
| * Gets parameters required by the template |
| * to generate a instance of this license family. |
| * @return not null, possibly empty |
| */ |
| public Collection<String> getExpectedParameters() { |
| return this.expectedParameters; |
| } |
| |
| /** |
| * Validates that these given parameters |
| * are suitable for the template expressing the legalise. |
| * @param parameters possibly null |
| * @return parameters, not null |
| * @throws LicenseTemplateException when the parameter |
| * do not fulfill the expectations of the template |
| */ |
| @SuppressWarnings("unchecked") |
| private Map<String, String> validate(final Map<String, String> parameters) |
| throws LicenseTemplateException { |
| if (parameters == null) { |
| return validate(Collections.EMPTY_MAP); |
| } |
| |
| if (this.expectedParameters.isEmpty() && parameters != null |
| && !parameters.isEmpty()) { |
| throw LicenseTemplateException.notLicenseTemplate(parameters, |
| getName()); |
| } |
| |
| if (!parametersMatch(parameters, this.expectedParameters)) { |
| throw LicenseTemplateException.parameterMismatch( |
| this.expectedParameters, parameters.keySet(), getName()); |
| } |
| |
| return parameters; |
| } |
| |
| /** |
| * Do the presented parameters fulfill expectations? |
| * @param parameters possibly null |
| * @param expectedParameters possibly null |
| * @return true when expected and presented parameters |
| * match, false otherwise |
| */ |
| private boolean parametersMatch(final Map<String, String> parameters, |
| final Collection<String> expectedParameters) { |
| final Set<String> keySet = parameters.keySet(); |
| return (keySet.containsAll(expectedParameters) && expectedParameters |
| .containsAll(keySet)); |
| } |
| |
| /** |
| * Translates a parameter name to |
| * the variable style used by the template |
| * @param parameterName not null |
| * @return variable in template format, not null |
| */ |
| private String variable(final String parameterName) { |
| return "${" + parameterName + "}"; |
| } |
| |
| /** |
| * Substitutes parameter values into the variable |
| * in the template legalise, parameterising |
| * an instance of the license family. |
| * @param parameters not null |
| * @param text template text |
| * @return not null |
| */ |
| private String substituteInto(final Map<String, String> parameters, |
| final String text) { |
| String result = text; |
| for (final Map.Entry<String, String> entry : parameters.entrySet()) { |
| result = result.replace(variable(entry.getKey()), entry.getValue()); |
| } |
| return result; |
| } |
| |
| /** |
| * Stores the license by its id. |
| * @param map not null |
| * @return the license stored |
| */ |
| public License storeIn(final Map<String, License> map) { |
| map.put(getId(), this); |
| return this; |
| } |
| |
| /** |
| * Gets the unique identifier for this license. |
| * @return not null |
| */ |
| public String getId() { |
| return this.id; |
| } |
| |
| /** |
| * Gets a locator for this license. |
| * @return not null |
| */ |
| public String getURL() { |
| return this.url; |
| } |
| |
| /** |
| * Gets a name for this license suitable for |
| * display. |
| * @return not null |
| */ |
| public String getName() { |
| return this.name; |
| } |
| |
| /** |
| * @see java.lang.Object#hashCode() |
| */ |
| @Override |
| public int hashCode() { |
| return getId().hashCode(); |
| } |
| |
| /** |
| * @see java.lang.Object#equals(java.lang.Object) |
| */ |
| @Override |
| public boolean equals(final Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| if (obj == null) { |
| return false; |
| } |
| if (getClass() != obj.getClass()) { |
| return false; |
| } |
| final License other = (License) obj; |
| return getId().equals(other); |
| } |
| |
| /** |
| * @see java.lang.Comparable#compareTo(java.lang.Object) |
| */ |
| public int compareTo(final License other) { |
| final int nameDifference = getName().compareTo(other.getName()); |
| return nameDifference == 0 ? getId().compareTo(other.getId()) |
| : nameDifference; |
| } |
| |
| @Override |
| public String toString() { |
| return "License [id=" + this.id + ", name=" + this.name + "]"; |
| } |
| |
| } |