001         package com.croftsoft.core.util.cache;
002    
003         import java.io.*;
004    
005         import com.croftsoft.core.util.id.Id;
006         import com.croftsoft.core.util.id.IntId;
007    
008         /*********************************************************************
009         * Static methods to support Cache implementations.
010         *
011         * @see
012         *   Cache
013         *
014         * @version
015         *   1999-04-20
016         * @author
017         *   <a href="http://www.CroftSoft.com/">David Wallace Croft</a>
018         *********************************************************************/
019    
020         public class  CacheLib
021         //////////////////////////////////////////////////////////////////////
022         //////////////////////////////////////////////////////////////////////
023         {
024    
025         private  CacheLib ( ) { }
026    
027         //////////////////////////////////////////////////////////////////////
028         // Test methods
029         //////////////////////////////////////////////////////////////////////
030    
031         /*********************************************************************
032         * Tests Cache implementations.
033         *
034         * <PRE>
035         *
036         * if ( args.length < 1 )
037         * {
038         *   System.out.println ( test ( ) );
039         * }
040         * else
041         * {
042         *   System.out.println ( test ( args ) );
043         * }
044         *
045         * </PRE>
046         *
047         * @param  args
048         *   Names of Cache classes.
049         *********************************************************************/
050    /*
051         public static void  main ( String [ ]  args )
052         //////////////////////////////////////////////////////////////////////
053         {
054           if ( args.length < 1 )
055           {
056             System.out.println ( test ( ) );
057           }
058           else
059           {
060             System.out.println ( test ( args ) );
061           }
062         }
063    */
064    
065         /*********************************************************************
066         * Tests the Cache implementations provided in this package.
067         *********************************************************************/
068    /*
069         public static boolean  test ( )
070         //////////////////////////////////////////////////////////////////////
071         {
072           try
073           {
074             return test ( new SoftCache ( ) )
075               &&   test ( new WeakCache ( ) );
076           }
077           catch ( Throwable  t )
078           {
079             t.printStackTrace ( );
080             return false;
081           }
082         }
083    */
084    
085         /*********************************************************************
086         * Tests Cache implementations.
087         *
088         * @param  cacheClassNames
089         *   Names of Cache classes.
090         *********************************************************************/
091    /*
092         public static boolean  test ( String [ ]  cacheClassNames )
093         //////////////////////////////////////////////////////////////////////
094         {
095           try
096           {
097             boolean  result = true;
098    
099             for ( int  i = 0; i < cacheClassNames.length; i++ )
100             {
101               Class  c = Class.forName ( cacheClassNames [ i ] );
102               Cache  cache = ( Cache ) c.newInstance ( );
103               result = test ( cache ) && result;
104               if ( !result ) break;
105             }
106    
107             return result;
108           }
109           catch ( Throwable  t )
110           {
111             t.printStackTrace ( );
112             return false;
113           }
114         }
115    */
116    
117         /*********************************************************************
118         * Tests a Cache implementation.
119         *
120         * @param  cache
121         *   An instance of a Cache to be tested.
122         *********************************************************************/
123    /*
124         public static boolean  test ( Cache  cache )
125         //////////////////////////////////////////////////////////////////////
126         {
127           try
128           {
129             Runtime  runtime = Runtime.getRuntime ( );
130    
131             Id  id0 = null;
132    
133             for ( int  index = 0; index < 1000; index++ )
134             {
135               // System.gc ( );
136    
137               if ( index % 10 == 0 )
138               {
139                 System.out.println (
140                   index + "-:  "
141                   + runtime.freeMemory ( )
142                   + " / "
143                   + runtime.totalMemory ( ) );
144               }
145    
146               String  s = Integer.toString ( index );
147               Id  id = new IntegerId ( index );
148               id = ( Id ) storeString ( cache, s, id ).clone ( );
149    
150               if ( index == 0 )
151               {
152                 id0 = id;
153               }
154    
155               if ( index % 10 == 0 )
156               {
157                 System.out.println (
158                   index + "+:  "
159                   + runtime.freeMemory ( )
160                   + " / "
161                   + runtime.totalMemory ( )
162                   + " "
163                   + retrieveString ( cache, id0 ) );
164               }
165    
166               if ( !s.equals ( retrieveString ( cache, id ) ) )
167               {
168                 return false;
169               }
170             }
171    
172             return true;
173           }
174           catch ( Throwable  t )
175           {
176             t.printStackTrace ( );
177             return false;
178           }
179         }
180    */
181    
182         //////////////////////////////////////////////////////////////////////
183         //////////////////////////////////////////////////////////////////////
184    
185         public static Id  storeString ( Cache  cache, String  s )
186           throws IOException
187         //////////////////////////////////////////////////////////////////////
188         {
189           return cache.store ( toInputStream ( s ) );
190         }
191    
192         public static String  retrieveString ( Cache  cache, Id  id )
193           throws IOException
194         //////////////////////////////////////////////////////////////////////
195         {
196           return toString ( cache.retrieve ( id ) );
197         }
198    
199         //////////////////////////////////////////////////////////////////////
200         //////////////////////////////////////////////////////////////////////
201    
202         public static byte [ ]  toByteArray ( InputStream  in )
203           throws IOException
204         //////////////////////////////////////////////////////////////////////
205         {
206           ByteArrayOutputStream  out = null;
207    
208           try
209           {
210             out = new ByteArrayOutputStream ( );
211    
212             int  i;
213             while ( ( i = in.read ( ) ) > -1 ) out.write ( i );
214    
215             return out.toByteArray ( );
216           }
217           finally
218           {
219             try { in.close  ( ); } catch ( Exception  ex ) { }
220             try { out.close ( ); } catch ( Exception  ex ) { }
221           }
222         }
223    
224         public static InputStream  toInputStream ( String  s )
225         //////////////////////////////////////////////////////////////////////
226         {
227           return toInputStream ( s.getBytes ( ) );
228         }
229    
230         public static InputStream  toInputStream ( byte [ ]  byteArray )
231         //////////////////////////////////////////////////////////////////////
232         {
233           return new ByteArrayInputStream ( byteArray );
234         }
235    
236         public static String  toString ( InputStream  in ) throws IOException
237         //////////////////////////////////////////////////////////////////////
238         {
239           if ( in == null ) return null;
240    
241           ByteArrayOutputStream  out = new ByteArrayOutputStream ( );
242           int  i;
243           while ( ( i = in.read ( ) ) > -1 ) out.write ( i );
244    
245           return new String ( out.toByteArray ( ) );
246         }
247    
248         //////////////////////////////////////////////////////////////////////
249         //////////////////////////////////////////////////////////////////////
250         }