Logo
Distributed Genetic Programming Framework
print print

File org.sfc.code.CodeSession.java

Here you can find all the information about the file org.sfc.code.CodeSession.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-06-14 06:27:24
 * Original Filename: org.sfc.code.CodeSession.java
 * Version          : 1.0.0
 * Last modification: 2006-06-14
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */

 
package org.sfc.code;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.security.CodeSource;
import java.security.ProtectionDomain;
import java.util.Enumeration;
import java.util.Map;
import java.util.jar.Manifest;

import org.sfc.collections.Collections;
import org.sfc.io.IO;
import org.sfc.scoped.DefaultReferenceCounted;
import org.sfc.utils.Typesafe;

/**
 * A code session allows you to access and modify loaded classes.
 * 
 * @author Thomas Weise
 */

public  class CodeSession extends DefaultReferenceCounted
  {
/**
 * The block url.
 */

  static  final URL                BURL ;
/**
 * The block class.
 */

  static  final Class<?>           BCLASS = new Object() {/* */}.getClass();
/**
 * The empty url enumeration.
 */

  static  final Enumeration<URL>   EUE = Typesafe.cast(
                                            Collections.EMPTY_ITERATOR);
  
  static
    {
    URL l_l;
    
    try
      {
      l_l = new URL("http""x", 13411, "x");
      }
    catch(Throwable l_t)
      {
      l_l = null;
      }
    
    BURL = l_l;
    }
  
/**
 * The internally used class loader.
 */

          final BasicClassLoader<?>   m_loader    ;
/**
 * The internal class map.
 */

  private final Map<String, Class<?>> m_classes   ;
/**
 * The internal resource map.
 */

  private final Map<String, URL>      m_resources ;
  
/**
 * Create a new basic code session.
 */

  public  CodeSession()
    {
    super();
    this.m_loader    = this.create_loader();
    this.m_classes   = Collections.create_map(-1);
    this.m_resources = Collections.create_map(-1);
    }

/**
 * Specify a class for a given name.
 * @param p_name    The name to assign the class to.
 * @param p_class   The class to be associated with the given name.
 * @see #remove_class(String)
 */

  public  synchronized  final void  put_class (final String   p_name,
                                               final Class<?> p_class)
    {
    if(p_class != null) this.m_classes.put(p_name, p_class);
    }
  
/**
 * Remove the given class from the specification set. This method does only
 * work for classes that are specified using <code>put_class</code>.
 * @param p_name  The class to be removed.
 * @see #put_class(String, Class)
 */

  public  synchronized  final void  remove_class  (final String p_name)
    {
    this.m_classes.remove(p_name);
    }
  
/**
 * With this method you can prohibit certain classes from being discovered
 * by the class loader.
 * @param p_name  The name of the class to prohibit. It is not possible
 *                from now on to find the class in this session.
 * @see #unblock_class(String)
 */

  public  synchronized  final void  block_class (final String p_name)
    {
    this.m_classes.put(p_name, BCLASS);
    }
  
/**
 * With this method you can stop prohibiting certain classes from being
 * discovered by the class loader.
 * @param p_name  The name of the class to stop to prohibit. It is not
 *                possible from now on to find the class in this session.
 * @see #block_class(String)
 */

  public  synchronized  final void  unblock_class (final String p_name)
    {
    if(this.m_classes.get(p_name) == BCLASS)
      {
      this.m_classes.remove(p_name);
      }
    }
  
/**
 * Get the internally specified class for the name passed in.
 * @param p_name    The name to find a matching class for.
 * @return  The class object associated with that name or
 *          <code>null</code> if none is associated.
 */

  synchronized  Class<?>  get_class_mapping(final String p_name)
    {
    return this.m_classes.get(p_name);
    }
  
  
  
/**
 * Specify a resource for a given name.
 * @param p_name       The name to assign the resource to.
 * @param p_resource   The resource to be associated with the given name.
 * @see #remove_resource(String)
 */

  public  synchronized  final void  put_resource (final String p_name,
                                                  final URL    p_resource)
    {
    if(p_resource != null) this.m_resources.put(p_name, p_resource);
    }
  
/**
 * Remove the given resource from the specification set. This method does
 * only work for resourcees that are specified using
 * <code>put_resource</code>.
 * @param p_name  The resource to be removed.
 * @see #put_resource(String, URL)
 */

  public  synchronized  final void  remove_resource  (final String p_name)
    {
    this.m_resources.remove(p_name);
    }
  
/**
 * With this method you can prohibit certain resourcees from being
 * discovered by the class loader.
 * @param p_name  The name of the resource to prohibit. It is not possible
 *                from now on to find the resource in this session.
 * @see #unblock_resource(String)
 */

  public  synchronized  final void  block_resource (final String p_name)
    {
    this.m_resources.put(p_name, BURL);
    }
  
/**
 * With this method you can stop prohibiting certain resourcees from being
 * discovered by the class loader.
 * @param p_name  The name of the resource to stop to prohibit. It is not
 *                possible from now on to find the resource in this session.
 * @see #block_resource(String)
 */

  public  synchronized  final void  unblock_resource (final String p_name)
    {
    if(this.m_resources.get(p_name) == BURL)
      {
      this.m_resources.remove(p_name);
      }
    }
  
/**
 * Get the internally specified resource for the name passed in.
 * @param p_name    The name to find a matching resource for.
 * @return  The resource object associated with that name or
 *          <code>null</code> if none is associated.
 */

  synchronized  URL  get_resource_mapping(final String p_name)
    {
    return this.m_resources.get(p_name);
    }
  
  
  
/**
 * Internally create the internal class loader.
 * @return The internal class loader to be used.
 */

  BasicClassLoader create_loader()
    {
    return new BasicClassLoader<CodeSession>(this);
    }
    
/**
 * Obtain the class which belongs to the specified name.
 * @param p_name  The binary name of the class to obtain.
 * @return  The class object. 
 */

  public  final Class<?>  get_class (final String p_name)
    {        
    try
      {
      return this.m_loader.loadClass(p_name);
      }
    catch(Throwable l_t)
      {
      return null;
      }
    }
  
/**
 * Obtain an url to the specified resource.
 * @param p_name  The name of the resource.
 * @return  The url to that resource, or <code>null</code> if no such
 *          resource is known.
 */

  public  final URL get_resource (final String p_name)
    {    
    return this.m_loader.getResource(p_name);
    }
  
/**
 * Finds all the resources with the given name. A resource is some data
 * (images, audio, text, etc) that can be accessed by class code in a way
 * that is independent of the location of the code.
 *
 * <p>The name of a resource is a <tt>/</tt>-separated path name that
 * identifies the resource.
 *
 * @param  p_name
 *         The resource name
 *
 * @return  An enumeration of {@link java.net.URL <tt>URL</tt>} objects for
 *          the resource.  If no resources could  be found, the enumeration
 *          will be empty.  Resources that the class loader doesn't have
 *          access to will not be in the enumeration.
 */

  public final Enumeration<URL> get_resources(final String p_name)
    {    
    try
      {
      return this.m_loader.getResources(p_name);
      }
    catch(IOException l_ioe)
      {
      return Typesafe.cast(Collections.EMPTY_ITERATOR);
      }
    }
  
  
/**
 * Add the specified url to the classpath.
 * @param p_url The url to be added.
 */

  public  final void  add_url (final URL p_url)
    {
    this.m_loader.add_url(p_url);
    }
  
  
/**
 * Converts an array of bytes into an instance of class Class,
 * with an optional CodeSource. Before the
 * class can be used it must be resolved.
 * <p>
 * If a non-null CodeSource is supplied a ProtectionDomain is
 * constructed and associated with the class being defined.
 * <p>
 * @param      p_name the expected name of the class, or <code>null</code>
 *                  if not known, using '.' and not '/' as the separator
 *                  and without a trailing ".class" suffix.
 * @param      p_b    the bytes that make up the class data. The bytes in 
 *             positions <code>off</code> through <code>off+len-1</code> 
 *             should have the format of a valid class file as defined 
 *             by the 
 *             <a href="http://java.sun.com/docs/books/vmspec/">Java 
 *             Virtual Machine Specification</a>.
 * @param      p_off  the start offset in <code>b</code> of the class data
 * @param      p_len  the length of the class data
 * @param      p_cs   the associated CodeSource, or <code>null</code> if none
 * @return the <code>Class</code> object created from the data,
 *         and optional CodeSource.
 * @exception  ClassFormatError if the data did not contain a valid class
 * @exception  IndexOutOfBoundsException if either <code>off</code> or 
 *             <code>len</code> is negative, or if 
 *             <code>off+len</code> is greater than <code>b.length</code>.
 *
 * @exception  SecurityException if an attempt is made to add this class
 *             to a package that contains classes that were signed by
 *             a different set of certificates than this class, or if 
 *             the class name begins with "java.".
 */

  public  final Class<?> define_class(final String     p_name,
                                      final byte[]     p_b,
                                      final int        p_off,
                                      final int        p_len,
                                      final CodeSource p_cs)
    {
    return this.m_loader.define_class(p_name, p_b, p_off, p_len, p_cs);
    }

/**
 * Converts a {@link java.nio.ByteBuffer <tt>ByteBuffer</tt>}
 * into an instance of class <tt>Class</tt>, with an optional CodeSource. 
 * Before the class can be used it must be resolved.
 * <p>
 * If a non-null CodeSource is supplied a ProtectionDomain is
 * constructed and associated with the class being defined.
 * <p>
 * @param      p_name the expected name of the class, or <code>null</code>
 *                  if not known, using '.' and not '/' as the separator
 *                  and without a trailing ".class" suffix.
 * @param      p_b    the bytes that make up the class data.  The bytes from positions
 *                  <tt>b.position()</tt> through <tt>b.position() + b.limit() -1</tt>
 *                  should have the format of a valid class file as defined by the
 *                  <a href="http://java.sun.com/docs/books/vmspec/">Java Virtual
 *                  Machine Specification</a>.
 * @param      p_cs   the associated CodeSource, or <code>null</code> if none
 * @return the <code>Class</code> object created from the data,
 *         and optional CodeSource.
 * @exception  ClassFormatError if the data did not contain a valid class
 * @exception  SecurityException if an attempt is made to add this class
 *             to a package that contains classes that were signed by
 *             a different set of certificates than this class, or if 
 *             the class name begins with "java.".
 */

  public  final Class<?> define_class(final String               p_name,
                                      final java.nio.ByteBuffer  p_b,
                                      final CodeSource           p_cs)
    {
    return this.m_loader.define_class(p_name, p_b, p_cs);
    }
  
/**
 * Converts a {@link java.nio.ByteBuffer <tt>ByteBuffer</tt>}
 * into an instance of class <tt>Class</tt>,
 * with an optional <tt>ProtectionDomain</tt>.  If the domain is
 * <tt>null</tt>, then a default domain will be assigned to the class as
 * specified in the documentation for {@link #define_class(String, byte[],
 * int, int)}.  Before the class can be used it must be resolved.
 *
 * <p>The rules about the first class defined in a package determining the set of
 * certificates for the package, and the restrictions on class names are identical
 * to those specified in the documentation for {@link #define_class(String, byte[],
 * int, int, ProtectionDomain)}.
 *
 * <p> An invocation of this method of the form
 * <i>cl</i><tt>.defineClass(</tt><i>name</i><tt>,</tt>
 * <i>bBuffer</i><tt>,</tt> <i>pd</i><tt>)</tt> yields exactly the same
 * result as the statements
 *
 * <blockquote><tt>
 * ...<br>
 * byte[] temp = new byte[</tt><i>bBuffer</i><tt>.java.nio.ByteBuffer#remaining
 * remaining()];<br>
 *     </tt><i>bBuffer</i><tt>.{@link java.nio.ByteBuffer#get(byte[])
 * get}(temp);<br>
 *     return {@link #define_class(String, byte[], int, int, ProtectionDomain)
 * </tt><i>cl</i><tt>.defineClass}(</tt><i>name</i><tt>, temp, 0, temp.length, </tt><i>pd</i><tt>);<br>
 * </tt></blockquote>
 *
 * @param  p_name
 *         The expected <a href="#name">binary name</a. of the class, or
 *         <tt>null</tt> if not known
 *
 * @param  p_b
 *         The bytes that make up the class data. The bytes from positions
 *         <tt>b.position()</tt> through <tt>b.position() + b.limit() -1 </tt>
 *         should have the format of a valid class file as defined by the <a
 *         href="http://java.sun.com/docs/books/vmspec/">Java Virtual
 *         Machine Specification</a>.
 *
 * @param  p_protection_domain
 *         The ProtectionDomain of the class, or <tt>null</tt>.
 *
 * @return  The <tt>Class</tt> object created from the data,
 *          and optional <tt>ProtectionDomain</tt>.
 *
 * @throws  ClassFormatError
 *          If the data did not contain a valid class.
 *
 * @throws  NoClassDefFoundError
 *          If <tt>name</tt> is not equal to the <a href="#name">binary
 *          name</a> of the class specified by <tt>b</tt>
 *
 * @throws  SecurityException
 *          If an attempt is made to add this class to a package that
 *          contains classes that were signed by a different set of
 *          certificates than this class, or if <tt>name</tt> begins with
 *          "<tt>java.</tt>".
 *
 * @see      #define_class(String, byte[], int, int, ProtectionDomain)
 */

  public final Class<?> define_class(
                            final String              p_name,
                            final java.nio.ByteBuffer p_b,
                            final ProtectionDomain    p_protection_domain)
    {
    return this.m_loader.define_class(p_name, p_b, p_protection_domain);
    }
  
  
/**
 * Converts an array of bytes into an instance of class <tt>Class</tt>.
 * Before the <tt>Class</tt> can be used it must be resolved.
 *
 * <p> This method assigns a default {@link java.security.ProtectionDomain
 * <tt>ProtectionDomain</tt>} to the newly defined class.  The
 * <tt>ProtectionDomain</tt> is effectively granted the same set of
 * permissions returned when {@link
 * java.security.Policy#getPermissions(java.security.CodeSource)
 * <tt>Policy.getPolicy().getPermissions(new CodeSource(null, null))</tt>}
 * is invoked.  The default domain is created on the first invocation of
 * {@link #define_class(String, byte[], int, int) <tt>defineClass</tt>},
 * and re-used on subsequent invocations.
 *
 * <p> To assign a specific <tt>ProtectionDomain</tt> to the class, use
 * the {@link #define_class(String, byte[], int, int,
 * java.security.ProtectionDomain) <tt>defineClass</tt>} method that takes a
 * <tt>ProtectionDomain</tt> as one of its arguments.  </p>
 *
 * @param  p_name
 *         The expected <a href="#name">binary name</a> of the class, or
 *         <tt>null</tt> if not known
 *
 * @param  p_b
 *         The bytes that make up the class data.  The bytes in positions
 *         <tt>off</tt> through <tt>off+len-1</tt> should have the format
 *         of a valid class file as defined by the <a
 *         href="http://java.sun.com/docs/books/vmspec/">Java Virtual
 *         Machine Specification</a>.
 *
 * @param  p_off
 *         The start offset in <tt>b</tt> of the class data
 *
 * @param  p_len
 *         The length of the class data
 *
 * @return  The <tt>Class</tt> object that was created from the specified
 *          class data.
 *
 * @throws  ClassFormatError
 *          If the data did not contain a valid class
 *
 * @throws  IndexOutOfBoundsException
 *          If either <tt>off</tt> or <tt>len</tt> is negative, or if
 *          <tt>off+len</tt> is greater than <tt>b.length</tt>.
 *
 * @throws  SecurityException
 *          If an attempt is made to add this class to a package that
 *          contains classes that were signed by a different set of
 *          certificates than this class (which is unsigned), or if
 *          <tt>name</tt> begins with "<tt>java.</tt>".
 *
 * @see  java.security.CodeSource
 * @see  java.security.SecureClassLoader
 */

  public  final Class<?> define_class(final String p_name,
                                      final byte[] p_b,
                                      final int    p_off,
                                      final int    p_len)
  throws ClassFormatError
    {
    return this.m_loader.define_class(p_name, p_b, p_off, p_len);
    }
  
/**
 * Converts an array of bytes into an instance of class <tt>Class</tt>,
 * with an optional <tt>ProtectionDomain</tt>.  If the domain is
 * <tt>null</tt>, then a default domain will be assigned to the class as
 * specified in the documentation for {@link #define_class(String, byte[],
 * int, int)}.  Before the class can be used it must be resolved.
 *
 * <p> The first class defined in a package determines the exact set of
 * certificates that all subsequent classes defined in that package must
 * contain.  The set of certificates for a class is obtained from the
 * {@link java.security.CodeSource <tt>CodeSource</tt>} within the
 * <tt>ProtectionDomain</tt> of the class.  Any classes added to that
 * package must contain the same set of certificates or a
 * <tt>SecurityException</tt> will be thrown.  Note that if
 * <tt>name</tt> is <tt>null</tt>, this check is not performed.
 * You should always pass in the <a href="#name">binary name</a> of the
 * class you are defining as well as the bytes.  This ensures that the
 * class you are defining is indeed the class you think it is.
 *
 * <p> The specified <tt>name</tt> cannot begin with "<tt>java.</tt>", since
 * all classes in the "<tt>java.*</tt> packages can only be defined by the
 * bootstrap class loader.  If <tt>name</tt> is not <tt>null</tt>, it
 * must be equal to the <a href="#name">binary name</a> of the class
 * specified by the byte array "<tt>b</tt>", otherwise a 
 * <tt>NoClassDefFoundError</tt> will be thrown.  </p>
 *
 * @param  p_name
 *         The expected <a href="#name">binary name</a> of the class, or
 *         <tt>null</tt> if not known
 *
 * @param  p_b
 *         The bytes that make up the class data. The bytes in positions
 *         <tt>off</tt> through <tt>off+len-1</tt> should have the format
 *         of a valid class file as defined by the <a
 *         href="http://java.sun.com/docs/books/vmspec/">Java Virtual
 *         Machine Specification</a>.
 *
 * @param  p_off
 *         The start offset in <tt>b</tt> of the class data
 *
 * @param  p_len
 *         The length of the class data
 *
 * @param  p_protection_domain
 *         The ProtectionDomain of the class
 *
 * @return  The <tt>Class</tt> object created from the data,
 *          and optional <tt>ProtectionDomain</tt>.
 *
 * @throws  ClassFormatError
 *          If the data did not contain a valid class
 *
 * @throws  NoClassDefFoundError
 *          If <tt>name</tt> is not equal to the <a href="#name">binary
 *          name</a> of the class specified by <tt>b</tt>
 *
 * @throws  IndexOutOfBoundsException
 *          If either <tt>off</tt> or <tt>len</tt> is negative, or if
 *          <tt>off+len</tt> is greater than <tt>b.length</tt>.
 *
 * @throws  SecurityException
 *          If an attempt is made to add this class to a package that
 *          contains classes that were signed by a different set of
 *          certificates than this class, or if <tt>name</tt> begins with
 *          "<tt>java.</tt>".
 */

  public  final Class<?> define_class(
                              final String           p_name,
                              final byte[]           p_b,
                              final int              p_off,
                              final int              p_len,
                              final ProtectionDomain p_protection_domain)
  throws ClassFormatError
    {
    return this.m_loader.define_class(p_name, p_b, p_off, p_len,
                                      p_protection_domain);
    }
  
  
/**
 * Defines a package by name in this <tt>ClassLoader</tt>.  This allows
 * class loaders to define the packages for their classes. Packages must
 * be created before the class is defined, and package names must be
 * unique within a class loader and cannot be redefined or changed once
 * created.  </p>
 *
 * @param  p_name
 *         The package name
 *
 * @param  p_spec_title
 *         The specification title
 *
 * @param  p_spec_version
 *         The specification version
 *
 * @param  p_spec_vendor
 *         The specification vendor
 *
 * @param  p_impl_title
 *         The implementation title
 *
 * @param  p_impl_version
 *         The implementation version
 *
 * @param  p_impl_vendor
 *         The implementation vendor
 *
 * @param  p_seal_base
 *         If not <tt>null</tt>, then this package is sealed with
 *         respect to the given code source {@link java.net.URL
 *         <tt>URL</tt>}  object.  Otherwise, the package is not sealed.
 *
 * @return  The newly defined <tt>Package</tt> object
 *
 * @throws  IllegalArgumentException
 *          If package name duplicates an existing package either in this
 *          class loader or one of its ancestors
 */

  public  final Package define_package(final String p_name,
                                       final String p_spec_title,
                                       final String p_spec_version,
                                       final String p_spec_vendor,
                                       final String p_impl_title,
                                       final String p_impl_version,
                                       final String p_impl_vendor,
                                       final URL    p_seal_base)
    throws IllegalArgumentException
    {
    return this.m_loader.define_package(p_name, p_spec_title, p_spec_version,
                              p_spec_vendor, p_impl_title, p_impl_version,
                              p_impl_vendor, p_seal_base);
    }
  
  
/**
 * Defines a new package by name in this ClassLoader. The attributes
 * contained in the specified Manifest will be used to obtain package
 * version and sealing information. For sealed packages, the additional
 * URL specifies the code source URL from which the package was loaded.
 *
 * @param p_name  the package name
 * @param p_man   the Manifest containing package version and sealing
 *              information
 * @param p_url   the code source url for the package, or null if none
 * @exception   IllegalArgumentException if the package name duplicates
 *              an existing package either in this class loader or one
 *              of its ancestors
 * @return the newly defined Package object
 */

  public  final Package define_package(final String    p_name,
                                       final Manifest  p_man,
                                       final URL       p_url)
  throws IllegalArgumentException
    {
    return this.m_loader.define_package(p_name, p_man, p_url);
    }
  
/**
 * Returns a <tt>Package</tt> that has been defined by this class loader
 * or any of its ancestors.  </p>
 *
 * @param  p_name
 *         The package name
 *
 * @return  The <tt>Package</tt> corresponding to the given name, or
 *          <tt>null</tt> if not found
 */

  public  final Package get_package(final String p_name)
    {
    return this.m_loader.get_package(p_name);
    }
  
/**
 * Returns all of the <tt>Packages</tt> defined by this class loader and
 * its ancestors.  </p>
 *
 * @return  The array of <tt>Package</tt> objects defined by this
 *          <tt>ClassLoader</tt>
 *
 * @since  1.2
 */

  public  final Package[] get_packages()
    {
    return this.m_loader.get_packages();
    }
  
/**
 * Instantiate a specified class.
 * @param p_class       The full name of the class to be instantiated.
 * @param p_parameters  The parameters for the constructor, use
 *                      <code>null</code> for parameterless constructors.
 * @return  The new instance of the class, or <code>null</code> if no 
 *          instance could be created.
 */

  public  final Object  instantiate (final String   p_class,
                                     final Object[] p_parameters)
    {
    Class<?> l_c;
    
    l_c = this.get_class(p_class);
    if(l_c != null) return Typesafe.instantiate(l_c, p_parameters);
    return null;
    }
  
/**
 * Add a file or a directory to the classpath.
 * @param p_source    The file or directory to be added.
 * @param p_recursive If this parameter <code>true</code> and
 *                    <code>p_source</code> referes to a directory, all
 *                    sub-directories will also be added to the classpath.
 */

  public  final void add_file  (final Object  p_source,
                                final boolean p_recursive)
    {
    File  l_f;
    
    l_f = IO.get_file(p_source);
    if(l_f != null)
      {
      if(p_recursive && l_f.isDirectory()) this.add_dir(l_f);
      else                                 this.add_url(IO.get_url(l_f));
      }
    }
  
/**
 * Add a directory to the classpath.
 * @param p_source    The directory to be added.
 */

  private final void add_dir  (final File    p_source)
    {  
    for(File l_f : (p_source.listFiles()))
      {
      if(l_f.isDirectory()) this.add_dir(l_f);
      }      
     
    this.add_url(IO.get_url(p_source));
    }
  
/**
 * Obtain the urls defining the class path of this code session.
 * @return  The urls defining the class path of this code session.
 */

  public  final URL[] get_urls()
    {
    return this.m_loader.getURLs();
    }
  }

File Information:

file name:CodeSession.java
package:org.sfc.code
qualified name:org.sfc.code.CodeSession.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/code/CodeSession.java
size:27.424 KB (28083 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-06-16 03:48:50 GMT+0000
last access: 2018-04-26 04:07:40 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2018-01-07 12:03:34 GMT+0000 served at 2018-04-26 04:07:40 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo