View source

From Eclipsepedia

for FAQ Can fragments be used to patch a plug-in?
You do not have permission to do that, for the following reason:
The action you have requested is limited to users in the group user.
You can view and copy the source of this page:
''

	
	




A common misconception is that a fragment can be used to patch
or replace functionality in its host plug-in. Although this is possible to
a certain extent, this is not what fragments were designed for. A
plug-in and its fragments each contribute a manifest, and each may
also contribute native libraries, Java code libraries, and other resources.
At runtime, these contributions are all merged into a single manifest and 
a single namespace of libraries and resources.
If a fragment defines the same library as its host, whether the 
fragment&#146;s library will be found over the host&#146;s library
is undefined. This makes it impractical to use fragments as a way of replacing
libraries or other resources defined by a plug-in.




Nonetheless, it is possible to design a plug-in so
that it allows a portion of its functionality to be implemented or
replaced by a fragment. Let&#146;s look at a notable example of how
this is applied in the <tt>org.eclipse.swt</tt> plug-in.
The SWT plug-in manifest declares a runtime library by using 
a special path-substitution variable:
<pre>
   &lt;library name=&quot;$ws$/swt.jar&quot;>
</pre>

When the plug-in manifest is loaded, the platform will substitute
the <tt>$ws$</tt> variable with a string describing the
windowing system of the currently running operating system.
Each windowing system has a separate SWT plug-in fragment
that will provide this library.  For example, when
running on windows, <tt>$ws$</tt> will resolve to <tt>ws/win32</tt>.
You can make use of this path-substitution facility in your own plug-in code
by using the <tt>Plugin.find</tt> methods.
The fragment <tt>org.eclipse.swt.win32</tt> supplies the <tt>swt.jar</tt>
library at the path <tt>org.eclipse.swt.win32/ws/win32/swt.jar</tt>. Thus,
in this case the fragment will supply a library that was specified by
its host plug-in.




The same principle can be used to allow a fragment to provide a patch
to a host plug-in. The host plug-in can specify both its own library and a patch
library in its plug-in manifest:
<pre>
   &lt;runtime&gt;
      &lt;library name=&quot;patch.jar&quot;&gt;
         &lt;export name=&quot;*&quot;/&gt;
      &lt;/library&gt;
      &lt;library name=&quot;main.jar&quot;&gt;
         &lt;export name=&quot;*&quot;/&gt;
      &lt;/library&gt;
   &lt;/runtime&gt;
</pre>




The host plug-in puts all its code in <tt>main.jar</tt> and does not specify
a <tt>patch.jar</tt> at all.  When no patch is needed, the <tt>patch.jar</tt> 
library is simply missing from the classpath. This allows a fragment to be added
later that contributes the <tt>patch.jar</tt> library.  Because the host plug-in
has defined <tt>patch.jar</tt> at the front of its runtime classpath, classes in
the patch library will be found before classes in the original library. 



This technique is used in Eclipse 3.0 to provide backward-compatibility 
support for plug-ins based on Eclipse 2.1 or earlier. The 
plug-in <tt>org.eclipse.ui.workbench</tt> defines a library 
called <tt>compatibility.jar</tt> at the start of its classpath.  
When the platform detects a plug-in written prior to Eclipse 3.0,
a fragment called <tt>org.eclipse.ui.workbench.compatibility</tt> 
containing <tt>compatibility.jar</tt> is automatically added to the 
plug-in&#146;s classpath.  
This library adds back some old API that was moved 
in Eclipse 3.0. The beauty of this mechanism is that it allows the 
backward-compatibility support to be added or removed with 
no impact on the host plug-in.





== See Also: ==


[[FAQ_What_is_the_classpath_of_a_plug-in%3F]]

For a step by step walk through to use fragments to patch hosts bundles in Eclipse 3.2 and up using OSGi see: [[Steps_to_use_Fragments_to_patch_a_plug-in]]

<hr><font size=-2>This FAQ was originally published in [http://www.eclipsefaq.org Official Eclipse 3.0 FAQs]. Copyright 2004, Pearson Education, Inc. All rights reserved. This text is made available here under the terms of the [http://www.eclipse.org/legal/epl-v10.html Eclipse Public License v1.0].</font>
Return to FAQ Can fragments be used to patch a plug-in?.
Retrieved from "http://wiki.eclipse.org/FAQ_Can_fragments_be_used_to_patch_a_plug-in%3F"