org.apache.myfaces.trinidad.bean.util.PropertyHashMap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of trinidad-api Show documentation
Show all versions of trinidad-api Show documentation
Public API for the Apache MyFaces Trinidad project
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.myfaces.trinidad.bean.util;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.el.ValueExpression;
import javax.faces.component.PartialStateHolder;
import javax.faces.context.FacesContext;
import org.apache.myfaces.trinidad.bean.FacesBean;
import org.apache.myfaces.trinidad.bean.PropertyKey;
import org.apache.myfaces.trinidad.bean.PropertyMap;
public class PropertyHashMap extends HashMap
implements PropertyMap
{
public PropertyHashMap(
PropertyMap map)
{
super(map);
}
public PropertyHashMap(
int initialCapacity,
float loadFactor)
{
super(initialCapacity, loadFactor);
}
public PropertyHashMap(
int initialCapacity)
{
super(initialCapacity);
}
public PropertyHashMap()
{
super();
}
@Override
public Object put(
PropertyKey key,
Object value)
{
Object retValue = super.put(key, value);
if (_createDeltas())
{
if ( key.getMutable().isAtLeastSometimesMutable() || !_equals(value, retValue))
_deltas.put(key, value);
}
else if (key.getMutable().isAtLeastSometimesMutable() && !(value instanceof ValueExpression))
{
_getMutableTracker(true).addProperty(key);
}
if (key.isPartialStateHolder())
{
_getPartialStateHolderTracker(true).addProperty(key);
}
return retValue;
}
@Override
public Object remove(
Object key)
{
boolean useDeltas = _createDeltas();
if (useDeltas)
{
if (!super.containsKey(key))
return null;
// If this key is contained, it certainly must be a PropertyKey!
assert(key instanceof PropertyKey);
_deltas.put((PropertyKey) key, null);
}
if (key instanceof PropertyKey)
{
PropertyKey propKey = (PropertyKey)key;
if (propKey.isPartialStateHolder())
{
_getPartialStateHolderTracker(true).removeProperty(propKey);
}
if (!useDeltas && propKey.getMutable().isAtLeastSometimesMutable())
{
PropertyTracker mutableTracker = _getMutableTracker(false);
if (mutableTracker != null)
mutableTracker.removeProperty(propKey);
}
}
return super.remove(key);
}
@Override
public void putAll(Map t)
{
boolean useDeltas =_createDeltas();
if (useDeltas)
_deltas.putAll(t);
Set keys = t.keySet();
for (PropertyKey key: keys)
{
if (key.isPartialStateHolder())
{
_getPartialStateHolderTracker(true).addProperty(key);
}
if (!useDeltas && key.getMutable().isAtLeastSometimesMutable())
{
Object value = t.get(key);
if (!(value instanceof ValueExpression))
{
_getMutableTracker(true).addProperty(key);
}
}
}
super.putAll(t);
}
public Object saveState(FacesContext context)
{
if (_initialStateMarked)
{
if (_deltas == null)
{
// if deltas is null still call _createDeltaPropertyMap but pass in false in case there
// are mutable or partialStateHolder attributes
_deltas = _createDeltaPropertyMap(false);
}
if (_deltas == null)
return null;
return StateUtils.saveState(_deltas, context, getUseStateHolder());
}
else
{
return StateUtils.saveState(this, context, getUseStateHolder());
}
}
public void restoreState(
FacesContext context,
FacesBean.Type type,
Object state)
{
StateUtils.restoreState(this, context, type, state, getUseStateHolder());
}
protected PropertyMap createDeltaPropertyMap()
{
return _createDeltaPropertyMap(true);
}
/**
*
* @param createAlways if createAlways is true then always create the map.
* If createAlways is false then only create the map if one of the trackers are empty
*/
private PropertyMap _createDeltaPropertyMap(boolean createAlways)
{
PropertyTracker tracker = _getMutableTracker(false);
PropertyTracker partialTracker = _getPartialStateHolderTracker(false);
// if createAlways is true then always create the map.
// if createAlways is false then only create the map if one of the trackers are empty
if (createAlways || tracker != null || partialTracker != null)
{
PropertyHashMap map = new PropertyHashMap(2);
map.setUseStateHolder(getUseStateHolder());
map.setType(_type);
if (tracker != null)
{
for (PropertyKey key: tracker)
{
Object val = get(key);
if (val != null)
{
map.put(key, val);
}
}
_mutableTracker = null;
}
if (partialTracker != null)
{
for (PropertyKey key: partialTracker)
{
// the key might have been in the mutable tracker, so check if the map already contains the key
if(!map.containsKey(key))
{
Object val = get(key);
if (val != null)
{
map.put(key, val);
}
}
}
}
return map;
}
return null;
}
public boolean getUseStateHolder()
{
return _useStateHolder;
}
public void setUseStateHolder(boolean useStateHolder)
{
_useStateHolder = useStateHolder;
}
// =-=AEW CLEAR?
public void markInitialState()
{
_initialStateMarked = true;
// PropertyTracker uses a bitmask to track properties
// We are tracking all properties that have CA_PARTIAL_STATE_HOLDER capability,
// so that we do not have to check every property here
PropertyTracker tracker = _getPartialStateHolderTracker(false);
if (tracker != null)
{
for (PropertyKey key: tracker)
{
Object val = get(key);
if (val != null)
{
((PartialStateHolder)val).markInitialState();
}
}
}
}
public void clearInitialState()
{
_initialStateMarked = false;
_deltas = null;
// PropertyTracker uses a bitmask to track properties
// We are tracking all properties that have CA_PARTIAL_STATE_HOLDER capability,
// so that we do not have to check every property here
PropertyTracker tracker = _getPartialStateHolderTracker(false);
if (tracker != null)
{
for (PropertyKey key: tracker)
{
Object val = get(key);
if (val != null)
{
((PartialStateHolder)val).clearInitialState();
}
}
}
}
public boolean initialStateMarked()
{
return _initialStateMarked;
}
/**
* Sets the the FacesBean type used by this map's owner bean
* @param type FacesBean type
*/
public void setType(FacesBean.Type type)
{
_type = type;
}
private boolean _createDeltas()
{
if (_initialStateMarked)
{
if (_deltas == null)
{
_deltas = createDeltaPropertyMap();
}
return true;
}
return false;
}
static private boolean _equals(Object a, Object b)
{
if (a == b)
return true;
if (a == null)
return false;
return a.equals(b);
}
private PropertyTracker _getPartialStateHolderTracker(boolean create)
{
if (_tracker == null && create)
{
if (_type == null)
{
throw new IllegalStateException("FacesBean.TYPE is required to track properties");
}
_tracker = new PropertyTracker(_type);
}
return _tracker;
}
private PropertyTracker _getMutableTracker(boolean create)
{
if (_mutableTracker == null && create)
{
if (_type == null)
{
throw new IllegalStateException("FacesBean.TYPE is required to track properties");
}
_mutableTracker = new PropertyTracker(_type);
}
return _mutableTracker;
}
private transient boolean _initialStateMarked;
private transient PropertyMap _deltas;
private boolean _useStateHolder;
private transient FacesBean.Type _type;
private transient PropertyTracker _tracker;
private transient PropertyTracker _mutableTracker;
private static final long serialVersionUID = 1L;
}