Logo
Distributed Genetic Programming Framework
print print

File org.sfc.utils.Typesafe.java

Here you can find all the information about the file org.sfc.utils.Typesafe.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2005 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2005-12-13 10:52:43
 * Original Filename: org.sfc.Typesafe.java
 * Version          : 1.0.4
 * Last modification: 2006-06-16
 *                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.utils;

import java.lang.reflect.Constructor;
import java.security.AccessController;
import java.security.PrivilegedAction;

import org.sfc.collections.Arrays;

/**
 * This class allows operations to be performed in a type-safe manner.
 * Some th
 *
 * @author Thomas Weise
 */

public final  class Typesafe
  {
/**
 * Prevent anyone from instantiating this class.
 */

  private Typesafe()
    {
    do_not_call();
    }
  
/**
 * Checks wether an object is an instance of a sfc system class.
 * @param p_object  The object to check.
 * @return  <code>true</code> if it is a sfc system object,
 *          <code>false</code> otherwise.
 */

  public  static  final boolean is_sfc_system_object(final Object p_object)
    {
    return ((p_object != null) &&
            is_sub_package(ROOT_PACKAGE, p_object.getClass().getPackage()));
    }
  
/**
 * Checks wether one package is a sub-package of another one.
 * @param p_root  The root package.
 * @param p_sub   The potential sub package.
 * @return  <code>true</code> if and only if <code>p_sub</code> is a sub-
 *          package of <code>p_root</code>.
 */

  public  static  final boolean is_sub_package  (final  Package p_root,
                                                 final  Package p_sub)
    {
    return ((p_sub != null) && (p_root != null) &&
            p_sub.getName().startsWith(p_root.getName()));
    }
  
/**
 * This method should be called inside methods that must never be invoked,
 * such as private constructors of method collection objects.
 */

  public  static  final void  do_not_call ()
    {
    tunnel_error("This method must not be called.");
    }
   
  
/**
 * Perform a hard-core type cast.
 * @param p_o   The object to cast.
 * @param <T>   The type to cast to.
 * @return  The object casted to that type.
 */

  @SuppressWarnings("unchecked")
  public  static  final <T> T cast  (final Object p_o)
    {
    return ((T)p_o);
    }
  
/**
 * Convert an error to one that does not need a <code>throws</code>- or
 * <code>exceptions</code>-statement.
 * @param p_t The error to convert.
 */

  public  static  final void  tunnel_error  (final Throwable p_t)
    {
    throw new RuntimeException(p_t);
    }
  
  
/**
 * Throw an error that does not need a <code>throws</code>- or
 * <code>exceptions</code>-statement.
 * @param p_cause A string describing the error's cause.
 */

  public  static  final void  tunnel_error  (final String p_cause)
    {
    throw new RuntimeException(p_cause);
    }

/**
 * Returns the class context of the current caller. That is, all the classes
 * whose methods are nested leading to a call to this routine.
 * The count of the classes in this context is the number of methods on the
 * execution stack. The element at index <code>0</code> is the class of the 
 * currently executing method, the element at index <code>1</code> is 
 * the class of that method's caller, and so on. 
 *  
 * @return  A <code>ClassContext</code>-object containing all class whose
 *          methods were called up to this method here.
 * @see ClassContext
 */

  public  static  final ClassContext get_class_context ()
    {
    CallerResolver l_cr;
    
    l_cr = RESOLVER;
    if(l_cr != null)
      {
      return new ClassContext(l_cr.getClassContext());
      }
    
    return EMPTY_CONTEXT;
    }

/**
 * Gets the depth that we're away from the requested class.
 * @param p_class The requested class.
 * @return The depth that we're away from the requested class.
 */

  public  static  final int get_class_depth (final Class p_class)
    {
    return RESOLVER.get_class_depth(p_class);    
    }
  
/**
 * Returns the class from which this method was called.
 * @return The class from which this method was called.
 */

  public  static  final Class<?>  get_current_class()
    {
    return  get_class_context().get(1);
    }

/**
 * Gets a system property.
 * @param p_name  The system property to get.
 * @return  The value of this property.
 */

  public  static  final String   get_system_property(final  String p_name)
    {
    return SYS_PROP.perform(p_name);
    }
  
  
/**
 * A helper class to get the call context. It subclasses SecurityManager
 * to make getClassContext() accessible. An instance of CallerResolver
 * only needs to be created, not installed as an actual security
 * manager.
 * 
 * @author    Thomas Weise
 * <p><i>
 * <b>original:</b> Vladimir Roubtsov<br/>
 * <b>title:</b> Find a way out of the ClassLoader maze<br/>
 * <b>source:</b> <a href="http://www.javaworld.com/javaworld/javaqa/2003-06/01-qa-0606-load.html">
 * javaworld article</a>
 * </i></p>
 */

  private static final class CallerResolver extends SecurityManager
    {      
/**
 * Returns the current execution stack as an array of classes. 
 * <p>
 * The length of the array is the number of methods on the execution 
 * stack. The element at index <code>0</code> is the class of the 
 * currently executing method, the element at index <code>1</code> is 
 * the class of that method's caller, and so on. 
 * </p>
 *
 * @return  the execution stack.
 */

    @Override
    protected final Class[] getClassContext ()
      {
      return super.getClassContext();
      }    
    
/**
 * Gets the depth that we're away from the requested class.
 * @param p_class The requested class.
 * @return The depth that we're away from the requested class.
 */

    final int get_class_depth (final Class p_class)
      {
      Class[] l_c;
      int     l_i, l_j;
      
      l_c = super.getClassContext();
      l_j = l_c.length;
      for(l_i = CONTEXT_RESERVED_CLASSES; l_i < l_j; l_i++)
        {
        if(l_c[l_i] == p_class) return (l_i - CONTEXT_RESERVED_CLASSES);        
        }
      return -1;
      }
    }



/**
 * This class will be used to get a system property.
 *  
 * @author    Thomas Weise 
 */

  private static  final class       SysPropGetter
                        implements  PrivilegedAction<String>
    {
/** the name of the property */
    private String    m_name;
    
/**
 * Get the system property.
 * @param p_name    The name of the property to get.
 * @return The value of the system property.
 */

    final synchronized  String  perform (final  String p_name)
      {
      this.m_name = p_name;
      return AccessController.doPrivileged(this); 
      }

/**
 * Execute the action.
 * @return  The system property.
 */

    public final String run()
      {
      String  l_s;
            
      try
        {
        l_s = System.getProperty(this.m_name);
        if((l_s != null) && (l_s.length() <= 0)) l_s = null;
        }
      catch(Throwable l_t)
        {
        l_s = null;
        }
      
      try
        {
        l_s = ((String)(System.getProperties().get(this.m_name)));
        if((l_s != null) && (l_s.length() <= 0)) l_s = null;
        }
      catch(Throwable l_t)
        {
        //
        }
      
      return l_s;
      }
      
    }


/**
 * Instantiate a specified class.
 * @param p_class       The class to be instantiated.
 * @param p_parameters  The parameters for the constructor, use
 *                      <code>null</code> for parameterless constructors.
 * @param <T>           The type to instantiate.
 * @return  The new instance of the class, or <code>null</code> if no 
 *          instance could be created.
 */

  public  static  final <T> T instantiate (final Class<T> p_class,
                                           final Object[] p_parameters)
    {
    Class[]     l_c;
    int         l_i;
    Constructor l_cc;
    
    if( (p_parameters != null) && ((l_i = p_parameters.length) > 0) )
      {
      l_c = new Class<?>[l_i];
      for(--l_i; l_i >= 0; l_i--)
        {
        l_c[l_i] = ((p_parameters[l_i] != null) ? p_parameters[l_i].getClass()
                                                : Object.class);
        }
      }
    else l_c = Arrays.EMPTY_CLASS_ARRAY;
    
    try
      {
      l_cc = p_class.getDeclaredConstructor(l_c);
      }
    catch(Throwable l_t)
      {
      if(l_c == Arrays.EMPTY_CLASS_ARRAY) return null;
      try
        {
        l_cc = p_class.getDeclaredConstructor(Arrays.EMPTY_CLASS_ARRAY);
        }
      catch(Throwable l_t2)
        {
        return null;
        }
      }
    
    try
      {
      return cast(l_cc.newInstance((l_c != Arrays.EMPTY_CLASS_ARRAY) ?
                                   p_parameters                      :
                                   Arrays.EMPTY_OBJECT_ARRAY));
      }
    catch(Throwable l_t)
      {
      return null;
      }
    } 
  

/**
 * The root package.
 */

  private static  final Package ROOT_PACKAGE = Typesafe.class.getPackage();
/**
 * The count of classes in the class context reserved for internal purposes.
 * @see #get_class_context()
 */

          static final int CONTEXT_RESERVED_CLASSES = 2;
/**
 * The empty class context, to be used if security doesn't allow us to create a new securitymanager.
 */

  private static final ClassContext EMPTY_CONTEXT;
/**
 * The internal helper class to allow the resolving of callers.
 */

  private static final CallerResolver RESOLVER;
/**
 * The getter for system properties.
 */

  private static final SysPropGetter SYS_PROP;
  
/**
 * Disables instantiation of this class.
 */

  static
    {    
    CallerResolver  l_cr;
  
    SYS_PROP = new SysPropGetter();
    
    try
      {
      l_cr = new CallerResolver();      
      }
    catch(Throwable l_t)
      {
      l_cr = null;
      }
          
    RESOLVER = l_cr;
    if(l_cr != null)
      {
      EMPTY_CONTEXT = null;
      }
    else
      {
      EMPTY_CONTEXT = new ClassContext(
                              new Class[CONTEXT_RESERVED_CLASSES]);
      }
    }
  }

File Information:

file name:Typesafe.java
package:org.sfc.utils
qualified name:org.sfc.utils.Typesafe.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/utils/Typesafe.java
size:10.893 KB (11155 B)
uploaded: 2015-07-22 04:11:13 GMT+0000
last update: 2006-06-16 05:28:21 GMT+0000
last access: 2018-01-24 01:18:58 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 2015-07-22 04:10:53 GMT+0000 served at 2018-01-24 01:18:58 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo