<change id="Mutex.Wrapper">

        <api name="util"/>

        <summary>Mutex made pluggable</summary>

        <version major="7" minor="10"/>

        <date day="7" month="1" year="2008"/>

        <author login="mkubec"/>

        <compatibility addition="yes"/>

        <description>

            <p>

                Added new constructor

                <a href="@TOP@/org/openide/util/Mutex.html">Mutex(Priviledged, Executor)</a>

                that allows creators of the mutex to intercept and wrap posted actions

                with custom code.

            </p>

        </description> 

        <class package="org.openide.util" name="Mutex"/>

        <issue number="123832"/>

    </change>

import java.util.concurrent.Executor;

    /** wrapper, if any */

    private final Executor wrapper;

        this.wrapper = null;

        this.wrapper = null;

        this.wrapper = null;

    }

    /** Constructor for those who wish to do some custom additional tasks

     * whenever an action or runnable is executed in the {@link Mutex}. This

     * may be useful for wrapping all the actions with custom {@link ThreadLocal}

     * value, etc. Just implement the {@link Executor}'s <code>execute(Runnable)</code>

     * method and do pre and post initialization tasks before running the runnable.

     * <p>

     * The {@link Executor#execute} method shall return only when the passed in

     * {@link Runnable} is finished, otherwise methods like {@link Mutex#readAccess(Action)} and co.

     * might not return proper result.

     * 

     * @param privileged can enter privileged states of this Mutex

     *  @param executor allows to wrap the work of the mutex with a custom code

     * @since 7.12

     */

    public Mutex(Privileged privileged, Executor executor) {

        LOCK = new Mutex(privileged);

        this.wrapper = executor;

        if (wrapper != null) {

            try {

                return doWrapperAccess(action, null, true);

            } catch (MutexException e) {

                throw (InternalError) new InternalError("Exception from non-Exception Action").initCause(e.getException()); // NOI18N

            }

        }

        if (wrapper != null) {

            return doWrapperAccess(action, null, true);

        }

        if (wrapper != null) {

            try {

                doWrapperAccess(null, action, true);

                return;

            } catch (MutexException ex) {

                throw (IllegalStateException)new IllegalStateException().initCause(ex);

            }

        }

        if (wrapper != null) {

            try {

                return doWrapperAccess(action, null, false);

            } catch (MutexException e) {

                throw (InternalError) new InternalError("Exception from non-Exception Action").initCause(e.getException()); // NOI18N

            }

        }

        if (wrapper != null) {

            return doWrapperAccess(action, null, false);

        }

        if (wrapper != null) {

            try {

                doWrapperAccess(null, action, false);

            } catch (MutexException ex) {

                throw (IllegalStateException)new IllegalStateException().initCause(ex);

            }

            return;

        }

        if (wrapper != null) {

            Mutex m = (Mutex)LOCK;

            return m.isReadAccess();

        }

        if (wrapper != null) {

            Mutex m = (Mutex)LOCK;

            return m.isWriteAccess();

        }

        if (wrapper != null) {

            Mutex m = (Mutex)LOCK;

            m.postRequest(mutexMode, run, wrapper);

            return;

        }

            if (exec != null) {

                class Exec implements Runnable {

                    public void run() {

                        enter(mutexMode, t, true);

                        try {

                            run.run();

                        } finally {

                            leave(t);

                        }

                    }

                }

                exec.execute(new Exec());

                return;

            }

    // -------------------------------- WRAPPERS --------------------------------

    private <T> T doWrapperAccess(

        final ExceptionAction<T> action, final Runnable runnable, final boolean readOnly

    ) throws MutexException {

        class R implements Runnable {

            T ret;

            MutexException e;

            public void run() {

                Mutex m = (Mutex)LOCK;

                try {

                    if (readOnly) {

                        if (action != null) {

                            ret = m.readAccess(action);

                        } else {

                            m.readAccess(runnable);

                        }

                    } else {

                        if (action != null) {

                            ret = m.writeAccess(action);

                        } else {

                            m.writeAccess(runnable);

                        }

                    }

                } catch (MutexException ex) {

                    this.e = ex;

                }

            }

        }

        R run = new R();

        wrapper.execute(run);

        if (run.e != null) {

            throw run.e;

        }

        return run.ret;

    }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.openide.util;

import java.util.concurrent.Executor;

import junit.framework.Test;

import org.netbeans.junit.NbTestCase;

import org.netbeans.junit.NbTestSuite;

import org.openide.util.Mutex.Action;

import org.openide.util.Mutex.ExceptionAction;

public class MutexWrapTest extends NbTestCase implements Executor {

    Mutex.Privileged p;

    Mutex m;

    ThreadLocal<Object> IN = new ThreadLocal<Object>();

    public MutexWrapTest(java.lang.String testName) {

        super(testName);

    }

    public static Test suite() {

//        return new MutexWrapTest("testPostRead");

        return new NbTestSuite(MutexWrapTest.class);

    }

    /** Sets up the test.

     */

    @Override

    protected void setUp () {

        p = new Mutex.Privileged ();

        m = new Mutex (p, this);

    }

    public void testRead() throws Exception {

        A arg = new A();

        Object ret = m.readAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testWrite() throws Exception {

        A arg = new A();

        Object ret = m.writeAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testExRead() throws Exception {

        E arg = new E();

        Object ret = m.readAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testExWrite() throws Exception {

        E arg = new E();

        Object ret = m.writeAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testRunRead() throws Exception {

        R arg = new R();

        m.readAccess(arg);

        assertTrue("Executed", arg.exec);

    }

    public void testRunWrite() throws Exception {

        R arg = new R();

        m.writeAccess(arg);

        assertTrue("Executed", arg.exec);

    }

    public void testPostRead() throws Exception {

        R arg = new R();

        m.postReadRequest(arg);

        assertTrue("Executed", arg.exec);

    }

    public void testPostReadFromWrite() throws Exception {

        R arg = new R();

        Del del = new Del();

        del.read = arg;

        m.writeAccess(del);

        assertTrue("Executed", arg.exec);

    }

    public void testPostReadFromRead() throws Exception {

        R arg = new R();

        Del del = new Del();

        del.read = arg;

        m.readAccess(del);

        assertTrue("Executed", arg.exec);

    }

    public void testPostWrite() throws Exception {

        R arg = new R();

        m.postWriteRequest(arg);

        assertTrue("Executed", arg.exec);

    }

    public void testPostWriteFromRead() throws Exception {

        R arg = new R();

        Del del = new Del();

        del.write = arg;

        m.readAccess(del);

        assertTrue("Executed", arg.exec);

    }

    public void testPostWriteFromWrite() throws Exception {

        R arg = new R();

        Del del = new Del();

        del.write = arg;

        m.writeAccess(del);

        assertTrue("Executed", arg.exec);

    }

    private class A implements Mutex.Action<Object> {

        boolean exec;

        public Object run() {

            exec = true;

            assertEquals("I am wrapped", MutexWrapTest.this, IN.get());

            return this;

        }

    }

    private class E implements Mutex.ExceptionAction<Object> {

        boolean exec;

        public Object run() {

            exec = true;

            assertEquals("I am wrapped", MutexWrapTest.this, IN.get());

            return this;

        }

    }

    private class R implements Runnable {

        boolean exec;

        public void run() {

            exec = true;

            assertEquals("I am wrapped", MutexWrapTest.this, IN.get());

        }

    }

    private class Del implements Runnable {

        Runnable write;

        Runnable read;

        public void run() {

            if (write != null) {

                m.postWriteRequest(write);

            }

            if (read != null) {

                m.postReadRequest(read);

            }

        }

    }

    public void execute(final Runnable run) {

        Object prev = IN.get();

        IN.set(MutexWrapTest.this);

        try {

            run.run();

        } finally {

            IN.set(prev);

        }

        assertFalse("No read", m.isReadAccess());

        assertFalse("No write", m.isWriteAccess());

    }

}