datahash_text.cpp

Go to the documentation of this file.

/*
 * datahash_text.cpp
 *
 * Copyright (C) 2003, 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.
 *
 *
 * Methods for reading/write hashes in/out of text streams.
 */

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

#include <fstream>
#include <sstream>

#include "common/wave_ex.h"

#include "perf/perf.h"

#include "util/file.h"
#include "util/parsing.h"



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

static smart_ptr<Datahash>
readHashFromStreamInternal
(
IO std::istream& stream
)
{
        smart_ptr<Datahash> root = new Datahash;
        ASSERT(root, "failed to create empty datahash");

        eParseBehavior behave = eParse_StripComments;

        // keep reading lines
        while (!stream.eof()) {
                std::string line = getNextLineFromStream(stream, behave);

                // get key name
                std::string key_name;
                const char * remain =
                    getNextTokenFromString(line.c_str(), key_name, behave);

                // empty?
                if ("" == key_name) {
                        continue;       // skip this line
                }

                // end of hash?
                if ("}" == key_name)
                        break;          // end of hash

                // skip whitespace
                while (*remain && isspace(*remain)) {
                        ++remain;
                }

                // truncate trailing whitespace
                long N = strlen(remain);
                while (N > 0 && isspace(remain[N - 1])) {
                        --N;
                }

                std::string value;
                for (long l = 0; l < N; ++l) {
                        value += remain[l];
                }

        //      DPRINTF("key:'%s'   value:'%s'", key_name.c_str(),
        //          value.c_str());

                if (!strcmp("{", value.c_str())) {
                        // complex value
                        smart_ptr<Datahash> hash =
                            readHashFromStream(key_name.c_str(), stream);
                        ASSERT(hash, "null value after reading subhash");

                        // add value
                        root->insert(key_name, hash);
                } else {
                        // simple value
                        root->insert(key_name, value);
                }
        }

        // success!
        return root;
}



static void
newlineAndIndent
(
IO std::ostream& stream,
IN int indent
)
throw()
{
        ASSERT(indent >= 0, "bad indent value");

        stream << "\n";
        for (int i = 0; i < indent; i++) {
                stream << "\t";
        }
}



void
writeHashToStreamInternal
(
IN const Datahash * hash,
IO std::ostream& stream,
IN int indent
)
{
        ASSERT(hash, "NULL hash");
        ASSERT(indent >= 0, "Bad indent value");

        // iterate over all entries
        Datahash::iterator_t i;
        hash->getIterator(i);
        std::string k;
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i, k)) {
                ASSERT(phv, "null?");
                const char * key = k.c_str();
                ASSERT(key, "null");

                // what sort of data element is this?
                if (eHashDataType_String == phv->type) {
                        newlineAndIndent(stream, indent);
                        stream << key << "\t" << phv->text;
                } else {
                        // subhash
                        newlineAndIndent(stream, indent);
                        stream << key << " {";
                        writeHashToStreamInternal(phv->hash, stream, indent + 1);
                        newlineAndIndent(stream, indent);
                        stream << "}\n";
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Datahash>
readHashFromStream
(
IN const char * key_name,
IO std::istream& stream
)
{
        perf::Timer timer("readHashFromStream");
        ASSERT(key_name, "null");

        try {
                return readHashFromStreamInternal(stream);
        } catch (std::exception& e) {
                WAVE_EX(wex);
                wex << "Failed to read hash with key name: " << key_name;
                wex << "\n";
                wex << e.what();
        }

        ASSERT(false, "should never get here");
        return NULL;
}



smart_ptr<Datahash>
readHashFromTextFile
(
IN const char * filename
)
{
        perf::Timer timer("readHashFromTextFile");
        ASSERT(filename, "NULL filename");

        // open file
        std::ifstream stream(filename);
        if (!stream.good()) {
                WAVE_EX(wex);
                wex << "Failed to open file for reading: " << filename;
        }

        try {
                return readHashFromStream("(root element)", stream);
        } catch (std::exception& e) {
                WAVE_EX(wex);
                wex << "Failure while reading from file: " << filename;
                wex << "\n";
                wex << e.what();
        }

        ASSERT(false, "should never get here");
        return NULL;
}



smart_ptr<Datahash>
readHashFromString
(
IN const char * val
)
{
        ASSERT(val, "null");

        std::istringstream iss(val);
        return readHashFromStream("root", iss);
}



void
writeHashToStream
(
IN const Datahash * hash,
IO std::ostream& stream
)
{
        perf::Timer timer("writeHashToStream");
        ASSERT(hash, "null");

        writeHashToStreamInternal(hash, stream, 0);
}



void
writeHashToTextFile
(
IN const Datahash * hash,
IN const char * filename,
IN const char * comment_at_top_of_file
)
{
        perf::Timer timer("writeHashToTextFile");
        ASSERT(hash, "NULL hash");
        ASSERT(filename, "NULL filename");
        // ASSERT(comment_at_top_of_file) -- this can be null

        // write to a temporary file
        std::string tmpfile = filename;
        tmpfile += ".data.tmp";

        {
                // open the file
                std::ofstream stream(tmpfile.c_str());
                if (!stream.good()) {
                        WAVE_EX(wex);
                        wex << "Failed to open file for writing: " << tmpfile;
                }

                // write a comment at the top if requested
                if (comment_at_top_of_file) {
                        stream << comment_at_top_of_file << "\n";
                }

                // recursively write the hash
                writeHashToStreamInternal(hash, stream, 0);

                // close with a final newline
                stream << "\n";

                stream.flush();
        }

        // rename
        if (rename(tmpfile.c_str(), filename)) {
                WAVE_EX(wex);
                wex << "Failed to rename from " << tmpfile << " to ";
                wex << filename;
        }
}



void
dumpHash
(
IN const char * title,
IN const Datahash * hash
)
{
        ASSERT(title, "null");
        ASSERT(hash, "null");

        std::ostringstream oss;
        writeHashToStream(hash, oss);

        DPRINTF("HASH DUMP %s:\n%s", title, oss.str().c_str());
}