aesop-map/map.cpp

Go to the documentation of this file.

/*
 * map.cpp
 *
 * Copyright (C) 2008  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 map support.
 */

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

#include "common/wave_ex.h"
#include "perf/perf.h"


namespace aesop {


// interface destructor implementation
MapFormatReader::~MapFormatReader(void) throw() { }

typedef std::vector<smart_ptr<MapFormatReader> > vec_reader_t;

static vec_reader_t s_readers;  // static (process-wide) list of readers


//
//      static helper methods
//



//
//      public API
//

void
registerMapFormatReader
(
IN smart_ptr<MapFormatReader>& reader
)
{
        ASSERT(reader, "registering a null reader?");

        s_readers.push_back(reader);
}



smart_ptr<Map>
loadMap
(
IN const char * id,
IN const char * path
)
{
        perf::Timer timer("loadMap");
        ASSERT(id, "null");
        ASSERT(path, "null");

        smart_ptr<Map> map;
        for (vec_reader_t::iterator i = s_readers.begin(); i != s_readers.end();
             ++i) {
                MapFormatReader * reader = *i;
                ASSERT(reader, "null map reader in vector?");

                bool isFormat = false;
                {
                        perf::Timer timer("loadMap::isMyFormat");
                        isFormat = reader->isMyFormat(id, path);
                }

                if (!isFormat)
                        continue;       // skip this reader

                // for now we dump information about the path and the
                //   general reader description
                DPRINTF("Path '%s' is claimed by reader.", path);
                const char * desc = reader->getDescription();
                ASSERT(desc, "reader returned a null description?");
                DPRINTF("  Reader: '%s'", desc);

                std::string timer_name = "loadMap::";
                timer_name += id;
                try {
                        perf::Timer timer(timer_name.c_str());
                        map = reader->loadMap(id, path);
                } catch (std::exception& e) {
                        WAVE_EX(wex);
                        wex << "Failed to load map " << id << " from " << path;
                        wex << "\n" << e.what();
                }
                break;
        }

        if (!map) {
                WAVE_EX(wex);
                wex << "Failed to load map at '" << path << "'.  No reader found!";
                return NULL;
        }

        // all done!
        return map;
}



};      // aesop namespace