/** this is true between addNotify and removeNotify */

--

    private boolean active;

    /** Private req processor for the refresh tasks */

    private static RequestProcessor refRP = 

        new RequestProcessor("FolderChildren_Refresh"); // NOI18N

            refreshChildren ();

            refreshChildren();

--

            refreshChildren ();

            refreshChildren();

--

    void refreshChildren () {

    Task refreshChildren() {

        initialize (true, false);

        return refRP.post(new ChildrenRefreshRunnable());

    }

    /** Creates a key for given data object.

    * This method is here to create something different then data object,

    * because the data object should be finalized when not needed and

    * that is why it should not be used as a key.

    *

    * @param obj data object

    * @return key representing the data object.

    */

    static Object createKey (DataObject obj) {

        return new Pair (obj.getPrimaryFile ());

    }

    /** This method takes the key created by createKey and converts it

    * into primary file.

    *

    * @param key the key

    * @return primary file of the key

    */

    private static FileObject getFile (Object key) {

        return ((Pair)key).primaryFile;

--

        FileObject fo = getFile (key);

        FileObject fo = ((Pair)key).primaryFile;

--

    /** Improves the searching capability to wait till all children

    public Node[] getNodes(boolean optimalResult) {

    * are found and then searching thru them.

        if (optimalResult) {

    */

            active = true;

    public Node findChild (final String name) {

            Task t = refreshChildren();

        // start the initialization

            t.waitFinished();

        Node[] forget = getNodes (); // DO NOT DELETE

        // waits till the list of children is created

        // JST: the folowing code is replacement for

        // initialize (false, false).waitFinished ()

        // 

        // the orgiginal code caused deadlocks when called with readAccess,

        // because the refreshChildren (which we wait for to be finished)

        // method calls setKeys and they require write request

        //

        // this code could probably be replaced by 

        // Children.MUTEX.isReadAccess, if such call would be added to Mutex

        class Jst implements Runnable {

            public boolean checkReadOrWrite;

            public boolean inReadAccess = true;

            public boolean inWriteAccess = true;

            public void run () {

                if (checkReadOrWrite) {

                    inReadAccess = false;

                } else {

                    inWriteAccess = false;

                }

            }

        }

        Jst t = new Jst ();

        // the code will run either immediatally or after we leave readAccess

        // section

        Children.MUTEX.postWriteRequest(t);

        t.checkReadOrWrite = true;

        Children.MUTEX.postReadRequest(t);

        if (!t.inReadAccess && !t.inWriteAccess) {

            // if we are not in readAccess we can safely wait till

            // refreshChildren finishes and sets new keys for the 

            initialize (name == null, false).waitFinished ();

            refreshTask.waitFinished ();

--

        return getNodes();

        // do the regular child lookup

        Node node = super.findChild (name);

        return node;

--

--

        setKeys (java.util.Collections.EMPTY_SET);

        //

    }

        active = false;

        // we don't call the setKeys directly here because

    /** Ensures that the content of children will be filled sometime.

        // there can be a task spawned by refreshChildren - so

    * @param force true if the content should be filled immediatelly

        // we want to clear the children after that task is finished

    */

        refreshChildren();

    private Task initialize (boolean force, boolean waitFirst) {

        Task t = initTask;

        if (t != null && t.isFinished()) {

            // if the original refresh task is finished we whould check if there are

            // some new changes in progress and wait for them to finish

            FolderList l = FolderList.find (folder.getPrimaryFile(), true);

            l.waitProcessingFinished ();

            t = initTask;

        }

        if (t != null && !force) {

            return t;

        }

//        if (t != null) {

//            t.waitFinished ();

//            refreshTask.waitFinished ();        

//            return t;

//        }

        final Addition add = new Addition (waitFirst);

        refreshTask = add.refTask;

        initTask = t = folder.computeChildrenList (add);

        t.addTaskListener (add);

        if (waitFirst) {

            add.waitFirst ();

        }

        return t;

--

    /** Support for incremental adding of new nodes.

    /**

    *

     * Instances of this class are posted to the request processor refRP

    * <P>

     * (FolderChildren_refresher). We do this because we do not want

    * There is a deadlock warning:

     * to call setKeys synchronously.

    * <OL>

     */

    *   <LI>A thread waiting in the waitFirst method can have MUTEX.readAccess

    private final class ChildrenRefreshRunnable implements Runnable {

    *   <LI>Thread running run () needs access to MUTEX.writeAccess (because of setKeys)

        /** calls setKeys with the folder children 

    *   <LI>Be sure that the thread leaves waitFirst before writeAccess is needed

         * or with empty collection if active is false

    * </OL>

    */

    private class Addition

    implements TaskListener, FolderListListener, Runnable {

        static final long serialVersionUID =-4194617547214845940L;

        /** last time of addition */

        private long time = System.currentTimeMillis () + TIME_DELAY;

        /** delay */

        private int delay = TIME_DELAY;

        /** update the nodes during processing or only at the end */

        private boolean processingUpdate;

        /** a keys to be later refreshed */

        private List refKeys;

        // fix of #27025. We have to keep reference to all data objects

        // for the whole lifetime of this object otherwise it can happen

        // that a data object is GCed between calling refreshKeys and

        // createNodes

        private List dataObjects = new ArrayList();

        /** processing of DataFolder.computeChildrenList finished */

        private boolean processingFinished;

        /** a task that is used to request refreshing of keys */

        private RequestProcessor.Task refTask = refRP.create(this); // NOI18N

        /** @param processingUpdate update the nodes during

        *  processing or only at the end 

        */

        public Addition (boolean processingUpdate) {

            this.processingUpdate = processingUpdate;

        }

        /** Another object has been recognized.

         * @param obj the object recognized

         * @param arr array where the implementation should add the

         *    object

         */

        public void process(DataObject obj, java.util.List arr) {

            if (!filter.acceptDataObject (obj)) {

                return;

            }

            // first accepted object is notified to the waiting thread in

            boolean first = arr.isEmpty ();

            arr.add (obj);

            // see comment for the variable dataObjects

            dataObjects.add (obj);

            if (!processingUpdate) {

                // if we should not notify during processing update

                // skip the rest

                return;

            }

            if (first) {

                synchronized (this) {

                    this.notify ();

                    refreshKeys (arr);

                }

                return;

            }

            if (System.currentTimeMillis () > time) {

                if (!arr.isEmpty ()) {

                    // add the nodes

                    synchronized (this) {

                        refreshKeys (arr);

                    }

                    delay *= 2;

                }

                time = System.currentTimeMillis () + delay;

            }

        }

        /** All objects has been recognized.

         * @param arr list of DataObjects

         */

        public void finished(java.util.List arr) {

            synchronized (this) {

                this.notify ();

                this.processingFinished = true;

                // change the order because initialize method has already finished

                refreshKeys (arr);

            }

        }

        /** Getter for first map.

        */

        public synchronized void waitFirst () {

            try {

                this.wait (50);

            } catch (InterruptedException e) {

                throw new IllegalStateException();

            }

        }

        /** Called when a task finishes running.

         * @param task the finished task

--

            List toSet;

            if (! active) {

            synchronized (this) { // 1

                setKeys (java.util.Collections.EMPTY_SET);

                toSet = refKeys;

                return;

                refKeys = null;

            }

            if (toSet != null) {

                // toSet can be null if 

                //   1. a task blocks on synchronized(this) // 1

                //   2. refreshKeys calls refKey = <newvalue> + refTask.schedule

                //   3. a task uses the new value, but is already planned =>

                //   4. it will be run next time with toSet == null

                if (FolderChildren.this.err != null) FolderChildren.this.err.log("setKeys: " + toSet);

                FolderChildren.this.setKeys(toSet);

--

            synchronized (this) {

            DataObject []ch = folder.getChildren();

                if (processingFinished) {

            Object []keys = new Object[ch.length];

                    if (FolderChildren.this.refreshTask == refTask) {

            for (int i = 0; i < keys.length; i++) {

                        if (err != null) err.log("fix for #30153 applied ");

                keys[i] = new Pair(ch[i].getPrimaryFile());

                        FolderChildren.this.refreshTask = Task.EMPTY;

//                        refTask.cancel();

                    }

                }

--

--

    */

     * It serves as a key for the given data object.

--

     * It is here to create something different then data object,

     * because the data object should be finalized when not needed and

     * that is why it should not be used as a key.

     */