system/src/sc/layer/TrackingClassLoader.java
private void disableBuildLoaders(TrackingClassLoader parent) {
      if (disabled)
         return;
      if (buildLoader && (layer == null || !layer.buildSeparate)) {
         disabled = true;
         replaceLoader = parent;
      }
      if (parentTrackingLoader != null) {
         Layer parentLayer = parentTrackingLoader.layer;
         // If this is a completely different stack of layers, do not disable it
         if (layer != null && parentLayer != null && layer.extendsLayer(parentLayer))
            parentTrackingLoader.disableBuildLoaders(parent);
      }
      if (disabled)
         layer = null;
   }
/**
    * Do not load any new classes in any TrackingClassLoaders which are marked as build loaders.  These are loaders
    * which track the built directories (as opposed to lib directories which are added in layers statically)
    * <p>
    * As we add a new tracking class loader for a build layer, it contains all of the build directories in layered order
    * from the previous layers - i.e. so we pick up the last layer's files first.  But as we build the system, we have to
    * add each build layer to the class loader scheme after we've built it so that we can load compiled classes for any
    * types we've determined are "final" i.e. can't be changed by subsequent build layers.  Otherwise, we always have to
    * load source descriptions for all files.  This puts us into a bad predicament with Java because it's basic philosophy
    * is that once you put a directory into a class loader, there's no way to add one before it.  There are good reasons for that...
    * it's easy to introduce incompatible classes but StrataCode is careful about sorting the dependencies so this does not
    * happen. The difficult strategy here then is to disable all build loaders, keeping any classes which have already
    * been loaded in them, keeping the original loader in the chain, and reordering the build-dirs once the subsqeuent
    * build dir has been compiled.
    * </p>
    */
Do not load any new classes in any TrackingClassLoaders which are marked as build loaders.  These are loaders
which track the built directories (as opposed to lib directories which are added in layers statically)

As we add a new tracking class loader for a build layer, it contains all of the build directories in layered order
from the previous layers - i.e. so we pick up the last layer's files first.  But as we build the system, we have to
add each build layer to the class loader scheme after we've built it so that we can load compiled classes for any
types we've determined are "final" i.e. can't be changed by subsequent build layers.  Otherwise, we always have to
load source descriptions for all files.  This puts us into a bad predicament with Java because it's basic philosophy
is that once you put a directory into a class loader, there's no way to add one before it.  There are good reasons for that
it's easy to introduce incompatible classes but StrataCode is careful about sorting the dependencies so this does not
happen. The difficult strategy here then is to disable all build loaders, keeping any classes which have already
been loaded in them, keeping the original loader in the chain, and reordering the build-dirs once the subsqeuent
build dir has been compiled.
Do not load any new classes in any TrackingClassLoaders which are marked as build loaders . These are loaders which track the built directories ( as opposed to lib directories which are added in layers statically ) As we add a new tracking class loader for a build layer it contains all of the build directories in layered order from the previous layers - i . e . so we pick up the last layer ' s files first . But as we build the system we have to add each build layer to the class loader scheme after we ' ve built it so that we can load compiled classes for any types we ' ve determined are " final " i . e . can ' t be changed by subsequent build layers . Otherwise we always have to load source descriptions for all files . This puts us into a bad predicament with Java because it ' s basic philosophy is that once you put a directory into a class loader there ' s no way to add one before it . There are good reasons for that it ' s easy to introduce incompatible classes but StrataCode is careful about sorting the dependencies so this does not happen . The difficult strategy here then is to disable all build loaders keeping any classes which have already been loaded in them keeping the original loader in the chain and reordering the build - dirs once the subsqeuent build dir has been compiled .
private void disableBuildLoaders(TrackingClassLoader parent) {
      if (disabled)
         return;
      if (buildLoader && (layer == null || !layer.buildSeparate)) {
         disabled = true;
         replaceLoader = parent;
      }
      if (parentTrackingLoader != null) {
         Layer parentLayer = parentTrackingLoader.layer;
         if (layer != null && parentLayer != null && layer.extendsLayer(parentLayer))
            parentTrackingLoader.disableBuildLoaders(parent);
      }
      if (disabled)
         layer = null;
   }
private void disableBuildLoaders ( TrackingClassLoader parent ) { if ( disabled ) return ; if ( buildLoader && ( layer == null || ! layer . buildSeparate ) ) { disabled = true ; replaceLoader = parent ; } if ( parentTrackingLoader != null ) { Layer parentLayer = parentTrackingLoader . layer ; if ( layer != null && parentLayer != null && layer . extendsLayer ( parentLayer ) ) parentTrackingLoader . disableBuildLoaders ( parent ) ; } if ( disabled ) layer = null ; }
Do not load any new classes in any TrackingClassLoaders which are marked as build loaders.
Do not load any new classes in any TrackingClassLoaders which are marked as build loaders .
// If this is a completely different stack of layers, do not disable it