%line	%branch
org.apache.jcs.engine.ElementAttributes	70%	100%

1		package org.apache.jcs.engine;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.io.ByteArrayInputStream;
23		import java.io.ByteArrayOutputStream;
24		import java.io.ObjectInputStream;
25		import java.io.ObjectOutputStream;
26		import java.io.Serializable;
27		import java.util.ArrayList;
28		import java.util.Iterator;
29
30		import org.apache.jcs.engine.behavior.IElementAttributes;
31		import org.apache.jcs.engine.control.event.behavior.IElementEventHandler;
32
33		/**
34		* This it the element attribute descriptor class. Each element in the cache has
35		* an ElementAttribute object associated with it. An ElementAttributes object
36		* can be associated with an element in 3 ways:
37		* <ol>
38		* <li>When the item is put into the cache, you can associate an element
39		* attributes object.</li>
40		* <li>If not attributes object is include when the element is put into the
41		* cache, then the default attributes for the region will be used.</li>
42		* <li>The element attributes can be reset. This effectively results in a
43		* retrieval followed by a put. Hence, this is the same as 1.</li>
44		* </ol>
45		* @version $Id: ILateralCacheTCPListener.java,v 1.2 2002/01/18 22:08:26
46		*/
47		public class ElementAttributes
48		implements IElementAttributes, Serializable, Cloneable
49		{
50		private static final long serialVersionUID = 7814990748035017441L;
51
52		/**
53		* Can this item be flushed to disk
54		*/
55	1702803	public boolean IS_SPOOL = true;
56
57		/**
58		* Is this item laterally distributable
59		*/
60	1702852	public boolean IS_LATERAL = true;
61
62		/**
63		* Can this item be sent to the remote cache
64		*/
65	1702863	public boolean IS_REMOTE = true;
66
67		/**
68		* You can turn off expiration by setting this to true. This causes the
69		* cache to bypass both max life and idle time expiration.
70		*/
71	1702864	public boolean IS_ETERNAL = true;
72
73		/**
74		* The object version. This is currently not used.
75		*/
76	1702892	public long version = 0;
77
78		/**
79		* Max life seconds
80		*/
81	1702871	public long maxLifeSeconds = -1;
82
83		/**
84		* The maximum time an entry can be idle. Setting this to -1 causes the idle
85		* time check to be ignored.
86		*/
87	1702814	public long maxIdleTimeSeconds = -1;
88
89		/**
90		* The byte size of the field. Must be manually set.
91		*/
92	1702914	public int size = 0;
93
94		/**
95		* The creation time. This is used to enforce the max life.
96		*/
97	1702921	public long createTime = 0;
98
99		/**
100		* The last access time. This is used to enforce the max idel time.
101		*/
102	1702832	public long lastAccessTime = 0;
103
104		/**
105		* The list of Event handlers to use. This is transient, since the event
106		* handlers cannot usually be serialized. This means that you cannot attach
107		* a post serialization event to an item.
108		* <p>
109		* TODO we need to check that when an item is passed to a non-local cache
110		* that if the local cache had a copy with event handlers, that those
111		* handlers are used.
112		*/
113		public transient ArrayList eventHandlers;
114
115		/**
116		* Constructor for the IElementAttributes object
117		*/
118	73075	public ElementAttributes()
119	1629529	{
120	1702675	this.createTime = System.currentTimeMillis();
121	1702875	this.lastAccessTime = class="keyword">this.createTime;
122	1702788	}
123
124		/**
125		* Constructor for the IElementAttributes object
126		* <p>
127		* @param attr
128		*/
129		protected ElementAttributes( ElementAttributes attr )
130	0	{
131	0	IS_ETERNAL = attr.IS_ETERNAL;
132
133		// waterfal onto disk, for pure disk set memory to 0
134	0	IS_SPOOL = attr.IS_SPOOL;
135
136		// lateral
137	0	IS_LATERAL = attr.IS_LATERAL;
138
139		// central rmi store
140	0	IS_REMOTE = attr.IS_REMOTE;
141
142	0	maxLifeSeconds = attr.maxLifeSeconds;
143		// timetolive
144	0	maxIdleTimeSeconds = attr.maxIdleTimeSeconds;
145	0	size = attr.size;
146	0	}
147
148		/**
149		* Copies the attributes, including references to event handlers.
150		* <p>
151		* @return a copy of the Attributes
152		*/
153		public IElementAttributes copy()
154		{
155		try
156		{
157		// need to make this more efficient. Just want to insure
158		// a proper copy
159	1692055	ElementAttributes attr = new ElementAttributes();
160	1692297	attr.setIdleTime( this.getIdleTime() );
161	1692416	attr.setIsEternal( this.getIsEternal() );
162	1692443	attr.setIsLateral( this.getIsLateral() );
163	1692350	attr.setIsRemote( this.getIsRemote() );
164	1692451	attr.setIsSpool( this.getIsSpool() );
165	1692281	attr.setMaxLifeSeconds( this.getMaxLifeSeconds() );
166	1692293	attr.addElementEventHandlers( this.eventHandlers );
167	1692337	return attr;
168		}
169	0	catch ( Exception e )
170		{
171	0	return new ElementAttributes();
172		}
173		}
174
175		/**
176		* Deep clone the attributes.
177		* <p>
178		* @return a clone of these attributes
179		*/
180		public Object clone2()
181		{
182		try
183		{
184	0	ByteArrayOutputStream baos = new ByteArrayOutputStream( 100 );
185	0	ObjectOutputStream oos = new ObjectOutputStream( baos );
186	0	oos.writeObject( this );
187	0	byte buf[] = baos.toByteArray();
188	0	oos.close();
189
190		// deserialize byte array into ArrayList
191
192	0	ByteArrayInputStream bais = new ByteArrayInputStream( buf );
193	0	ObjectInputStream ois = new ObjectInputStream( bais );
194	0	ElementAttributes attr = (ElementAttributes) ois.readObject();
195	0	ois.close();
196
197	0	attr.createTime = System.currentTimeMillis();
198	0	return attr;
199		}
200	0	catch ( Exception e )
201		{
202		// swallow
203		}
204	0	return null;
205		}
206
207		/*
208		* (non-Javadoc)
209		* @see org.apache.jcs.engine.behavior.IElementAttributes#setVersion(long)
210		*/
211		public void setVersion( long version )
212		{
213	0	this.version = version;
214	0	}
215
216		/*
217		* (non-Javadoc)
218		* @see org.apache.jcs.engine.behavior.IElementAttributes#setMaxLifeSeconds(long)
219		*/
220		public void setMaxLifeSeconds( long mls )
221		{
222	1692681	this.maxLifeSeconds = mls;
223	1692696	}
224
225		/*
226		* (non-Javadoc)
227		* @see org.apache.jcs.engine.behavior.IElementAttributes#getMaxLifeSeconds()
228		*/
229		public long getMaxLifeSeconds()
230		{
231	1745353	return this.maxLifeSeconds;
232		}
233
234		/*
235		* (non-Javadoc)
236		* @see org.apache.jcs.engine.behavior.IElementAttributes#setIdleTime(long)
237		*/
238		public void setIdleTime( long idle )
239		{
240	1692339	this.maxIdleTimeSeconds = idle;
241	1692469	}
242
243		/*
244		* (non-Javadoc)
245		* @see org.apache.jcs.engine.behavior.IElementAttributes#setSize(int)
246		*/
247		public void setSize( int size )
248		{
249	0	this.size = size;
250	0	}
251
252		/*
253		* (non-Javadoc)
254		* @see org.apache.jcs.engine.behavior.IElementAttributes#getSize()
255		*/
256		public int getSize()
257		{
258	0	return size;
259		}
260
261		/*
262		* (non-Javadoc)
263		* @see org.apache.jcs.engine.behavior.IElementAttributes#getCreateTime()
264		*/
265		public long getCreateTime()
266		{
267	46599	return createTime;
268		}
269
270		/**
271		* Sets the createTime attribute of the IElementAttributes object
272		*/
273		public void setCreateTime()
274		{
275	0	createTime = System.currentTimeMillis();
276	0	}
277
278		/*
279		* (non-Javadoc)
280		* @see org.apache.jcs.engine.behavior.IElementAttributes#getVersion()
281		*/
282		public long getVersion()
283		{
284	0	return version;
285		}
286
287		/*
288		* (non-Javadoc)
289		* @see org.apache.jcs.engine.behavior.IElementAttributes#getIdleTime()
290		*/
291		public long getIdleTime()
292		{
293	1730384	return this.maxIdleTimeSeconds;
294		}
295
296		/*
297		* (non-Javadoc)
298		* @see org.apache.jcs.engine.behavior.IElementAttributes#getTimeToLiveSeconds()
299		*/
300		public long getTimeToLiveSeconds()
301		{
302	275	long now = System.currentTimeMillis();
303	275	return ( ( this.getCreateTime() + ( class="keyword">this.getMaxLifeSeconds() * 1000 ) ) - now ) / 1000;
304		}
305
306		/*
307		* (non-Javadoc)
308		* @see org.apache.jcs.engine.behavior.IElementAttributes#getLastAccessTime()
309		*/
310		public long getLastAccessTime()
311		{
312	52699	return this.lastAccessTime;
313		}
314
315		/*
316		* (non-Javadoc)
317		* @see org.apache.jcs.engine.behavior.IElementAttributes#setLastAccessTimeNow()
318		*/
319		public void setLastAccessTimeNow()
320		{
321	2399302	this.lastAccessTime = System.currentTimeMillis();
322	2399514	}
323
324		/*
325		* (non-Javadoc)
326		* @see org.apache.jcs.engine.behavior.IElementAttributes#getIsSpool()
327		*/
328		public boolean getIsSpool()
329		{
330	3293787	return this.IS_SPOOL;
331		}
332
333		/*
334		* (non-Javadoc)
335		* @see org.apache.jcs.engine.behavior.IElementAttributes#setIsSpool(boolean)
336		*/
337		public void setIsSpool( boolean val )
338		{
339	1701411	this.IS_SPOOL = val;
340	1701383	}
341
342		/*
343		* (non-Javadoc)
344		* @see org.apache.jcs.engine.behavior.IElementAttributes#getIsLateral()
345		*/
346		public boolean getIsLateral()
347		{
348	1692486	return this.IS_LATERAL;
349		}
350
351		/*
352		* (non-Javadoc)
353		* @see org.apache.jcs.engine.behavior.IElementAttributes#setIsLateral(boolean)
354		*/
355		public void setIsLateral( boolean val )
356		{
357	1692439	this.IS_LATERAL = val;
358	1692506	}
359
360		/**
361		* Can this item be sent to the remote cache
362		* @return true if the item can be sent to a remote auxiliary
363		*/
364		public boolean getIsRemote()
365		{
366	1692465	return this.IS_REMOTE;
367		}
368
369		/**
370		* Sets the isRemote attribute of the ElementAttributes object
371		* @param val
372		* The new isRemote value
373		*/
374		public void setIsRemote( boolean val )
375		{
376	1692474	this.IS_REMOTE = val;
377	1692481	}
378
379		/**
380		* You can turn off expiration by setting this to true. The max life value
381		* will be ignored.
382		* <p>
383		* @return true if the item cannot expire.
384		*/
385		public boolean getIsEternal()
386		{
387	2466481	return this.IS_ETERNAL;
388		}
389
390		/**
391		* Sets the isEternal attribute of the ElementAttributes object. True means
392		* that the item should never expire. If can still be removed if it is the
393		* least recently used, and you are using the LRUMemory cache. it just will
394		* not be filtered for expiration by the cache hub.
395		* <p>
396		* @param val
397		* The new isEternal value
398		*/
399		public void setIsEternal( boolean val )
400		{
401	1692620	this.IS_ETERNAL = val;
402	1692615	}
403
404		/**
405		* Adds a ElementEventHandler. Handler's can be registered for multiple
406		* events. A registered handler will be called at every recognized event.
407		* <p>
408		* The alternative would be to register handlers for each event. Or maybe
409		* The handler interface should have a method to return whether it cares
410		* about certain events.
411		* <p>
412		* @param eventHandler
413		* The ElementEventHandler to be added to the list.
414		*/
415		public void addElementEventHandler( IElementEventHandler eventHandler )
416		{
417		// lazy here, no concurrency problems expected
418	700136	if ( this.eventHandlers == null )
419		{
420	560129	this.eventHandlers = new ArrayList();
421		}
422	700136	this.eventHandlers.add( eventHandler );
423	700136	}
424
425		/**
426		* Sets the eventHandlers of the IElementAttributes object.
427		* <p>
428		* This add the references to the local list. Subsequent changes in the
429		* caller's list will not be reflected.
430		* <p>
431		* @param eventHandlers
432		* List of IElementEventHandler objects
433		*/
434		public void addElementEventHandlers( ArrayList eventHandlers )
435		{
436	1692259	if ( eventHandlers == null )
437		{
438	1132269	return;
439		}
440
441	560028	for ( Iterator iter = eventHandlers.iterator(); iter.hasNext(); )
442		{
443	560028	addElementEventHandler( (IElementEventHandler) iter.next() );
444	560028	}
445	560028	}
446
447		/**
448		* Gets the elementEventHandlers. Returns null if none exist. Makes checking
449		* easy.
450		* <p>
451		* @return The elementEventHandlers List of IElementEventHandler objects
452		*/
453		public ArrayList getElementEventHandlers()
454		{
455	1601633	return this.eventHandlers;
456		}
457
458		/**
459		* For logging and debugging the element IElementAttributes.
460		* <p>
461		* @return String info about the values.
462		*/
463		public String toString()
464		{
465	275	StringBuffer dump = new StringBuffer();
466
467	275	dump.append( "[ IS_LATERAL = " ).append( IS_LATERAL );
468	275	dump.append( ", IS_SPOOL = " ).append( IS_SPOOL );
469	275	dump.append( ", IS_REMOTE = " ).append( IS_REMOTE );
470	275	dump.append( ", IS_ETERNAL = " ).append( IS_ETERNAL );
471	275	dump.append( ", MaxLifeSeconds = " ).append( this.getMaxLifeSeconds() );
472	275	dump.append( ", IdleTime = " ).append( this.getIdleTime() );
473	275	dump.append( ", CreateTime = " ).append( this.getCreateTime() );
474	275	dump.append( ", LastAccessTime = " ).append( this.getLastAccessTime() );
475	275	dump.append( ", getTimeToLiveSeconds() = " ).append( String.valueOf( getTimeToLiveSeconds() ) );
476	275	dump.append( ", createTime = " ).append( String.valueOf( createTime ) ).append( " ]" );
477
478	275	return dump.toString();
479		}
480		}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.