package org.apache.commons.jcs.engine;
/*
* 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.
*/
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.jcs.engine.behavior.IElementAttributes;
import org.apache.commons.jcs.engine.control.event.behavior.IElementEventHandler;
/**
* This it the element attribute descriptor class. Each element in the cache has an ElementAttribute
* object associated with it. An ElementAttributes object can be associated with an element in 3
* ways:
* <ol>
* <li>When the item is put into the cache, you can associate an element attributes object.</li>
* <li>If not attributes object is include when the element is put into the cache, then the default
* attributes for the region will be used.</li>
* <li>The element attributes can be reset. This effectively results in a retrieval followed by a
* put. Hence, this is the same as 1.</li>
* </ol>
*/
public class ElementAttributes
implements IElementAttributes
{
/** Don't change. */
private static final long serialVersionUID = 7814990748035017441L;
/** Can this item be flushed to disk */
private boolean IS_SPOOL = true;
/** Is this item laterally distributable */
private boolean IS_LATERAL = true;
/** Can this item be sent to the remote cache */
private boolean IS_REMOTE = true;
/**
* You can turn off expiration by setting this to true. This causes the cache to bypass both max
* life and idle time expiration.
*/
private boolean IS_ETERNAL = true;
/** Max life seconds */
private long maxLife = -1;
/**
* The maximum time an entry can be idle. Setting this to -1 causes the idle time check to be
* ignored.
*/
private long maxIdleTime = -1;
/** The byte size of the field. Must be manually set. */
private int size = 0;
/** The creation time. This is used to enforce the max life. */
private long createTime = 0;
/** The last access time. This is used to enforce the max idel time. */
private long lastAccessTime = 0;
/**
* The list of Event handlers to use. This is transient, since the event handlers cannot usually
* be serialized. This means that you cannot attach a post serialization event to an item.
* <p>
* TODO we need to check that when an item is passed to a non-local cache that if the local
* cache had a copy with event handlers, that those handlers are used.
*/
private transient ArrayList<IElementEventHandler> eventHandlers;
private long timeFactor = 1000;
/**
* Constructor for the IElementAttributes object
*/
public ElementAttributes()
{
this.createTime = System.currentTimeMillis();
this.lastAccessTime = this.createTime;
}
/**
* Constructor for the IElementAttributes object
* <p>
* @param attr
*/
protected ElementAttributes( ElementAttributes attr )
{
IS_ETERNAL = attr.IS_ETERNAL;
// waterfall onto disk, for pure disk set memory to 0
IS_SPOOL = attr.IS_SPOOL;
// lateral
IS_LATERAL = attr.IS_LATERAL;
// central rmi store
IS_REMOTE = attr.IS_REMOTE;
maxLife = attr.maxLife;
// time-to-live
maxIdleTime = attr.maxIdleTime;
size = attr.size;
}
/**
* Sets the maxLife attribute of the IAttributes object.
* <p>
* @param mls The new MaxLifeSeconds value
*/
@Override
public void setMaxLife(long mls)
{
this.maxLife = mls;
}
/**
* Sets the maxLife attribute of the IAttributes object. How many seconds it can live after
* creation.
* <p>
* If this is exceeded the element will not be returned, instead it will be removed. It will be
* removed on retrieval, or removed actively if the memory shrinker is turned on.
* @return The MaxLifeSeconds value
*/
@Override
public long getMaxLife()
{
return this.maxLife;
}
/**
* Sets the idleTime attribute of the IAttributes object. This is the maximum time the item can
* be idle in the cache, that is not accessed.
* <p>
* If this is exceeded the element will not be returned, instead it will be removed. It will be
* removed on retrieval, or removed actively if the memory shrinker is turned on.
* @param idle The new idleTime value
*/
@Override
public void setIdleTime( long idle )
{
this.maxIdleTime = idle;
}
/**
* Size in bytes. This is not used except in the admin pages. It will be -1 by default.
* <p>
* @param size The new size value
*/
@Override
public void setSize( int size )
{
this.size = size;
}
/**
* Gets the size attribute of the IAttributes object
* <p>
* @return The size value
*/
@Override
public int getSize()
{
return size;
}
/**
* Gets the createTime attribute of the IAttributes object.
* <p>
* This should be the current time in milliseconds returned by the sysutem call when the element
* is put in the cache.
* <p>
* Putting an item in the cache overrides any existing items.
* @return The createTime value
*/
@Override
public long getCreateTime()
{
return createTime;
}
/**
* Sets the createTime attribute of the IElementAttributes object
*/
public void setCreateTime()
{
createTime = System.currentTimeMillis();
}
/**
* Gets the idleTime attribute of the IAttributes object.
* <p>
* @return The idleTime value
*/
@Override
public long getIdleTime()
{
return this.maxIdleTime;
}
/**
* Gets the time left to live of the IAttributes object.
* <p>
* This is the (max life + create time) - current time.
* @return The TimeToLiveSeconds value
*/
@Override
public long getTimeToLiveSeconds()
{
final long now = System.currentTimeMillis();
final long timeFactorForMilliseconds = getTimeFactorForMilliseconds();
return ( this.getCreateTime() + this.getMaxLife() * timeFactorForMilliseconds - now ) / 1000;
}
/**
* Gets the LastAccess attribute of the IAttributes object.
* <p>
* @return The LastAccess value.
*/
@Override
public long getLastAccessTime()
{
return this.lastAccessTime;
}
/**
* Sets the LastAccessTime as now of the IElementAttributes object
*/
@Override
public void setLastAccessTimeNow()
{
this.lastAccessTime = System.currentTimeMillis();
}
/**
* only for use from test code
*/
public void setLastAccessTime(long time)
{
this.lastAccessTime = time;
}
/**
* Can this item be spooled to disk
* <p>
* By default this is true.
* @return The spoolable value
*/
@Override
public boolean getIsSpool()
{
return this.IS_SPOOL;
}
/**
* Sets the isSpool attribute of the IElementAttributes object
* <p>
* By default this is true.
* @param val The new isSpool value
*/
@Override
public void setIsSpool( boolean val )
{
this.IS_SPOOL = val;
}
/**
* Is this item laterally distributable. Can it be sent to auxiliaries of type lateral.
* <p>
* By default this is true.
* @return The isLateral value
*/
@Override
public boolean getIsLateral()
{
return this.IS_LATERAL;
}
/**
* Sets the isLateral attribute of the IElementAttributes object
* <p>
* By default this is true.
* @param val The new isLateral value
*/
@Override
public void setIsLateral( boolean val )
{
this.IS_LATERAL = val;
}
/**
* Can this item be sent to the remote cache
* @return true if the item can be sent to a remote auxiliary
*/
@Override
public boolean getIsRemote()
{
return this.IS_REMOTE;
}
/**
* Sets the isRemote attribute of the ElementAttributes object
* @param val The new isRemote value
*/
@Override
public void setIsRemote( boolean val )
{
this.IS_REMOTE = val;
}
/**
* You can turn off expiration by setting this to true. The max life value will be ignored.
* <p>
* @return true if the item cannot expire.
*/
@Override
public boolean getIsEternal()
{
return this.IS_ETERNAL;
}
/**
* Sets the isEternal attribute of the ElementAttributes object. True means that the item should
* never expire. If can still be removed if it is the least recently used, and you are using the
* LRUMemory cache. it just will not be filtered for expiration by the cache hub.
* <p>
* @param val The new isEternal value
*/
@Override
public void setIsEternal( boolean val )
{
this.IS_ETERNAL = val;
}
/**
* Adds a ElementEventHandler. Handler's can be registered for multiple events. A registered
* handler will be called at every recognized event.
* <p>
* The alternative would be to register handlers for each event. Or maybe The handler interface
* should have a method to return whether it cares about certain events.
* <p>
* @param eventHandler The ElementEventHandler to be added to the list.
*/
@Override
public void addElementEventHandler( IElementEventHandler eventHandler )
{
// lazy here, no concurrency problems expected
if ( this.eventHandlers == null )
{
this.eventHandlers = new ArrayList<IElementEventHandler>();
}
this.eventHandlers.add( eventHandler );
}
/**
* Sets the eventHandlers of the IElementAttributes object.
* <p>
* This add the references to the local list. Subsequent changes in the caller's list will not
* be reflected.
* <p>
* @param eventHandlers List of IElementEventHandler objects
*/
@Override
public void addElementEventHandlers( List<IElementEventHandler> eventHandlers )
{
if ( eventHandlers == null )
{
return;
}
for (IElementEventHandler handler : eventHandlers)
{
addElementEventHandler(handler);
}
}
@Override
public long getTimeFactorForMilliseconds()
{
return timeFactor;
}
@Override
public void setTimeFactorForMilliseconds(long factor)
{
this.timeFactor = factor;
}
/**
* Gets the elementEventHandlers. Returns null if none exist. Makes checking easy.
* <p>
* @return The elementEventHandlers List of IElementEventHandler objects
*/
@Override
public ArrayList<IElementEventHandler> getElementEventHandlers()
{
return this.eventHandlers;
}
/**
* For logging and debugging the element IElementAttributes.
* <p>
* @return String info about the values.
*/
@Override
public String toString()
{
StringBuilder dump = new StringBuilder();
dump.append( "[ IS_LATERAL = " ).append( IS_LATERAL );
dump.append( ", IS_SPOOL = " ).append( IS_SPOOL );
dump.append( ", IS_REMOTE = " ).append( IS_REMOTE );
dump.append( ", IS_ETERNAL = " ).append( IS_ETERNAL );
dump.append( ", MaxLifeSeconds = " ).append( this.getMaxLife() );
dump.append( ", IdleTime = " ).append( this.getIdleTime() );
dump.append( ", CreateTime = " ).append( this.getCreateTime() );
dump.append( ", LastAccessTime = " ).append( this.getLastAccessTime() );
dump.append( ", getTimeToLiveSeconds() = " ).append( String.valueOf( getTimeToLiveSeconds() ) );
dump.append( ", createTime = " ).append( String.valueOf( createTime ) ).append( " ]" );
return dump.toString();
}
/**
* @see java.lang.Object#clone()
*/
@Override
public IElementAttributes clone()
{
try
{
ElementAttributes c = (ElementAttributes) super.clone();
c.setCreateTime();
return c;
}
catch (CloneNotSupportedException e)
{
throw new RuntimeException("Clone not supported. This should never happen.", e);
}
}
}