nstream.cpp

Go to the documentation of this file.

/*
 * nstream.cpp
 *
 * Copyright (c) 2009 Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Basic nstream object implementations.  see nstream.h
 */

// includes --------------------------------------------------------------------
#include "nstream.h"            // always include our own header first

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "util/file.h"          // pathname manipulations



namespace nstream {

// interface destructors
Stream::~Stream(void) throw() { }
Entry::~Entry(void) throw() { }
File::~File(void) throw() { }
Folder::~Folder(void) throw() { }
Manager::~Manager(void) throw() { }



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static eIterationFlag
maybeVisit
(
IN Entry * entry,
IN visit_entry_fn callback,
IN void * context,
IN const SetString * extensions,
IN const char * filter,
IN bool visitHidden
)
{
        ASSERT(entry, "null");
        ASSERT(callback, "null");
        // ASSERT(context) -- we don't care
        // ASSERT(extensions) -- can be null
        // ASSERT(filter) -- can be null

        const char * name = entry->getName();
        ASSERT(name, "null");

        // do we need to check extension?
        if (extensions) {
                const char * ext = GetExtension(name);
                if (!ext ||
                    extensions->end() == extensions->find(ext)) {
                        // no extension, or doesn't match
                        // don't visit, but keep iterating
                        return eIterate_Continue;
                }
        }

        // do we need to check path?
        if (filter) {
                if (!strstr(name, filter)) {
                        // path (name) does not contain filter as substring
                        // don't visit, but keep iterating
                        return eIterate_Continue;
                }
        }

        // okay, visit
        return callback(entry, context);
}



////////////////////////////////////////////////////////////////////////////////
//
//      Public APIs
//
////////////////////////////////////////////////////////////////////////////////

void
Stream::writeDiagnostics
(
IO std::ostream& out
)
{
        // this is helpful for debugging
        // we do NOT write the full stream!
        // just some diagnostic information

        smart_ptr<File> file = this->getFile();
        if (file) {
                const char * filename = file->getName();
                out << "read-only stream from file: '" << filename << "'";
        } else {
                out << "(stream from unknown file)";
        }
}



smart_ptr<Stream>
getStreamRelativeTo
(
IN Stream * startStream,
IN const char * relativePath
)
{
        perf::Timer timer("getStreamRelativeTo");
        ASSERT(startStream, "null");
        ASSERT(relativePath, "null");

//      DPRINTF("In getStreamRelativeTo()...");
//      DPRINTF("  relative path: %s", relativePath);

        smart_ptr<File> file = startStream->getFile();
        THROW(file, "failed to get File for Stream");

        const char * name = file->getName();
        ASSERT(name, "File contains null name");

        std::string relName = getPathRelativeTo(name, relativePath);
//      DPRINTF("  relative path as resolved: %s", relName.c_str());

        smart_ptr<Manager> mgr = file->getManager();
        THROW(mgr, "File returned null manager");

        smart_ptr<File> newFile = mgr->getEntry(relName.c_str());
        if (!newFile) {
                DPRINTF("No such entry, or not a file: %s", relName.c_str());
                return NULL;
        }

        // open a stream!
        return newFile->openStream();
}



smart_ptr<Stream>
openNamedStream
(
IN Manager * mgr,
IN const char * name
)
{
        ASSERT(mgr, "null");
        ASSERT(name, "null");

        smart_ptr<File> file = mgr->getEntry(name);
        THROW(file,
            "Could not get File at path (does not exist, or is folder): "
            << name);

        smart_ptr<Stream> stream = file->openStream();
        THROW(stream, "Failed to open stream for File: " << name);

        return stream;
}



std::string
getStreamName
(
IN Stream * stream
)
{
        ASSERT(stream, "null");

        smart_ptr<File> file = stream->getFile();
        THROW(file, "failed to retrieve File for Stream");

        return file->getName();
}



eIterationFlag
walkChildFolders
(
IN Folder * root,
IN visit_entry_fn callback,
IN void * context,
IN const SetString * extensions,
IN const char * filter,
IN bool visitHidden
)
{
        ASSERT(root, "null");
        ASSERT(callback, "null");
        // ASSERT(context) -- can be null
        // ASSERT(extensions) -- can be null
        // ASSERT(filter) -- can be null

        root->resetIteration();         // just to be safe
        while (smart_ptr<Entry> entry = root->getNextChild()) {
                const char * name = entry->getName();
                ASSERT(name, "null");
                name = GetFilename(name);

//              DPRINTF("name='%s', visitHidden='%s'", name,
//                  (visitHidden) ? "true" : "false");

                // does this begin with a dot?  (note: safe check for UTF-8)
                if ('.' == name[0] && !visitHidden) {
//                      DPRINTF("Skipping entry: '%s'", name);
                        // yes, begins with a dot and we're supposed to skip
                        continue;
                }

                // visit first (if matches criteria)
                if (eIterate_Stop ==
                    maybeVisit(entry, callback, context, extensions, filter,
                                visitHidden)) {
                        return eIterate_Stop;
                }

                // is this is a folder object?  recurse
                Folder * child = dynamic_cast<Folder *>((Entry *) entry);
                if (!child)
                        continue;       // not a folder, go to next child
                if (eIterate_Stop == walkChildFolders(child, callback,
                                              context, extensions, filter,
                                              visitHidden))
                        return eIterate_Stop;
        }

        return eIterate_Continue;
}



};      // nstream namespace