fs-nstream.cpp

Go to the documentation of this file.

/*
 * fs-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 filesystem namespace.  See nstream.h
 */

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

#include <fstream>
#ifdef WIN32
#define stat _stat
#include <sys/types.h>
#else   // WIN32
#include <unistd.h>
#endif  // WIN32
#include <sys/stat.h>

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "util/file.h"
#include "util/token_stream.h"


namespace nstream {


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

// declaration only
static smart_ptr<Entry> getEntryForName(IN const char * name,
                                IN const char * rootDir);   // namespace root


static std::string
getFullPath
(
IN const char * rootDir,
IN const char * name
)
{
        ASSERT(rootDir, "null");
        ASSERT(name, "null");

        std::string retval;
        appendPath(rootDir, name, retval);
        return retval;
}



////////////////////////////////////////////////////////////////////////////////
//
//      FSStream -- class that implements the nstream::Stream interface for a
//              local filesystem.
//
////////////////////////////////////////////////////////////////////////////////

class FSStream : public Stream {
public:
        // constructor, destructor ---------------------------------------------
        ~FSStream(void) throw() { }

        // nstream::Stream class interface methods ----------------------------
        std::istream& getStream(void) { return m_stream; }
        smart_ptr<File> getFile(void);

        // static factory methods ----------------------------------------------
        static smart_ptr<Stream> create(IN const char * name,
                                IN const char * rootDir);

private:
        // private helper methods ----------------------------------------------
        FSStream(void) throw() { }

        // private member data -------------------------------------------------
        std::ifstream           m_stream;       // raw fstream
        std::string             m_name;
        std::string             m_rootDir;
};



smart_ptr<File>
FSStream::getFile
(
void
)
{
        // we create entry and rely on auto-upcast
        smart_ptr<File> file =
            getEntryForName(m_name.c_str(), m_rootDir.c_str());

        // this routine isn't supposed to return null, so throw if there's a
        //      problem.  in general we'll get errors only if the file has been
        //      renamed out from under us
        THROW(file,
            "filesystem stream is for file now gone: " << m_rootDir << "/"
            << m_name);

        // all good
        return file;
}



smart_ptr<Stream>
FSStream::create
(
IN const char * name,
IN const char * rootDir
)
{
        ASSERT(name, "null");
        ASSERT(rootDir, "null");

        smart_ptr<FSStream> local = new FSStream;
        ASSERT(local, "out of memory");

        local->m_name = name;
        local->m_rootDir = rootDir;

        // get full path
        std::string full_path = getFullPath(rootDir, name);

        // open stream!
        local->m_stream.open(full_path.c_str(), std::ios::binary);
        THROW(local->m_stream.good(),
            "Failed to open file for reading: " << full_path);

        // all good
        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      FSFile -- class that implements the nstream::File interface for a
//              local filesystem.
//
////////////////////////////////////////////////////////////////////////////////

class FSFile : public File {
public:
        // constructor, destructor ---------------------------------------------
        ~FSFile(void) throw() { }

        // nstream::Entry class interface methods -----------------------------
        eType getType(void) const throw() { return eType_File; }
        const char * getName(void) const throw() { return m_name.c_str(); }
        smart_ptr<Manager> getManager(void) {
                        return getFilesystemManager(m_rootDir.c_str());
                }

        // nstream::File class interface methods ------------------------------
        smart_ptr<Stream> openStream(void);

        // static factory methods ----------------------------------------------
        static smart_ptr<File> create(IN const char * name,
                                IN const char * rootDir);

private:
        // private helper methods ----------------------------------------------
        FSFile(void) throw() { }

        // private member data -------------------------------------------------
        std::string             m_name;
        std::string             m_rootDir;
};



smart_ptr<Stream>
FSFile::openStream
(
void
)
{
        return FSStream::create(m_name.c_str(), m_rootDir.c_str());
}



smart_ptr<File>
FSFile::create
(
IN const char * name,
IN const char * rootDir
)
{
        ASSERT(name, "null");
        ASSERT(rootDir, "null");

        smart_ptr<FSFile> local = new FSFile;
        ASSERT(local, "out of memory");

        local->m_name = name;
        local->m_rootDir = rootDir;

        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      FSFolder -- class that implements the nstream::Folder interface for a
//              local filesystem.
//
//      NOTE: this is built with an iterative model.  This is to handle the
//      (extreme) cases where a filesystem contains thousands of entries per
//      directory.
//
////////////////////////////////////////////////////////////////////////////////

class FSFolder : public Folder {
public:
        // constructor, destructor ---------------------------------------------
        ~FSFolder(void) throw();

        // nstream::Entry class interface methods -----------------------------
        eType getType(void) const throw() { return eType_Folder; }
        const char * getName(void) const throw() { return m_name.c_str(); }
        smart_ptr<Manager> getManager(void) {
                        return getFilesystemManager(m_rootDir.c_str());
                }

        // nstream::Folder class interface methods ----------------------------
        smart_ptr<Entry> getChildByName(IN const char * name);
        void resetIteration(void);
        smart_ptr<Entry> getNextChild(void);

        // static factory methods ----------------------------------------------
        static smart_ptr<Folder> create(IN const char * name,
                                IN const char * root);

private:
        // private helper methods ----------------------------------------------
        FSFolder(void) throw();
        void closeDir(void) throw();

        // private member data -------------------------------------------------
        DIR *           m_DIR;          // directory handle
        std::string     m_name;
        std::string     m_rootDir;
};



FSFolder::FSFolder(void)
throw()
:
m_DIR(NULL)
{
}



FSFolder::~FSFolder(void)
throw()
{
        this->closeDir();
}



smart_ptr<Entry>
FSFolder::getChildByName
(
IN const char * name
)
{
        ASSERT(name, "null");

        std::string relPath = getFullPath(m_name.c_str(), name);
        return getEntryForName(relPath.c_str(), m_rootDir.c_str());
}



void
FSFolder::resetIteration
(
void
)
{
        this->closeDir();
}



smart_ptr<Entry>
FSFolder::getNextChild
(
void
)
{
        if (!m_DIR) {
                // no directory handle yet!  Need to open directory
                std::string full_path =
                    getFullPath(m_rootDir.c_str(), m_name.c_str());
                m_DIR = opendir(full_path.c_str());
                THROW(m_DIR,
                    "Failed to open directory: " << full_path);
        }

        // get next entry
        struct dirent * entry = NULL;
        while (true) {
                entry = readdir(m_DIR);
                if (!entry) {
                        // end of directory entries!
                        this->closeDir();
                        return NULL;
                }

                // skip entries that aren't semantically valid for the
                //   nstream::Folder iteration
                if (!strcmp(".", entry->d_name) ||
                    !strcmp("..", entry->d_name)) {
                        continue;       // skip these
                }

                // entry is valid!
                break;
        }
        ASSERT(entry, "null");

        // have a valid entry
        std::string relPath = getFullPath(m_name.c_str(), entry->d_name);
        return getEntryForName(relPath.c_str(), m_rootDir.c_str());
}



void
FSFolder::closeDir
(
void
)
throw()
{
        if (m_DIR) {
                closedir(m_DIR);
                m_DIR = NULL;
        }
}



smart_ptr<Folder>
FSFolder::create
(
IN const char * name,
IN const char * rootDir
)
{
        ASSERT(name, "null");
        ASSERT(rootDir, "null");

//      DPRINTF("Creating folder for name: %s", name);
//      DPRINTF("  root dir: %s", rootDir);

        smart_ptr<FSFolder> local = new FSFolder();
        ASSERT(local, "out of memory");

        local->m_name = name;
        local->m_rootDir = rootDir;

        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      FSMgr -- class that implements the nstream::Manager interface for a
//              local filesystem
//
////////////////////////////////////////////////////////////////////////////////

class FSMgr : public Manager {
public:
        // constructor, destructor ---------------------------------------------
        ~FSMgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN const char * rootDir);

        // nstream::Manager class interface methods ---------------------------
        smart_ptr<Entry> getEntry(IN const char * name);
        smart_ptr<Folder> getRoot(void);
        std::string getFullName(IN const char * name);

private:
        // private member data -------------------------------------------------
        std::string             m_rootDir;
};



void
FSMgr::initialize
(
IN const char * rootDir
)
{
        ASSERT(rootDir, "null");

        m_rootDir = rootDir;
}



smart_ptr<Entry>
FSMgr::getEntry
(
IN const char * name
)
{
        ASSERT(name, "null");

        return getEntryForName(name, m_rootDir.c_str());
}



smart_ptr<Folder>
FSMgr::getRoot
(
void
)
{
        return FSFolder::create("", m_rootDir.c_str());
}



std::string
FSMgr::getFullName
(
IN const char * name
)
{
        ASSERT(name, "null");
        return getFullPath(m_rootDir.c_str(), name);
}



////////////////////////////////////////////////////////////////////////////////
//
//      static methods needed by the above
//
////////////////////////////////////////////////////////////////////////////////

static smart_ptr<Entry>
getEntryForName
(
IN const char * name,
IN const char * rootDir
)
{
        ASSERT(name, "null");
        ASSERT(rootDir, "null");

        // DPRINTF("Creating entry for name: %s", name);
        // DPRINTF("  root dir: %s", rootDir);

        std::string full_path = getFullPath(rootDir, name);
        const char * path = full_path.c_str();

        // look up stats on this path
        struct stat sb;
        if (stat(path, &sb)) {
                DPRINTF("Could not stat filesystem path: %s", path);
                return NULL;
        }

        // see if directory
        if (S_IFDIR & sb.st_mode) {
                return FSFolder::create(name, rootDir);
        }

        // assume file
        return FSFile::create(name, rootDir);
}



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

smart_ptr<Manager>
getFilesystemManager
(
IN const char * root_dir
)
{
        ASSERT(root_dir, "null");

        smart_ptr<FSMgr> local = new FSMgr;
        local->initialize(root_dir);

        return local;
}



};      // nstream namespace