/*******************************************************************************
 * Copyright (c) 2004, 2007 Boeing.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Boeing - initial API and implementation
 *******************************************************************************/
package org.eclipse.osee.ote.messaging.dds.service;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.osee.ote.messaging.dds.ReturnCode;

/**
 * Provides registration functionality of types that are used in the DDS system. The registry relies on a hash map for
 * optimum performance tuning which can be done via the parameters to the constructor. The registry acts as the
 * authority for types by keeping track of <code>TypeSignature</code>'s.
 * 
 * @author Robert A. Fisher
 * @author David Diepenbrock
 */
public class TypeRegistry {
   private final Map<String, TypeSignature> typeHash;

   /**
    * Create a new <code>TypeRegistry</code> with particular characteristics. This is used by portions of the DDS system
    * for resolving necessary information about types during run time.
    * 
    * @param initialCapacity The initial capacity to create the hash map with
    * @param loadFactor The load factor for the hash map. This specifies how full the map can get before more memory is
    * allocated for the map.
    */
   public TypeRegistry(int initialCapacity, float loadFactor) {
      super();
      typeHash = Collections.synchronizedMap(new HashMap<String, TypeSignature>(initialCapacity, loadFactor));
   }

   /**
    * Register a <code>TypeSignature</code> with the registry.
    * 
    * @see TypeSignature
    * @param signature The signature of the type to register.
    * @return OK if the type was registered. OUT_OF_RESOURCES if a memory error happened, or PRECONDITION_NOT_MET if the
    * signature conflicts with one already registered.
    */
   public ReturnCode register(TypeSignature signature) {
      ReturnCode retCode = ReturnCode.OK;

      TypeSignature checkSignature = typeHash.get(signature.getTypeName());
      // If the signature was not already registered, then add it.
      if (checkSignature == null) {
         try {
            typeHash.put(signature.getTypeName(), signature);
         } catch (OutOfMemoryError er) {
            er.printStackTrace();
            retCode = ReturnCode.OUT_OF_RESOURCES;
         }

         // If the signature was already registered, then make sure the signature is the same
      } else {
         if (!checkSignature.equals(signature)) {
            retCode = ReturnCode.PRECONDITION_NOT_MET;
         }
      }

      return retCode;
   }

   /**
    * Provides the signature for a type with a particular name.
    * 
    * @param typeName The name of the type to lookup
    * @return The appropriate signature for the name as registered with the registry, null if no such signature exists.
    */
   public TypeSignature lookupSignature(String typeName) {
      return typeHash.get(typeName);
   }

   public void clear() {
      typeHash.clear();
   }
}