/*******************************************************************************
 * Copyright (c) 2006, 2010 Oracle. 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.jpa.core.context;

/**
 * Context persistent <em>attribute</em> (field or property).
 * <p>
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from
 * pioneering adopters on the understanding that any code that uses this API
 * will almost certainly be broken (repeatedly) as the API evolves.
 * 
 * @version 2.3
 * @since 2.0
 */
public interface PersistentAttribute
	extends ReadOnlyPersistentAttribute, AccessHolder
{
	/**
	 * Set the attribute's mapping.
	 * If the specified key is <code>null</code>, clear the specified mapping,
	 * allowing the attribute's mapping to default (if appropriate).
	 * Return the new mapping (which may be a <em>null</em> mapping).
	 */
	AttributeMapping setMappingKey(String key);
}
