| /* |
| * Copyright 2001-2004 The Apache Software Foundation. |
| * |
| * Licensed 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.ws.scout.registry.infomodel; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Set; |
| |
| import javax.xml.registry.JAXRException; |
| import javax.xml.registry.LifeCycleManager; |
| import javax.xml.registry.UnsupportedCapabilityException; |
| import javax.xml.registry.infomodel.Association; |
| import javax.xml.registry.infomodel.Classification; |
| import javax.xml.registry.infomodel.Concept; |
| import javax.xml.registry.infomodel.ExternalIdentifier; |
| import javax.xml.registry.infomodel.ExternalLink; |
| import javax.xml.registry.infomodel.InternationalString; |
| import javax.xml.registry.infomodel.Key; |
| import javax.xml.registry.infomodel.Organization; |
| import javax.xml.registry.infomodel.RegistryObject; |
| |
| /** |
| * Implements RegistryObject Interface |
| * Implements JAXR Interface. |
| * For futher details, look into the JAXR API Javadoc. |
| * |
| * @author <a href="mailto:anil@apache.org">Anil Saldhana</a> |
| * @author <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a> |
| */ |
| public class RegistryObjectImpl extends ExtensibleObjectImpl implements RegistryObject |
| { |
| private final LifeCycleManager lifeCycleManager; |
| private Key key; |
| private InternationalString name = new InternationalStringImpl(); |
| private InternationalString desc = new InternationalStringImpl(); |
| |
| private Set<Classification> classifications = new HashSet<Classification>(); |
| private Set<Association> associations = new HashSet<Association>(); |
| private Set<ExternalIdentifier> externalIds = new HashSet<ExternalIdentifier>(); |
| private Set<ExternalLink> externalLinks = new HashSet<ExternalLink>(); |
| |
| //TODO never assigned |
| private OrganizationImpl submittingOrganization; |
| |
| public RegistryObjectImpl(LifeCycleManager lifeCycleManager) |
| { |
| this.lifeCycleManager = lifeCycleManager; |
| } |
| |
| public RegistryObjectImpl(LifeCycleManager lifeCycleManager, InternationalString n) |
| { |
| this.lifeCycleManager = lifeCycleManager; |
| name = n; |
| } |
| |
| public Key getKey() |
| { |
| return key; |
| } |
| |
| public InternationalString getDescription() |
| { |
| return desc; |
| } |
| |
| public void setDescription(InternationalString description) |
| { |
| this.desc = description; |
| } |
| |
| public InternationalString getName() |
| { |
| return name; |
| } |
| |
| public void setName(InternationalString name) |
| { |
| this.name = name; |
| } |
| |
| public void setKey(Key k) |
| { |
| key = k; |
| } |
| |
| public String toXML() throws JAXRException |
| { |
| throw new UnsupportedCapabilityException("toXML is not supported"); |
| } |
| |
| public void addClassification(Classification classification) |
| { |
| classifications.add(classification); |
| } |
| |
| public void addClassifications(Collection collection) |
| { |
| if (collection!=null) { |
| for (Object classification : collection) { |
| classifications.add((Classification)classification); |
| } |
| } |
| } |
| |
| public void removeClassification(Classification classification) |
| { |
| classifications.remove(classification); |
| } |
| |
| public void removeClassifications(Collection collection) |
| { |
| classifications.removeAll(collection); |
| } |
| |
| public Collection getClassifications() |
| { |
| return Collections.unmodifiableSet(classifications); |
| } |
| |
| public void setClassifications(Collection collection) |
| { |
| Set<Classification> newClassifications = new HashSet<Classification>(collection.size()); |
| for (Object classification : collection) { |
| newClassifications.add((Classification) classification); |
| } |
| classifications = newClassifications; |
| } |
| |
| /** |
| * Adds specified Association to use this object as source. |
| * Silently replaces the sourceObject in Association with |
| * reference to this object. |
| * |
| * @param association association to add |
| * @throws JAXRException |
| */ |
| public void addAssociation(Association association) |
| throws JAXRException |
| { |
| associations.add(association); |
| |
| association.setSourceObject(this); |
| } |
| |
| public void addAssociations(Collection collection) throws JAXRException |
| { |
| for (Object association : collection) { |
| addAssociation((Association) association); |
| } |
| } |
| |
| public Collection<Association> getAssociations() throws JAXRException |
| { |
| return Collections.unmodifiableSet(associations); |
| } |
| |
| public void setAssociations(Collection collection) |
| { |
| Set<Association> newAssociations = new HashSet<Association>(collection.size()); |
| for (Object association : collection) { |
| newAssociations.add((Association) association); |
| } |
| associations = newAssociations; |
| } |
| |
| public void removeAssociation(Association association) |
| { |
| associations.remove(association); |
| } |
| |
| public void removeAssociations(Collection collection) |
| { |
| associations.removeAll(collection); |
| } |
| |
| public void addExternalIdentifier(ExternalIdentifier externalIdentifier) |
| { |
| externalIds.add(externalIdentifier); |
| ((ExternalIdentifierImpl) externalIdentifier).setRegistryObject(this); |
| } |
| |
| public void addExternalIdentifiers(Collection collection) |
| { |
| if (collection!=null) { |
| for (Object externalId : collection) { |
| externalIds.add((ExternalIdentifier) externalId); |
| ((ExternalIdentifierImpl) externalId).setRegistryObject(this); |
| } |
| } |
| } |
| |
| public void removeExternalIdentifier(ExternalIdentifier externalIdentifier) |
| { |
| externalIds.remove(externalIdentifier); |
| ((ExternalIdentifierImpl) externalIdentifier).setRegistryObject(null); |
| } |
| |
| public void removeExternalIdentifiers(Collection collection) |
| { |
| //Lets clear out the reference to this in the ext id |
| Iterator iter = collection.iterator(); |
| while (iter != null && iter.hasNext()) |
| { |
| ExternalIdentifier externalId = (ExternalIdentifier) iter.next(); |
| ((ExternalIdentifierImpl) externalId).setRegistryObject(null); |
| } |
| externalIds.removeAll(collection); |
| } |
| |
| public Collection<ExternalIdentifier> getExternalIdentifiers() |
| { |
| return Collections.unmodifiableSet(externalIds); |
| } |
| |
| public void setExternalIdentifiers(Collection collection) |
| { |
| Set<ExternalIdentifier> newExternalIds = new HashSet<ExternalIdentifier>(collection.size()); |
| for (Object externalId : collection) { |
| newExternalIds.add((ExternalIdentifier) externalId); |
| } |
| externalIds = newExternalIds; |
| } |
| |
| public void addExternalLink(ExternalLink externalLink) |
| { |
| externalLinks.add(externalLink); |
| ((ExternalLinkImpl) externalLink).addLinkedObject(this); |
| } |
| |
| public void addExternalLinks(Collection collection) |
| { |
| for (Object externalLink : collection) { |
| externalLinks.add((ExternalLink) externalLink); |
| ((ExternalLinkImpl) externalLink).addLinkedObject(this); |
| } |
| } |
| |
| public void removeExternalLink(ExternalLink externalLink) |
| { |
| ((ExternalLinkImpl) externalLink).removeLinkedObject(this); |
| externalLinks.remove(externalLink); |
| } |
| |
| public void removeExternalLinks(Collection collection) |
| { |
| Iterator iter = collection.iterator(); |
| while (iter != null && iter.hasNext()) |
| { |
| ExternalLink externalLink = (ExternalLink) iter.next(); |
| ((ExternalLinkImpl) externalLink).removeLinkedObject(this); |
| } |
| externalLinks.removeAll(collection); |
| } |
| |
| public Collection<ExternalLink> getExternalLinks() |
| { |
| return Collections.unmodifiableSet(externalLinks); |
| } |
| |
| public void setExternalLinks(Collection collection) |
| { |
| Set<ExternalLink> newExternalLinks = new HashSet<ExternalLink>(collection.size()); |
| for (Object externalLink : collection) { |
| newExternalLinks.add((ExternalLink) externalLink); |
| } |
| externalLinks = newExternalLinks; |
| } |
| |
| public Organization getSubmittingOrganization() |
| { |
| return submittingOrganization; |
| } |
| |
| public LifeCycleManager getLifeCycleManager() |
| { |
| return lifeCycleManager; |
| } |
| |
| /** |
| * The spec does not define how equality is defined for RegistryObject's. |
| * We choose to define it as having the same class and key value; if the |
| * key is null then the objects are not equal. |
| * |
| * @param obj the object to compare to |
| * @return true if the other object is of the same class and has the same key value |
| */ |
| public boolean equals(Object obj) |
| { |
| if (obj == this) return true; |
| if (obj == null || !this.getClass().equals(obj.getClass())) return false; |
| final RegistryObjectImpl other = (RegistryObjectImpl) obj; |
| return this.key != null && key.equals(other.key); |
| } |
| |
| public int hashCode() |
| { |
| return key == null ? 0 : key.hashCode(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Level 1 features must throw exceptions |
| /////////////////////////////////////////////////////////////////////////// |
| |
| public Collection getAuditTrail() throws JAXRException |
| { |
| throw new UnsupportedCapabilityException("Level 1 feature"); |
| } |
| |
| public Collection getAssociatedObjects() throws JAXRException |
| { |
| throw new UnsupportedCapabilityException("Level 1 feature"); |
| } |
| |
| public Concept getObjectType() throws JAXRException |
| { |
| throw new UnsupportedCapabilityException("Level 1 feature"); |
| } |
| |
| public Collection getRegistryPackages() throws JAXRException |
| { |
| throw new UnsupportedCapabilityException("Level 1 feature"); |
| } |
| } |