/*		 
 * Copyright (C) 2002-2014 Sebastiano Vigna 
 *
 * 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 PACKAGE;

/** An abstract class providing basic methods for functions implementing a type-specific interface.
 *
 * <P>Optional operations just throw an {@link
 * UnsupportedOperationException}. Generic versions of accessors delegate to
 * the corresponding type-specific counterparts following the interface rules
 * (they take care of returning <code>null</code> on a missing key).
 *
 * <P>This class handles directly a default return
 * value (including {@linkplain #defaultReturnValue() methods to access
 * it}). Instances of classes inheriting from this class have just to return
 * <code>defRetValue</code> to denote lack of a key in type-specific methods. The value
 * is serialized.
 *
 * <P>Implementing subclasses have just to provide type-specific <code>get()</code>,
 * type-specific <code>containsKey()</code>, and <code>size()</code> methods.
 *
 */

public abstract class ABSTRACT_FUNCTION KEY_VALUE_GENERIC implements FUNCTION KEY_VALUE_GENERIC, java.io.Serializable {

	private static final long serialVersionUID = -4940583368468432370L;

	protected ABSTRACT_FUNCTION() {}

	/**
	 * The default return value for <code>get()</code>, <code>put()</code> and
	 * <code>remove()</code>.  
	 */

	protected VALUE_GENERIC_TYPE defRetValue;
	
	public void defaultReturnValue( final VALUE_GENERIC_TYPE rv ) {
		defRetValue = rv;
	}

	public VALUE_GENERIC_TYPE defaultReturnValue() {
		return defRetValue;
	}

	public VALUE_GENERIC_TYPE put( KEY_GENERIC_TYPE key, VALUE_GENERIC_TYPE value ) {
		throw new UnsupportedOperationException();
	}

	public VALUE_GENERIC_TYPE REMOVE_VALUE( KEY_TYPE key ) {
		throw new UnsupportedOperationException();
	}

	public void clear() {
		throw new UnsupportedOperationException();
	}


#if #keys(primitive)
	public boolean containsKey( final Object ok ) {
		return containsKey( KEY_OBJ2TYPE( ok ) );
	}
#endif

#if #keys(primitive) || #values(primitive)
                                                                                                                                             
	/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key.
	 *
	 * <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
	 * it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
	 */
	public VALUE_GENERIC_CLASS get( final Object ok ) {
		final KEY_TYPE k = KEY_OBJ2TYPE( ok );
		return containsKey( k ) ? VALUE2OBJ( GET_VALUE( k ) ) : null;
	}
                                                                                                                                             
	/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key. 
	 *
	 * <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
	 * it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
	 */
	public VALUE_GENERIC_CLASS put( final KEY_GENERIC_CLASS ok, final VALUE_GENERIC_CLASS ov ) {
		final KEY_GENERIC_TYPE k = KEY_CLASS2TYPE( ok );
		final boolean containsKey = containsKey( k );
		final VALUE_GENERIC_TYPE v = put( k, VALUE_CLASS2TYPE( ov ) );
		return containsKey ? VALUE2OBJ( v ) : null;
	}
                                                                                                                                             
	/** Delegates to the corresponding type-specific method, taking care of returning <code>null</code> on a missing key. 
	 *
	 * <P>This method must check whether the provided key is in the map using <code>containsKey()</code>. Thus,
	 * it probes the map <em>twice</em>. Implementors of subclasses should override it with a more efficient method.
	 */
	public VALUE_GENERIC_CLASS remove( final Object ok ) {
		final KEY_TYPE k = KEY_OBJ2TYPE( ok );
		final boolean containsKey = containsKey( k );
		final VALUE_GENERIC_TYPE v = REMOVE_VALUE( k );
		return containsKey ? VALUE2OBJ( v ) : null;
	}
#endif
}