<change id="createAndOpen">

            <api name="filesystems"/>

            <summary>FileObject.createAndOpen</summary>

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

            <date day="10" month="9" year="2010"/>

            <author login="jtulach"/>

            <compatibility addition="yes" binary="compatible" source="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>

            <description>

                <p>

                Create a file and write its content (almost) atomically using the new

                <a href="@TOP@/org/openide/filesystems/FileObject.html#createAndOpen(java.lang.String)">FileObject.createAndOpen</a>

                method.

                </p>

            </description>

            <class package="org.openide.filesystems" name="FileObject"/>

            <issue number="40739"/>

        </change>

            if (atomicAction instanceof FileSystem.AsyncAtomicAction) {

                if (((FileSystem.AsyncAtomicAction)atomicAction).isAsynchronous()) {

                    return true;

                }

            }

    /** 

     * Creates new file in this folder and immediately opens it for writing.

     * This method prevents possible race condition which can happen

     * when using the {@link #createData(java.lang.String)} method.  

     * Using {@link #createData(java.lang.String) that method} makes it

     * possible for someone to read the content of the newly created

     * file before its content is written. This method does its best to eliminate

     * such race condition.

     * 

     * <p class="nonnormative">

     * This method usually delivers both, {@link FileChangeListener#fileDataCreated(org.openide.filesystems.FileEvent) data created}

     * and {@link FileChangeListener#fileChanged(org.openide.filesystems.FileEvent) changed} 

     * events. Preferably it delivers them asynchronously. The assumption

     * is that the file will be (at least partially) written before

     * the listeners start to process the first event. The safety is additionally

     * ensured by <q>mutual exclusion</q> between output and input streams 

     * for the same file (any call to {@link #getInputStream()} will be blocked

     * for at least two seconds if there is existing open output stream). 

     * If you finish writing the content of your file in those two seconds,

     * you can be sure, nobody will have read its content yet.

     * </p>

     * 

     * @param name name of file to create with its extension

     * @return output stream to use to write content of the file

     * @throws IOException if the file cannot be created (e.g. already exists), or if <code>this</code> is not a folder

     * @since 7.40

     */

    public OutputStream createAndOpen(final String name) throws IOException {

        class R implements FileSystem.AsyncAtomicAction {

            OutputStream os;

            @Override

            public void run() throws IOException {

                FileObject fo = createData(name);

                os = fo.getOutputStream();

            }

            @Override

            public boolean isAsynchronous() {

                return true;

            }

        }

        R r = new R();

        getFileSystem().runAtomicAction(r);

        return r.os;

    }

    static interface AsyncAtomicAction extends AtomicAction {

        boolean isAsynchronous();

    }

    public void  testCreateAndOpen() throws Exception {

        checkSetUp();

        FileObject f;

        try {

            f = getTestFolder1(root).createFolder("createAndOpen");

        } catch (IOException iex) {

            fsAssert("If read only FS, then OK to fail",

            fs.isReadOnly());

            return;

        }

        final FileObject fold = f;

        class L extends FileChangeAdapter {

            String dataCreated;

            String changed;

            @Override

            public synchronized void fileDataCreated(FileEvent fe) {

                try {

                    FileObject ch = fold.getFileObject("child.txt");

                    assertNotNull("Child found", ch);

                    dataCreated = ch.asText();

                    notifyAll();

                } catch (IOException ex) {

                    throw new IllegalStateException(ex);

                }

            }

            @Override

            public synchronized void fileChanged(FileEvent fe) {

                try {

                    FileObject ch = fold.getFileObject("child.txt");

                    assertNotNull("Child found", ch);

                    changed = ch.asText();

                    notifyAll();

                } catch (IOException ex) {

                    throw new IllegalStateException(ex);

                }

            }

            public synchronized void waitEvents() throws InterruptedException {

                for (int i = 0; i < 100; i++) {

                    if (changed != null && dataCreated != null) {

                        break;

                    }

                    wait(100);

                }

            }

        }

        L l = new L();

        fold.addFileChangeListener(l);

        assertEquals("No children", 0, fold.getChildren().length);

        OutputStream os = fold.createAndOpen("child.txt");

        os.write("Ahoj".getBytes());

        os.close();

        FileObject ch = fold.getFileObject("child.txt");

        assertNotNull("Child found", ch);

        assertEquals("Right content now", "Ahoj", ch.asText());

        l.waitEvents();

        assertEquals("Right content when changed", "Ahoj", l.changed);

        assertEquals("Right content when created", "Ahoj", l.dataCreated);

    }