/*
* 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");
}
}