* and gets resolved, to either a project or library entry, using
* <code>JavaCore#getResolvedClasspathVariable</code>.
* It is also possible to register an automatic initializer (<code>ClasspathVariableInitializer</code>),
- * which will be invoked through the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
+ * which will be invoked through the extension point "net.sourceforge.phpdt.core.classpathVariableInitializer".
* After resolution, a classpath variable entry may either correspond to a project or a library entry. </li>
*
* <li> A named classpath container identified by its container path.
* which can be used as additional hints for resolving this container reference. If no container was ever
* recorded for this container path onto this project (using <code>setClasspathContainer</code>,
* then a <code>ClasspathContainerInitializer</code> will be activated if any was registered for this
- * container ID onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
+ * container ID onto the extension point "net.sourceforge.phpdt.core.classpathContainerInitializer".
* A classpath container entry can be resolved explicitly using <code>JavaCore#getClasspathContainer</code>
* and the resulting container entries can contain any non-container entry. In particular, it may contain variable
* entries, which in turn needs to be resolved before being directly used.
* @since 2.1
*/
IPath[] getExclusionPatterns();
+ /**
+ * Returns the set of patterns used to explicitly define resources to be
+ * included with this source entry.
+ * <p>
+ * When no inclusion patterns are specified, the source entry includes all
+ * relevent files in the resource tree rooted at this source entry's path.
+ * Specifying one or more inclusion patterns means that only the specified
+ * portions of the resource tree are to be included. Each path specified
+ * must be a relative path, and will be interpreted relative to this source
+ * entry's path. File patterns are case-sensitive. A file matched by one or
+ * more of these patterns is included in the corresponding package fragment
+ * root unless it is excluded by one or more of this entrie's exclusion
+ * patterns. Exclusion patterns have higher precedence than inclusion
+ * patterns; in other words, exclusion patterns can remove files for the
+ * ones that are to be included, not the other way around.
+ * </p>
+ * <p>
+ * See {@link #getExclusionPatterns()} for a discussion of the syntax and
+ * semantics of path patterns. The absence of any inclusion patterns is
+ * semantically equivalent to the explicit inclusion pattern
+ * <code>**</code>.
+ * </p>
+ * <p>
+ * Examples:
+ * <ul>
+ * <li>
+ * The inclusion pattern <code>src/**</code> by itself includes all
+ * files under a root folder named <code>src</code>.
+ * </li>
+ * <li>
+ * The inclusion patterns <code>src/**</code> and
+ * <code>tests/**</code> includes all files under the root folders
+ * named <code>src</code> and <code>tests</code>.
+ * </li>
+ * <li>
+ * The inclusion pattern <code>src/**</code> together with the
+ * exclusion pattern <code>src/**/Foo.java</code> includes all
+ * files under a root folder named <code>src</code> except for ones
+ * named <code>Foo.java</code>.
+ * </li>
+ * </ul>
+ * </p>
+ *
+ * @return the possibly empty list of resource inclusion patterns
+ * associated with this source entry, and <code>null</code> for other
+ * kinds of classpath entries
+ * @since 3.0
+ */
+ IPath[] getInclusionPatterns();
/**
* Returns the full path to the specific location where the builder writes