restream.cpp

Go to the documentation of this file.

/*
 * restream.cpp
 *
 * Copyright (c) 2009,2011 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.
 *
 *
 * Resource-based named streams.  See resources.h and nstream.h
 */

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

#include "common/wave_ex.h"
#include "wave-crypto/wave-crypto.h"
#include "perf/perf.h"
#include "resources/resources.h"
#include "util/file.h"


namespace nstream {


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

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



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

class ResStream : public Stream {
public:
        // constructor, destructor ---------------------------------------------
        ~ResStream(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 * nameSpace,
                                IN const char * name);

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

        // private member data -------------------------------------------------
        std::istringstream      m_stream;       // raw stringstream
        std::string             m_name;
        std::string             m_nameSpace;
};



smart_ptr<File>
ResStream::getFile
(
void
)
{
        std::string fullPath = m_nameSpace;
        fullPath += "/";
        fullPath += m_name;

        // we create entry and rely on auto-upcast
        return getEntryForName(fullPath.c_str());
}



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

        //DPRINTF("Creating stream for namespace='%s', name='%s'",
        //    nameSpace, name);

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

        local->m_nameSpace = nameSpace;
        local->m_name = name;

        int bytes = getResourceSize(nameSpace, name);
        ASSERT_THROW(bytes > 0,
            "No such resource: namespace='" << nameSpace << "', name='" <<
            name);

        const byte_t * value = getResourceData(nameSpace, name);
        ASSERT_THROW(value > 0,
            "No such resource: namespace='" << nameSpace << "', name='" <<
            name);

        // string which is the source of our string
        std::string source;
        source.assign((const char *) value, bytes);

        // reset stream
        local->m_stream.str(source);
        ASSERT_THROW(local->m_stream.good(),
            "Failed to open resouce for reading: namespace='" << nameSpace <<
            "', name='" << name << "'");

        // all good
        return local;
}



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

class ResFile : public File {
public:
        // constructor, destructor ---------------------------------------------
        ~ResFile(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 getResourceStreamManager();
                }

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

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

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

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



smart_ptr<Stream>
ResFile::openStream
(
void
)
{
        return ResStream::create(m_nameSpace.c_str(), m_name.c_str());
}



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

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

        local->m_nameSpace = nameSpace;
        local->m_name = name;

        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      ResFolder -- 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 ResFolder : public Folder {
public:
        // constructor, destructor ---------------------------------------------
        ~ResFolder(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 getResourceStreamManager();
                }

        // 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);

private:
        // private helper methods ----------------------------------------------
        ResFolder(void) throw();

        // private member data -------------------------------------------------
        std::string     m_name;
        int             m_index;
};



ResFolder::ResFolder(void)
throw()
{
        m_index = 0;
}



ResFolder::~ResFolder(void)
throw()
{
}



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

        if ("" == m_name) {
                return ResFolder::create(name);
        } else {
                return ResFile::create(m_name.c_str(), name);
        }
}



void
ResFolder::resetIteration
(
void
)
{
        m_index = 0;
}



smart_ptr<Entry>
ResFolder::getNextChild
(
void
)
{
        if ("" == m_name) {
                // we are the root, so iterate namespaces instead of resources
                int nMax = getResourceNamespaceCount();
                if (m_index >= nMax) {
                        // we are at max!
                        return NULL;
                }

                // use this namespace
                return ResFolder::create(getResourceNamespaceName(m_index++));
        }

        // we are a namespace, so iterate resources in this namespace
        const char * name = getResourceName(m_name.c_str(), m_index);
        if (!name) {
                return NULL;    // our index is (no longer) valid
        }

        // increment index
        ++m_index;

        // return this child
        return this->getChildByName(name);
}



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

        //DPRINTF("Creating folder for name: '%s'", name);

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

        local->m_name = name;

        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      ResMgr -- class that implements the nstream::Manager interface for
//              built-in resources (see the resources library)
//
////////////////////////////////////////////////////////////////////////////////

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

        // public class methods ------------------------------------------------
        void initialize(void);

        // 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 -------------------------------------------------
};



void
ResMgr::initialize
(
void
)
{
}



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

        return getEntryForName(name);
}



smart_ptr<Folder>
ResMgr::getRoot
(
void
)
{
        return ResFolder::create("");
}



std::string
ResMgr::getFullName
(
IN const char * name
)
{
        ASSERT(name, "null");
        return name;
}



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

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

        DPRINTF("Creating entry for name: %s", name);

        // parse name: skip any leading slashes
        while (*name && '/' == *name) {
                ++name;
        }

        // is this a folder (namespace) or a resource?
        std::string parentDir;
        GetParentDirectory(name, parentDir);
        const char * resname = GetFilename(name);

        if ("" == parentDir || !*resname) {
                DPRINTF("  ...namespace!");

                const char * nameSpace = NULL;
                if (!*resname) {
                        // this was a name with a trailing slash
                        nameSpace = parentDir.c_str();
                } else {
                        // this was a bare name
                        nameSpace = resname;
                }

                // create folder for namespace (or empty for root)
                return ResFolder::create(nameSpace);
        }

        // this is a namespace + resource name
        DPRINTF("   ...namespace + resource name");
        DPRINTF("   namespace: '%s'", parentDir.c_str());
        DPRINTF("   resource:  '%s'", resname);

        // assume file
        return ResFile::create(parentDir.c_str(), resname);
}



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

smart_ptr<Manager>
getResourceStreamManager
(
void
)
{
        smart_ptr<ResMgr> local = new ResMgr;
        local->initialize();
        return local;
}



};      // nstream namespace