Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Hibernate OGM, Domain model persistence for NoSQL datastores
   *
   * License: GNU Lesser General Public License (LGPL), version 2.1 or later
   * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
   */
  package org.hibernate.ogm.type.impl;
  
 import java.util.Map;
 
 import org.dom4j.Node;
Not a public API Copied from org.hibernate.type.AbstractStandardBasicType

Author(s):
Emmanuel Bernard
 
 public abstract class AbstractGenericBasicType<T>
 		implements  GridType//BasicType,
 
 	private static final boolean[] TRUE = { true };
 	private static final boolean[] FALSE = { false };
 
 	private final GridValueExtractor<T> typeExtractor;
 	private final GridValueBinder<T> typeBinder;
 
 	public AbstractGenericBasicType(GridTypeDescriptor gridTypeDescriptorJavaTypeDescriptor<T> javaTypeDescriptor) {
 		this. = gridTypeDescriptor;
 		this. = javaTypeDescriptor;
 		this. = gridTypeDescriptor.getExtractorjavaTypeDescriptor );
 		this. = gridTypeDescriptor.getBinderjavaTypeDescriptor );
 	}
 
 	public T fromString(String string) {
 		return .fromStringstring );
 	}
 
 	public String toString(T value) {
 		return .toStringvalue );
 	}
 
 	public T fromStringValue(String xmlthrows HibernateException {
 		return fromStringxml );
 	}
 
 	public String toXMLString(T valueSessionFactoryImplementor factorythrows HibernateException {
 		return toStringvalue );
 	}
 
 	public T fromXMLString(String xmlMapping factorythrows HibernateException {
 		return xml == null || xml.length() == 0 ? null : fromStringValuexml );
 	}
 
 	protected MutabilityPlan<T> getMutabilityPlan() {
 	}
 
 	protected T getReplacement(T original, T target) {
 		if ( !isMutable() ) {
 			return original;
 		}
 		else if ( isEqualoriginaltarget ) ) {
 			return original;
 		}
 		else {
 			return deepCopyoriginal );
 		}
 	}
 
 	public boolean[] toColumnNullness(Object valueMapping mapping) {
 		return value == null ?  : ;
 	}
 
 	public String[] getRegistrationKeys() {
 				: new String[] { getName() };
	}
	protected boolean registerUnderJavaType() {
		return false;
	}
	// final implementations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	}
	}
	public final Class getReturnedClass() {
	}
	public abstract int getColumnSpan(Mapping mappingthrows MappingException;
	public final boolean isAssociationType() {
		return false;
	}
	public final boolean isCollectionType() {
		return false;
	}
	public final boolean isComponentType() {
		return false;
	}
	public final boolean isEntityType() {
		return false;
	}
	public final boolean isAnyType() {
		return false;
	}
	public final boolean isXMLElement() {
		return false;
	}
	@SuppressWarnings({ "unchecked" })
	public final boolean isSame(Object xObject y) {
		return isEqual( (T) x, (T) y );
	}
	@SuppressWarnings({ "unchecked" })
	public final boolean isEqual(Object xObject ySessionFactoryImplementor factory) {
		return isEqual( (T) x, (T) y );
	}
	@SuppressWarnings({ "unchecked" })
	public final boolean isEqual(Object oneObject another) {
		return .areEqual( (T) one, (T) another );
	}
	public final int getHashCode(Object xSessionFactoryImplementor factory) {
		return getHashCodex );
	}
	@SuppressWarnings({ "unchecked" })
	public final int getHashCode(Object x) {
	}
	@SuppressWarnings({ "unchecked" })
	public final int compare(Object xObject y) {
		return .getComparator().compare( (T) x, (T) y );
	}
	public final boolean isDirty(Object oldObject currentSessionImplementor session) {
		return isDirtyoldcurrent );
	}
	public final boolean isDirty(Object oldObject currentboolean[] checkableSessionImplementor session) {
		return checkable[0] && isDirtyoldcurrent );
	}
	protected final boolean isDirty(Object oldObject current) {
		return !isSameoldcurrent );
	}
	public final boolean isModified(
			Object oldHydratedState,
			Object currentState,
			boolean[] checkable,
			SessionImplementor session) {
		return isDirtyoldHydratedStatecurrentState );
	}
	public final Object nullSafeGet(
			Tuple rs,
			String[] names,
			Object owner) {
		return nullSafeGetrsnames[0], session );
	}
	public final Object nullSafeGet(Tuple rsString nameSessionImplementor sessionObject owner) {
		return nullSafeGetrsnamesession );
	}
	private T nullSafeGet(Tuple rsString namefinal SessionImplementor session) {
		return nullSafeGetrsname, (WrapperOptionsnull );
	}
	protected final T nullSafeGet(Tuple rsString nameWrapperOptions options) {
		return .extractrsname );
	}
//	public Object get(Map<String,Object> rs, String name, SessionImplementor session) throws HibernateException, SQLException {
//		return nullSafeGet( rs, name, session );
//	}
	@SuppressWarnings({ "unchecked" })
	public final void nullSafeSet(
			Tuple rs,
			Object value,
			String[] names,
			final SessionImplementor session)  {
		nullSafeSetrsvaluenames, (WrapperOptionsnull );
	}
	@SuppressWarnings({ "unchecked" })
	protected final void nullSafeSet(Tuple rsObject valueString[] namesWrapperOptions options) {
		.bindrs, (T) valuenames );
	}
	public final void nullSafeSet(Tuple stObject valueString[] namesboolean[] settableSessionImplementor session)
		if (settable.length > 1) {
			throw new NotYetImplementedException("Multi column property not implemented yet");
		}
		if ( settable[0] ) {
			nullSafeSetstvaluenamessession );
		}
	}
//	public void set(PreparedStatement st, T value, int index, SessionImplementor session) throws HibernateException, SQLException {
//		nullSafeSet( st, value, index, session );
//	}
	@SuppressWarnings({ "unchecked" })
	public final String toLoggableString(Object valueSessionFactoryImplementor factory) {
	}
	@SuppressWarnings({ "unchecked" })
	public final void setToXMLNode(Node nodeObject valueSessionFactoryImplementor factory) {
		node.setTexttoString( (T) value ) );
	}
	public final Object fromXMLNode(Node xmlMapping factory) {
		return fromStringxml.getText() );
	}
	public final boolean isMutable() {
	}
	@SuppressWarnings({ "unchecked" })
	public Object deepCopy(Object valueSessionFactoryImplementor factorythrows HibernateException {
		return deepCopy( (T) value );
	}
	protected final T deepCopy(T value) {
		return getMutabilityPlan().deepCopyvalue );
	}
	@SuppressWarnings({ "unchecked" })
	public final Serializable disassemble(Object valueSessionImplementor sessionObject ownerthrows HibernateException {
		return getMutabilityPlan().disassemble( (T) value );
	}
	public final Object assemble(Serializable cachedSessionImplementor sessionObject ownerthrows HibernateException {
		return getMutabilityPlan().assemblecached );
	}
	public final void beforeAssemble(Serializable cachedSessionImplementor session) {
	}
	public final Object hydrate(Tuple rsString[] namesSessionImplementor sessionObject owner)
		return nullSafeGetrsnamessessionowner );
	}
	public final Object resolve(Object valueSessionImplementor sessionObject ownerthrows HibernateException {
		return value;
	}
	public final Object semiResolve(Object valueSessionImplementor sessionObject ownerthrows HibernateException {
		return value;
	}
		return this;
	}
	@SuppressWarnings({ "unchecked" })
	public final Object replace(Object originalObject targetSessionImplementor sessionObject ownerMap copyCache) {
		return getReplacement( (T) original, (T) target );
	}
	@SuppressWarnings({ "unchecked" })
	public Object replace(
			Object original,
			Object target,
			Object owner,
			Map copyCache,
			ForeignKeyDirection foreignKeyDirection) {
		return . == foreignKeyDirection
getReplacement( (T) original, (T) target )
target;
	}
New to GrepCode? Check out our FAQ X