/**
 * Returns an instance of the adaptable object with type of adapterType, or
 * null if the given object could not be adapted to that type. See
 * {@link IAdapterManager#getAdapter(Object, Class)}.
 */
@SuppressWarnings("unchecked")
public static <T> T getAdapter(Object adaptable,
    Class<? extends T> adapterType) {

  /*
   * Try a simple instanceof check. This also safeguards against a misuse of
   * getAdapter. For example, ISelection is adaptable (there is a
   * SelectionAdapterFactory), so the user may incorrectly try adapting it to
   * IStructuredSelection. However, in this case, the implementation of
   * SelectionAdapterFactory would return null.
   */
  if (adapterType.isInstance(adaptable)) {
    return (T) adaptable;
  }
  
  IAdapterManager adapterManager = Platform.getAdapterManager();
  assert (adapterManager != null);
  return (T) adapterManager.getAdapter(adaptable, adapterType);
}
 

/**
 * Tries to adapt each object to the given class.
 *
 * @param objects objects that are tried to adapted
 * @param clazz class to adapt each object to
 * @param adapterManager the adapterManager that is used to adapt the objects
 * @return all objects that were adapted or <code>null</code> if the object array is <code>null
 *     </code>
 */
public static <T> List<T> getAdaptableObjects(
    Object[] objects, Class<? extends T> clazz, IAdapterManager adapterManager) {

  if (objects == null) return null;

  Set<T> adaptableObjects = new HashSet<T>(objects.length);

  for (Object object : objects) {
    T adaptedObject = adapterManager.getAdapter(object, clazz);

    if (adaptedObject != null && !adaptableObjects.contains(adaptedObject)) {
      adaptableObjects.add(adaptedObject);
    }
  }

  return new ArrayList<T>(adaptableObjects);
}
 

@Before
public void createMock() {
  adapterManager = EasyMock.createMock(IAdapterManager.class);
  EasyMock.expect(
          adapterManager.getAdapter(EasyMock.anyObject(), EasyMock.anyObject(Class.class)))
      .andAnswer(
          new IAnswer<Object>() {
            @Override
            public Object answer() throws Throwable {
              return EasyMock.getCurrentArguments()[0];
            }
          })
      .anyTimes();

  EasyMock.replay(adapterManager);
}
 

/**
    * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
    */
public <T> T getAdapter(Class<T> adapter) {
       // lookup the IAdapterManager service
       final IAdapterManager manager = Platform.getAdapterManager();
       // forward the request to IAdapterManager service
       return manager.getAdapter(this, adapter);
   }
 

public void startup(IProgressMonitor monitor) throws CoreException {
	IAdapterManager mgr = Platform.getAdapterManager();
	
	// adapterFactory to translate IResource to ISVNResource
	localResourceAdapterFactory = new LocalResourceAdapterFactory();
	mgr.registerAdapters(localResourceAdapterFactory,IResource.class);
}
 

private void registerActions( )
{
	final IActionBars actionBars = getViewSite( ).getActionBars( );
	IToolBarManager toolbarManager = actionBars.getToolBarManager( );
	exportAction = new ExportSampleReportAction( instance );
	toolbarManager.add( exportAction );
	toolbarManager.add( new Separator( ) );

	Object adapter = null;
	int status = Platform.getAdapterManager( ).queryAdapter( this,
			IAction.class.getName( ) );

	if ( status == IAdapterManager.LOADED )
	{
		adapter = Platform.getAdapterManager( ).getAdapter( this,
				IAction.class );
	}
	else if ( status == IAdapterManager.NOT_LOADED )
	{
		// Cause the plug-in loading first
		adapter = Platform.getAdapterManager( ).loadAdapter( this,
				IAction.class.getName( ) );
	}
	if ( adapter != null )
	{
		importAction = ( (IOpenSampleReportAction) adapter );
		importAction.setMainComposite( instance );
		toolbarManager.add( (Action) importAction );
	}

	actionBars.updateActionBars( );
}
 

public static IAdapterManager getAdapterManager( )
{
	if ( platform != null )
	{
		return platform.getAdapterManager( );
	}
	return null;
}
 

public void shutdown(IProgressMonitor monitor) throws CoreException {
	IAdapterManager mgr = Platform.getAdapterManager();
	mgr.unregisterAdapters(localResourceAdapterFactory);
	localResourceAdapterFactory = null;
}
 

public static <T> T getAdapter( Object adaptable, Class<T> adapterClass )
{
	IAdapterManager adapterManager = org.eclipse.birt.core.framework.Platform.getAdapterManager( );
	return adapterClass.cast( adapterManager.loadAdapter( adaptable,
			adapterClass.getName( ) ) );
}
 

public IAdapterManager getAdapterManager( )
{
	return AdapterManager.getDefault( );
}
 

public IAdapterManager getAdapterManager( )
{
	return Platform.getAdapterManager( );
}
 

/**
 * Gets adapter from extension point.
 * 
 * @param <T>
 * @param adaptable
 * @param type
 * @return adapter class
 * @since 2.5.1
 */
public static <T> T getAdapter( Object adaptable, Class<T> type )
{
	// use BIRT platform as the Eclipse platform may throws exception if the
	// OSGi is not started
	IAdapterManager adapterManager = org.eclipse.birt.core.framework.Platform.getAdapterManager( );
	return type.cast( adapterManager.loadAdapter( adaptable, type.getName( ) ) );
}
 

IAdapterManager getAdapterManager( );