Derek Hulley 686ec6479b Further DAO for audit values
- General-purpose property persisting in searchable schema
 - TODO: More high volume tests for general values


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@15556 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
2009-08-03 17:59:05 +00:00

378 lines
11 KiB
Java

/*
* Copyright (C) 2005-2009 Alfresco Software Limited.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* As a special exception to the terms and conditions of version 2.0 of
* the GPL, you may redistribute this Program in connection with Free/Libre
* and Open Source Software ("FLOSS") applications as described in Alfresco's
* FLOSS exception. You should have recieved a copy of the text describing
* the FLOSS exception, and it is also available here:
* http://www.alfresco.com/legal/licensing"
*/
package org.alfresco.repo.domain.propval;
import java.io.Serializable;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.alfresco.util.EqualsHelper;
import org.alfresco.util.Pair;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Entity bean for <b>alf_prop_value</b> table.
* <p>
* Values here are either simple values that can be stored in a <code>long</code>
* or will be references to data in other tables.
*
* @author Derek Hulley
* @since 3.3
*/
public class PropertyValueEntity
{
public static final Long LONG_ZERO = new Long(0L);
public static final Long LONG_ONE = new Long(1L);
public static final Short ORDINAL_NULL = new Short((short)0);
public static final Short ORDINAL_BOOLEAN = new Short((short)1);
public static final Short ORDINAL_LONG = new Short((short)2);
public static final Short ORDINAL_DOUBLE = new Short((short)3);
public static final Short ORDINAL_STRING = new Short((short)4);
public static final Short ORDINAL_SERIALIZABLE = new Short((short)5);
/**
* Enumeration of persisted types for <b>alf_prop_value.persisted_type</b>.
* <p/>
* This enumeration is a helper for the default implementation of the {@link PropertyTypeConverter}
* and should not be used in public interfaces.
*
* @author Derek Hulley
* @since 3.3
*/
public static enum PersistedType
{
NULL
{
@Override
public Short getOrdinalNumber()
{
return ORDINAL_NULL;
}
@Override
public Class<?> getAssociatedClass()
{
throw new UnsupportedOperationException("NULL is a special case and has no associated class.");
}
},
BOOLEAN
{
@Override
public Short getOrdinalNumber()
{
return ORDINAL_BOOLEAN;
}
@Override
public Class<?> getAssociatedClass()
{
return Boolean.class;
}
},
LONG
{
@Override
public Short getOrdinalNumber()
{
return ORDINAL_LONG;
}
@Override
public Class<?> getAssociatedClass()
{
return Long.class;
}
},
DOUBLE
{
@Override
public Short getOrdinalNumber()
{
return ORDINAL_DOUBLE;
}
@Override
public Class<?> getAssociatedClass()
{
return Double.class;
}
},
STRING
{
@Override
public Short getOrdinalNumber()
{
return ORDINAL_STRING;
}
@Override
public Class<?> getAssociatedClass()
{
return String.class;
}
},
SERIALIZABLE
{
@Override
public Short getOrdinalNumber()
{
return ORDINAL_SERIALIZABLE;
}
@Override
public Class<?> getAssociatedClass()
{
return Serializable.class;
}
};
/**
* Fetch the numerical value that will represent the the persisted type. This is done
* explicitly to prevent ordering issues if further types are added.
*
* @return Returns the ordinal number
*/
public abstract Short getOrdinalNumber();
/**
* Get the persisted type's class. This is used for determining the source type when
* converting from persisted values.
*
* @return Returns the class associated with the persisted type
*/
public abstract Class<?> getAssociatedClass();
}
public static final Pair<Short, Serializable> PERSISTED_TYPE_NULL;
/**
* An unmodifiable map of persisted type enums keyed by their ordinal number
*/
public static final Map<Short, PersistedType> persistedTypesByOrdinal;
/**
* An unmodifiable map of persisted type enums keyed by the classes they store
*/
public static final Map<Class<?>, PersistedType> persistedTypesByClass;
static
{
// Create a pair for null values
PERSISTED_TYPE_NULL = new Pair<Short, Serializable>(PersistedType.NULL.getOrdinalNumber(), new Long(0));
// Create the map of ordinal-type
Map<Short, PersistedType> mapOrdinal = new HashMap<Short, PersistedType>(15);
for (PersistedType persistedType : PersistedType.values())
{
mapOrdinal.put(persistedType.getOrdinalNumber(), persistedType);
}
persistedTypesByOrdinal = Collections.unmodifiableMap(mapOrdinal);
// Create the map of class-type
Map<Class<?>, PersistedType> mapClass = new HashMap<Class<?>, PersistedType>(29);
mapClass.put(Boolean.class, PersistedType.BOOLEAN);
mapClass.put(Short.class, PersistedType.LONG);
mapClass.put(Integer.class, PersistedType.LONG);
mapClass.put(Long.class, PersistedType.LONG);
mapClass.put(Float.class, PersistedType.DOUBLE);
mapClass.put(Double.class, PersistedType.DOUBLE);
mapClass.put(String.class, PersistedType.STRING);
mapClass.put(Date.class, PersistedType.LONG);
persistedTypesByClass = Collections.unmodifiableMap(mapClass);
}
private static final Log logger = LogFactory.getLog(PropertyValueEntity.class);
private Long id;
private Short persistedType;
private Long longValue;
private String stringValue;
private Double doubleValue;
private Serializable serializableValue;
public PropertyValueEntity()
{
this.persistedType = PersistedType.NULL.getOrdinalNumber();
this.longValue = LONG_ZERO;
}
@Override
public int hashCode()
{
return (persistedType == null ? 0 : persistedType.intValue()) + (longValue == null ? 0 : longValue.intValue());
}
@Override
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
else if (obj != null && obj instanceof PropertyValueEntity)
{
PropertyValueEntity that = (PropertyValueEntity) obj;
return EqualsHelper.nullSafeEquals(this.persistedType, that.persistedType) &&
EqualsHelper.nullSafeEquals(this.longValue, that.longValue);
}
else
{
return false;
}
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder(512);
sb.append("PropertyValueEntity")
.append("[ ID=").append(id)
.append(", type=").append(persistedType)
.append(", value=").append(longValue)
.append("]");
return sb.toString();
}
/**
* @return Returns the ID-value pair
*/
public Pair<Long, Serializable> getEntityPair()
{
Serializable value = getValue();
return new Pair<Long, Serializable>(id, value);
}
/**
* Gets the value based on the persisted type.
* Note that this is the value <b>as persisted</b> and not the original, client-required
* value.
* @return Returns the persisted value
*/
public Serializable getValue()
{
if (persistedType.equals(PersistedType.NULL.getOrdinalNumber()))
{
return null;
}
else if (persistedType.equals(PersistedType.BOOLEAN.getOrdinalNumber()))
{
return (longValue.longValue() > 0 ? Boolean.TRUE : Boolean.FALSE);
}
else if (persistedType.equals(PersistedType.LONG.getOrdinalNumber()))
{
return longValue;
}
else if (persistedType.equals(PersistedType.DOUBLE.getOrdinalNumber()))
{
return doubleValue;
}
else if (persistedType.equals(PersistedType.STRING.getOrdinalNumber()))
{
return stringValue;
}
else if (persistedType.equals(PersistedType.SERIALIZABLE.getOrdinalNumber()))
{
return serializableValue;
}
else
{
logger.warn("Persisted type code not recognised: " + this.persistedType);
// Return any non-null value and hope it works
if (serializableValue != null)
{
return serializableValue;
}
else if (doubleValue != null)
{
return doubleValue;
}
else if (stringValue != null)
{
return stringValue;
}
else
{
return longValue;
}
}
}
public Long getId()
{
return id;
}
public void setId(Long id)
{
this.id = id;
}
public Short getPersistedType()
{
return persistedType;
}
public void setPersistedType(Short persistedType)
{
this.persistedType = persistedType;
}
public Long getLongValue()
{
return longValue;
}
public void setLongValue(Long longValue)
{
this.longValue = longValue;
}
public String getStringValue()
{
return stringValue;
}
public void setStringValue(String stringValue)
{
this.stringValue = stringValue;
}
public Double getDoubleValue()
{
return doubleValue;
}
public void setDoubleValue(Double doubleValue)
{
this.doubleValue = doubleValue;
}
public Serializable getSerializableValue()
{
return serializableValue;
}
public void setSerializableValue(Serializable serializableValue)
{
this.serializableValue = serializableValue;
}
}