/*
    * 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/../../org/apache/ws/scout/registry/infomodel/RegistryObjectImpl.html#RegistryObjectImpl">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");
     }
 }