| <?xml version="1.0" encoding="UTF-8"?> |
| <!-- |
| |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| |
| --> |
| <!DOCTYPE api-answers PUBLIC "-//NetBeans//DTD Arch Answers//EN" "../../nbbuild/antsrc/org/netbeans/nbbuild/Arch.dtd" [ |
| <!ENTITY api-questions SYSTEM "../../nbbuild/antsrc/org/netbeans/nbbuild/Arch-api-questions.xml"> |
| ]> |
| |
| <api-answers |
| question-version="1.12" |
| author="jglick@netbeans.org" |
| > |
| |
| &api-questions; |
| |
| |
| <!-- |
| <question id="arch-what"> |
| What is this project good for? |
| <hint> |
| Please provide here few lines describing the the project, |
| what problem it should solve, provide links to documentation, |
| specifications, etc. |
| </hint> |
| </question> |
| --> |
| <answer id="arch-what"> |
| The Modules API lies at the core of NetBeans and describes how plug-in |
| modules are added and managed. |
| <api name="ModulesAPI" group="java" type="export" category="official" url="@TOP@/org/openide/modules/doc-files/api.html"/> |
| </answer> |
| |
| <answer id="arch-usecases"> |
| <a onclick="target='_blank'" href="https://leanpub.com/nbp4beginners"> |
| <img src="http://wiki.apidesign.org/images/0/03/NetBeansPlatformForBeginners.jpg" |
| style="float: right" |
| width="60" height="70" alt="Cover of NetBeans Platform for Beginners book"/> |
| </a> |
| For general overview of the concepts, |
| together with code samples, see chapter 2, |
| of <a onclick="target='_blank'" href="https://leanpub.com/nbp4beginners">NetBeans Platform for Beginners</a> |
| by Jason Wexbridge and Walter Nyland. |
| |
| Gory technical details are explained on <a href="@TOP@/org/openide/modules/doc-files/api.html"> |
| API overview page |
| </a>. Other interesting topic(s) follow: |
| |
| <usecase id="classpath" name="How a classpath of my module is constructed?" > |
| The NetBeans is defacto a container that manages individual module's |
| lifecycle and other runtime aspects. One of the important things is |
| that it creates a runtime classpath for provided modules based on |
| dependencies they specify in their manifests. The |
| <a href="@TOP@/org/openide/modules/doc-files/classpath.html"> |
| overview of the runtime infrastructure</a> is a good starting place for |
| everyone who wishes to learn more about the NetBeans runtime container |
| behaviour. |
| </usecase> |
| <usecase id="patchfor" name="Runtime compatibility patches"> |
| <p> |
| To maintain binary compatibility, method implementations may be injected |
| at runtime, in a form of a superclass in the class' inheritance hierarchy. |
| Modules compiled against older version of APIs which contains MethodReferences to |
| methods removed from the oficial APIs will be then linked according to JVM Resolution |
| algorithm to a matching method present in the superclass of the referenced type. |
| </p> |
| <p> |
| Annotations are used to instruct the ClassLoader to make transformations to the API |
| classes. <a href="@TOP@/org/openide/modules/PatchFor.html">PatchFor</a> causes the annotated |
| class to be injected as a superclass of the API class identified by the annotation's value. |
| <a href="@TOP@/org/openide/modules/ConstructorDelegate.html">ConstructorDelegate</a> marks |
| a method, which is called as constructor implementation in the case that it is necessary |
| to preserve a constructor for binary compatibility. |
| </p> |
| </usecase> |
| </answer> |
| |
| |
| <!-- |
| <question id="compat-i18n"> |
| Is your module correctly internationalized? |
| <hint> |
| Correct internationalization means that it obeys instuctions |
| at <a href="http://www.netbeans.org/devhome/docs/i18n/index.html"> |
| NetBeans I18N pages</a>. |
| </hint> |
| </question> |
| --> |
| <answer id="compat-i18n"> |
| Yes |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="compat-standards"> |
| Does the module implements or defines any standards? Is the |
| implementation exact or it deviates somehow? |
| </question> |
| --> |
| <answer id="compat-standards"> |
| It defines and implements the Modules API. No intentional deviations. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="compat-version"> |
| Does your module properly coexists with earlier and future |
| versions? Can you correctly read settings? Will future |
| versions be able to read settings? |
| |
| <hint> |
| Very helpful for reading settings is to store version number |
| there, so future versions can decide whether how to read/convert |
| the settings and older versions can ignore the new ones. |
| </hint> |
| </question> |
| --> |
| <answer id="compat-version"> |
| Backward compatibility of setting storage for the list of configured modules |
| is considered a design priority. The implementation of the Modules API uses |
| an XML format to store this list; it has an associated versioned DTD, and the |
| 1.0 format additionally supports expansion through arbitrary named parameters. |
| Also, the modules themselves can be considered settings in that a user directory |
| may contain them, so backward compatibility of the directory layout is maintained. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="dep-jre"> |
| Which version of JRE you need (1.2, 1.3, 1.4, etc.)? |
| <hint> |
| It is expected that if your module runs on 1.x that it will run |
| on 1.x+1 if no, state that please. Also describe here cases where |
| you run different code on different versions of JRE and why. |
| </hint> |
| </question> |
| --> |
| <answer id="dep-jre"> |
| 1.3 |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="dep-jrejdk"> |
| Do you require JDK or is JRE enough? |
| </question> |
| --> |
| <answer id="dep-jrejdk"> |
| JRE |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="dep-nb"> |
| What other NetBeans projects this one depends on? |
| <hint> |
| If you want, describe such projects as imported API using |
| the <code><api name="identification" type="import or export" category="stable" url="where is the description" /></code> |
| </hint> |
| </question> |
| --> |
| <answer id="dep-nb"> |
| <api name="UtilitiesAPI" group="java" type="import" category="official" url="@org-openide-util@/org/openide/util/doc-files/api.html"/> |
| And in the implementation only: |
| <api name="FilesystemsAPI" group="java" type="import" category="official" url="@org-openide-filesystems@/org/openide/filesystems/doc-files/api.html"/> |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="dep-non-nb"> |
| What other non-NetBeans projects this one depends on? |
| |
| <hint> |
| Some non-NetBeans projects are packaged as NetBeans modules |
| (see <a href="http://libs.netbeans.org">libraries</a>) and |
| it is prefered to use this approach when more modules may |
| depend on such third-party library. |
| </hint> |
| </question> |
| --> |
| <answer id="dep-non-nb"> |
| None, other than any available SAX parser. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="dep-platform"> |
| On which platforms your module run? Any? Does it run in the same |
| way? |
| <hint> |
| If your module is using JNI or deals with special differences of |
| OSes like filesystems, etc. please describe here what they are. |
| </hint> |
| </question> |
| --> |
| <answer id="dep-platform"> |
| Any. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="deploy-jar"> |
| Do you deploy just module JAR file(s) or some other files? |
| <hint> |
| If your module consist just from one module JAR file, just confirm that. |
| If it uses more than one JAR, describe where there are located, how |
| they refer to each other. |
| If it consist of module JAR(s) and other files, please describe |
| what is their purpose, why other files are necessary. Please |
| make sure that installation/deinstallation leaves the system |
| in state as it was before installation. |
| </hint> |
| </question> |
| --> |
| <answer id="deploy-jar"> |
| The API portion is inside <samp>openide.jar</samp>; |
| the implementation refers to this and is inside <samp>core.jar</samp>. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="deploy-nbm"> |
| Can you deploy NBM via AutoUpdate center? |
| <hint> |
| If not why? |
| </hint> |
| </question> |
| --> |
| <answer id="deploy-nbm"> |
| Yes (as part of <samp>openide.nbm</samp> and <samp>core.nbm</samp>). |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="deploy-packages"> |
| Are packages of your module made inaccessible by not declaring them |
| public? |
| |
| <hint> |
| NetBeans module system allows restriction of access rights to |
| public classes of your module from other modules. This prevents |
| unwanted dependencies of others on your code and should be used |
| whenever possible (<a href="http://www.netbeans.org/download/apis/org/openide/doc-files/upgrade.html#3.4-public-packages"> |
| public packages |
| </a>). |
| </hint> |
| </question> |
| --> |
| <answer id="deploy-packages"> |
| <p> |
| The entire API is one public package. |
| <api name="ModulesAPI" group="java" type="export" category="official" /> |
| </p> |
| <p> |
| The implementation is in another package and is not considered |
| public, though it is made available to <code>autoupdate</code> and |
| <code>apisupport</code> as these special modules deal directly with |
| the module system at a deeper level than the API provides for. |
| <api name="CoreModulesAPI" group="java" type="export" category="friend"/> |
| </p> |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="deploy-shared"> |
| Do you need to be installed in shared location or only in user directory? |
| <hint> |
| Installation location shall not matter, if it does explain why. |
| </hint> |
| </question> |
| --> |
| <answer id="deploy-shared"> |
| Must be installed in the shared location as it is part of the very core of NetBeans. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="exec-classloader"> |
| Does your code uses own classloader? |
| <hint> |
| A bit unusual. Please explain why and what for. |
| </hint> |
| </question> |
| --> |
| <answer id="exec-classloader"> |
| The implementation creates one class loader for each enabled module, |
| plus a special "system" class loader. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="exec-component"> |
| Is execution of your code influenced by (string) property |
| of any of your components? |
| |
| <hint> |
| Often <code>JComponent.getClientProperty</code>, <code>Action.getValue</code> |
| or <code>PropertyDescriptor.getValue</code>, etc. are used to influence |
| a behaviour of some code. This of course forms an interface that should |
| be documented. Also if one depends on some interface that an object |
| implements (<code>component instanceof Runnable</code>) that forms an |
| API as well. |
| </hint> |
| </question> |
| --> |
| <answer id="exec-component"> |
| No. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="exec-privateaccess"> |
| Are you aware of any other part of the system calling some of |
| your methods by reflection? |
| <hint> |
| If so, describe the "contract" as an API. Likely private or friend one, but |
| still API and consider rewrite of it. |
| </hint> |
| </question> |
| --> |
| <answer id="exec-privateaccess"> |
| No. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="exec-property"> |
| Is execution of your code influenced by any environment of |
| system (<code>System.getProperty</code>) property? |
| |
| <hint> |
| If there is a property that can change the behaviour of your |
| code, somebody will likely use it. You should describe what it does |
| and the stability category of this API. You may use |
| <PRE> |
| <property name="id" category="private" > |
| description of the property, where it is used, what it influence, etc. |
| </property> |
| </PRE> |
| </hint> |
| </question> |
| --> |
| <answer id="exec-property"> |
| <api type="import" group="systemproperty" name="netbeans.home" category="private"> |
| NetBeans installation directory. |
| </api> |
| <api type="import" group="systemproperty" name="netbeans.user" category="private"> |
| User directory. |
| </api> |
| <api type="import" group="systemproperty" name="netbeans.dirs" category="private"> |
| Additional installation component directories. |
| </api> |
| <api type="export" group="systemproperty" name="netbeans.systemclassloader.patches" category="friend"> |
| Classpath appended to the system class loader. |
| Used for automated testing infrastructure. |
| </api> |
| <api type="import" group="systemproperty" name="netbeans.classpath" category="friend"> |
| May be used to prepend items to the same class loader as is used |
| for <samp>openide.jar</samp> and <samp>core.jar</samp>, similarly |
| to JARs found in <samp>lib/patches/</samp>. |
| </api> |
| <api type="export" group="systemproperty" name="netbeans.cache.manifests" category="private"> |
| By default true, may be turned off to disable manifest caching. |
| </api> |
| <api type="export" group="systemproperty" name="netbeans.patches.MODULE.CODE.NAME.BASE" category="friend"> |
| Patch directories or JARs to add to the class loader for a module, |
| besides <samp>patches/MODULE-CODE-NAME-BASE/*.jar</samp>. |
| </api> |
| <api type="export" group="systemproperty" name="netbeans.preresolve.classes" category="private"> |
| If true, all module classes are forcibly loaded at startup, to help |
| detect possible linkage errors. |
| </api> |
| <api type="export" group="systemproperty" name="org.netbeans.core.modules.NbInstaller.noAutoDeps" category="private"> |
| Disables automatic module dependency upgrades. |
| </api> |
| <api type="export" group="systemproperty" name="org.netbeans.core.modules" category="private"> |
| If set to <samp>0</samp>, enables logging for the module system. |
| </api> |
| <api type="export" group="systemproperty" name="org.netbeans.core.modules.NbInstaller.NO_COMPAT_AUTO_TRANSITIVE_DEPS" category="private"> |
| Disabled automatic transitive class loader dependencies for old modules. |
| </api> |
| <api type="export" group="systemproperty" name="netbeans.modules.quiet" category="private"> |
| Avoids text messaging (other than <code>ErrorManager</code> logging) to the console |
| from the module system. |
| </api> |
| <api type="export" group="systemproperty" name="netbeans.moduleitem.dontverifyclassloader" category="private"> |
| Suppresses checks to ensure that module section classes are actually loaded |
| from the module itself. |
| </api> |
| <api type="import" group="systemproperty" name="netbeans.full.hack" category="friend" url="http://wiki.netbeans.org/DevFaqNetBeansFullHack"> |
| Avoids using GUI when user-visible error conditions occur. |
| </api> |
| <api type="import" group="systemproperty" name="netbeans.mainclass" category="friend"> |
| Name of class from <samp>core.jar</samp> which will handle most of the |
| startup sequence; by default, <samp>org.netbeans.core.Main</samp>. |
| </api> |
| <!-- XXX this is really in "launcher", not module system --> |
| <api type="export" group="systemproperty" name="netbeans.security.nocheck" category="friend"> |
| Suppress security checks in the VM, even from "untrusted" code. |
| </api> |
| <api type="export" group="systemproperty" name="netbeans.classloader.verbose" category="private"> |
| Prints messages when resources or classes are loaded from JARs. |
| </api> |
| <api group="systemproperty" name="netbeans.cache.layers" type="export" category="private"> |
| <p> |
| Used to control the XML layer cache mechanism. Value may be a |
| fully-qualified class name to load as a manager (implement |
| <code>org.netbeans.core.projects.cache.LayerCacheManager</code>), |
| or <code>-</code> to disable caching and always parse the XML |
| layers directly. Current default is to use a binary cache |
| manager. |
| </p> |
| </api> |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="exec-reflection"> |
| Does your code uses java.lang.reflect to execute some other code? |
| <hint> |
| This usually indicates a missing or unsufficient API in the other |
| part of the system. If the other side is not aware of your dependency |
| this contract can be easily broken. |
| </hint> |
| </question> |
| --> |
| <answer id="exec-reflection"> |
| Of course components present in modules are initially loaded using |
| reflection. Otherwise there is little semantic use of it (transparent |
| optimizations only). One exception: pending a solution to <a |
| href="http://www.netbeans.org/issues/show_bug.cgi?id=29382">#29382</a>, |
| one portion of the Filesystems API is accessed via reflection when |
| merging XML layers from modules. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="format-clipboard"> |
| Which protocols your code reads/inserts when communicating with |
| clipboard? |
| </question> |
| --> |
| <answer id="format-clipboard"> |
| N/A |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="format-dnd"> |
| Which protocols your code understands during drag-n-drop? |
| </question> |
| --> |
| <answer id="format-dnd"> |
| N/A |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="format-types"> |
| Which file formats your code reads or writes on disk? |
| </question> |
| --> |
| <answer id="format-types"> |
| <ul> |
| <li>Module JAR files, as specified by the Modules API</li> |
| <li><api group="dtd" category="devel" type="export" name="module-status-1_0.dtd" url="http://www.netbeans.org/dtds/module-status-1_0.dtd"><samp>-//NetBeans//DTD Module Status 1.0//EN</samp></api></li> |
| <li><api group="dtd" category="devel" type="export" name="module-auto-deps-1_0.dtd" url="http://www.netbeans.org/dtds/module-auto-deps-1_0.dtd"><samp>-//NetBeans//DTD Module Automatic Dependencies 1.0//EN</samp></api></li> |
| <li><api group="dtd" category="stable" type="export" name="filesystem-1_1.dtd" url="http://www.netbeans.org/dtds/filesystem-1_1.dtd"><samp>-//NetBeans//DTD Filesystem 1.1//EN</samp></api></li> |
| <li>a custom binary format for caching merged layer contents</li> |
| <li>a custom binary format for caching module manifests</li> |
| <li>a custom binary (serialized) format for caching folder lookup</li> |
| <li>Java serialization for externalized <code>ModuleInstall</code>s (deprecated)</li> |
| </ul> |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="lookup-lookup"> |
| Does your module uses <code>org.openide.util.Lookup</code> |
| to find any components to communicate to? Which ones? |
| |
| <hint> |
| Please describe the interfaces you are searching for, where |
| are defined, whether you are searching for just one or more of them, |
| if the order is important, etc. Also clasify the stability of such |
| API contract. |
| </hint> |
| </question> |
| --> |
| <answer id="lookup-lookup"> |
| All registered <code>InstalledFileLocator</code> |
| instances are queried and used |
| to implement <code>InstalledFileLocator.getDefault()</code>. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="lookup-register"> |
| Do you register anything into the lookup for other to find? |
| <hint> |
| Do you register using layer file or using <code>META-INF/services</code>? |
| Who is supposed to find your component? |
| </hint> |
| </question> |
| --> |
| <answer id="lookup-register"> |
| <ul> |
| <li><code>TestModuleDeployer</code> (from META-INF), used by apisupport</li> |
| <li><code>InstalledFileLocator</code> (from META-INF), used by its public default method</li> |
| <li>an instance of every known <code>ModuleInfo</code>, via a custom lookup insertion (specified in API)</li> |
| <li>an instance of <code>ClassLoader</code>, via a custom lookup insertion (used broadly)</li> |
| </ul> |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="lookup-remove"> |
| Are removing entries of other modules from the lookup? |
| <hint> |
| Why? Of course, that is possible, but it can be dangerous. Is the module |
| your are masking resource from aware of what you are doing? |
| </hint> |
| </question> |
| --> |
| <answer id="lookup-remove"> |
| No. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-exit"> |
| Does your module executes anything on exit? |
| </question> |
| --> |
| <answer id="perf-exit"> |
| Delegates to exit handlers of enabled modules. |
| Saves lookup cache. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-huge_dialogs"> |
| Does your module contain any dialogs or wizards with huge |
| amount of GUI controls like combo boxes, lists, trees, text |
| areas? |
| </question> |
| --> |
| <answer id="perf-huge_dialogs"> |
| No. Occasionally small dialogs only. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-limit"> |
| Are there any limits in number/size of elements your code |
| can handle? |
| </question> |
| --> |
| <answer id="perf-limit"> |
| No. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-mem"> |
| What is the amount of memory your component occupies? Estimate |
| with a relaction to the number of windows, etc. |
| </question> |
| --> |
| <answer id="perf-mem"> |
| Not a lot. On modules which are well-formed (layers, JAR entries, |
| complex interdependencies) but which do not run any code there is a modest |
| incremental cost: 3.1msec and 4.5Kb per module at least measurement. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-menus"> |
| Does your module use dynamically changing context menus or |
| context sensitive actions with complicated logic for enable/disable? |
| </question> |
| --> |
| <answer id="perf-menus"> |
| No. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-progress"> |
| Does your module executes some long running task? |
| <hint>Typically they are tasks like connecting over |
| network, computing huge amount of data, compilation. |
| Such communication should be done asynchronously (for example |
| using <code>RequestProcessor</code>), definitively it should |
| not block AWT thread. |
| </hint> |
| </question> |
| --> |
| <answer id="perf-progress"> |
| Bulk module installation can be time-consuming. <code>org.netbeans.core.ui.ModuleBean</code> |
| is a Swing-safe bean that serves as a nonblocking wrapper for all module system |
| modifications and is used e.g. in the <b>Modules</b> node. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-scale"> |
| Which external criteria influence the performance of your |
| program (size of file in editor, number of files in menu, |
| in source directory, etc.) and how well your code scales? |
| Please include some estimates. |
| </question> |
| --> |
| <answer id="perf-scale"> |
| Scalability of the standalone system seems reasonably good; even with |
| a thousand modules (an order of magnitude higher than current reality) |
| startup time and memory consumption in the module system itself are |
| not large (7 seconds, 6 Mb). |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-startup"> |
| Does your module executes anything on startup? |
| </question> |
| --> |
| <answer id="perf-startup"> |
| Yes, of course - it finds and loads all modules. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="perf-wakeup"> |
| Is any piece of your code waking up periodically? |
| </question> |
| --> |
| <answer id="perf-wakeup"> |
| No. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="resources-file"> |
| Does your module use <code>java.io.File</code> directly? |
| |
| <hint> |
| NetBeans provide a logical wrapper over plain files called |
| <code>org.openide.filesystems.FileObject</code> that |
| provides uniform access to such resources and is the prefered |
| way that should be used. But of course there can be situations when |
| this is not suitable. |
| </hint> |
| </question> |
| --> |
| <answer id="resources-file"> |
| <p> |
| Yes, module JARs and associated resource JARs must be real files. |
| They are loaded as defined by module enablement XML files. |
| </p> |
| <p> |
| Module enablement XML files are loaded via Filesystems. The public |
| API (partially) specifies them only in these terms. |
| <code>autoupdate</code> uses Filesystems to manipulate them when |
| necessary, though it relies on some additional |
| implementation-specific knowledge of their format (which is fairly |
| stable, especially since changes are limited by compatibility |
| constraints on old user directories). The NetBeans build scripts use |
| some additional implementation knowledge to pregenerate suitable XML |
| files for modules included in the application distribution. |
| </p> |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="resources-layer"> |
| Does your module provide own layer? Does it create some files or |
| folders on it? What it is trying to communicate by that and with which |
| component? |
| |
| <hint> |
| NetBeans allows automatic and declarative installation of resources |
| by module layers. Module register files into appropriate places |
| and other components use that information to perform their task |
| (build menu, toolbar, window layout, list of templates, set of |
| options, etc.). |
| </hint> |
| </question> |
| --> |
| <answer id="resources-layer"> |
| The Modules API defines some layer folders: |
| <ul> |
| <li><samp>Modules/*.xml</samp> (read from and written to)</li> |
| <li><samp>ModuleAutoDeps/*.xml</samp> (only read from)</li> |
| </ul> |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="resources-mask"> |
| Does your module mask/hide/override any resource provided by another one in |
| module layer? |
| |
| <hint> |
| If you mask a file provided by another module, you probably depend |
| on that and do not want the other module to (for example) change |
| the file's name. That module shall thus make that file available as an API |
| of some stability category. |
| </hint> |
| </question> |
| --> |
| <answer id="resources-mask"> |
| No. |
| </answer> |
| |
| |
| |
| <!-- |
| <question id="resources-read"> |
| Does your module read any resources from layers? For what purpose? |
| |
| <hint> |
| As this is some kind of intermodule dependency, it is a kind of API. |
| Please describe it and clasify according to |
| <a href="http://openide.netbeans.org/tutorial/api-design.html#categories"> |
| common stability categories</a>. |
| </hint> |
| </question> |
| --> |
| <answer id="resources-read"> |
| XML files are read from the two folders defined by the API. |
| Note however that since these folders control the module system itself, |
| contents generally should not be placed in module layers, but in the |
| <samp>system/</samp> subfolder of the installation or user directory |
| (generally, in the NBM). |
| </answer> |
| |
| </api-answers> |
