Indicate if we're going to use deferred loading. (Also clears the current list)

@param loading True if we should use deferred loading
545448
public static void setDeferredLoading(boolean loading) {
		single = new LoadingList();
		
		InternalTextureLoader.get().setDeferredLoading(loading);
		SoundStore.get().setDeferredLoading(loading);
	}
753202
protected void deferredClose() {
        Thread t = new Thread(getClass().getName() + " DeferredClose") {
            @Override
            public void run() {
                try {
                    synchronized (BaseFileManager.this) {
                        long now = System.currentTimeMillis();
                        while (now < lastUsedTime + deferredCloseTimeout) {
                            BaseFileManager.this.wait(lastUsedTime + deferredCloseTimeout - now);
                            now = System.currentTimeMillis();
                        }
                        deferredCloseTimeout = 0;
                        close();
                    }
                } catch (InterruptedException e) {
                } catch (IOException e) {
                }
            }
        };
        t.setDaemon(true);
        t.start();
    }
287006
public final boolean isLoading() {
        if (mDatas.isEmpty()) {
            return false;
        }
        for (int i = 0; i < mDatas.size(); i++) {
            if (mDatas.get(i).isLoading()) {
                return true;
            }
        }
        return false;
    }
251721
public static void clearClassLoader(final ClassLoader classLoader) {
        BeanPropertiesCache.clear(classLoader);
        final Iterator<Map.Entry<CacheKey, String>> it = CLASS_CACHE.entrySet().iterator();
        while (it.hasNext()) {
            final CacheKey key = it.next().getKey();
            if (key.loader == classLoader) {
                it.remove();
            }
        }
    }
1002237
private boolean loadPage() {
		Collection<T> list;
		
		if( pages.size() <= pageIndex ) {
			return false;
		}
		list = pages.get(pageIndex);
		currentPage = list.iterator();
		return true;
	}
1205273
public void classLoaderInit(DynamicClassLoader loader)
  {
    EnvLoaderListener listener = _listenerRef.get();
    
    if (listener != null)
      listener.classLoaderInit(loader);
  }
832920
public void loadChoices(Iterable<String> choices) {
        clear();
        
        if (choices != null) {
            for (String choice : choices) {
                addChoice(choice, false);
            }
        }
        
        checkSelection(true);
    }
282459
private static void apiReady() {

        loadingApi = false;
        for (Command callback : onApiReady) {
            callback.execute();
        }
        onApiReady.clear();
    }
884623
public void setLoading(boolean isLoading) {
        getSupportFragmentManager()
                .beginTransaction()
                .replace(R.id.root, isLoading ? loadingFragment : formFragment)
                .commit();
    }
608404
void removeDownload(OfflineDownloadOptions offlineDownload, boolean canceled) {
    if (canceled) {
      stateChangeDispatcher.onCancel(offlineDownload);
    } else {
      stateChangeDispatcher.onSuccess(offlineDownload);
    }
    offlineDownloads.remove(offlineDownload);
  }
450319
public boolean isUnloadedAtDestination() {
		for (HandlingEvent event : this.lnkDeliveryHistory.eventsOrderedByCompletionTime()) {
			if (HandlingEvent.Type.UNLOAD.equals(event.getType()) && hasArrived()) {
				return true;
			}
		}
		return false;
	}
641035
public void unload() {
        deactivate();
        if (getAntecedent() != null) {
            getAntecedent().unload();
        }
        if (getConsequent() != null) {
            getConsequent().unload();
        }
    }
158194
function Deferred () {
	var self      = this;

	this.promise  = promise.factory();
	this.onDone   = [];
	this.onAlways = [];
	this.onFail   = [];

	// Setting handlers to execute Arrays of Functions
	this.promise.then( function ( arg ) {
		promise.delay( function () {
			array.each( self.onDone, function ( i ) {
				i( arg );
			});

			array.each( self.onAlways, function ( i ) {
				i( arg );
			});

			self.onAlways = [];
			self.onDone   = [];
			self.onFail   = [];
		});
	}, function ( arg ) {
		promise.delay( function () {
			array.each( self.onFail, function ( i ) {
				i( arg );
			});

			array.each( self.onAlways, function ( i ) {
				i( arg );
			});

			self.onAlways = [];
			self.onDone   = [];
			self.onFail   = [];
		});
	});
}
210608
private void checkTarget() {
		if (target == null) {
			try {
				load();
				LoadingList.get().remove(this);
				return;
			} catch (IOException e) {
				throw new RuntimeException("Attempt to use deferred texture before loading and resource not found: "+resourceName);
			}
		}
	}
819567
@Override
    protected void classLoaderChanged()
    {
        Vector toRemove = new Vector(); // safely remove
        for ( Enumeration e = listeners.elements(); e.hasMoreElements(); )
        {
            WeakReference wr = (WeakReference)e.nextElement();
            Listener l = (Listener)wr.get();
            if ( l == null )  // garbage collected
              toRemove.add( wr );
            else
              l.classLoaderChanged();
        }
        for( Enumeration e = toRemove.elements(); e.hasMoreElements(); )
            listeners.removeElement( e.nextElement() );
    }
734783
public void resetThreadContextLoader() {
        if (LoaderUtils.isContextLoaderAvailable() && isContextLoaderSaved) {
            LoaderUtils.setContextClassLoader(savedContextLoader);
            savedContextLoader = null;
            isContextLoaderSaved = false;
        }
    }
560835
function() {
    this.clear_rows();
    if(! this.isEmptyTable()) {
      if(this.dataModel.fetched) {
        var self = this;

        this.dataModel.each(function(row) {
          self.addRow(row);
        });
      } else {
        this._renderLoading();
      }
    } else {
      this._renderEmpty();
    }

  }