datahash_util.cpp

Go to the documentation of this file.

/*
 * datahash_util.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.
 *
 *
 * Implementation of the datahash utilities.
 */

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

#include "util/date.h"          // date utilities
#include "util/parsing.h"       // parsing utilities

#include "common/wave_ex.h"


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

static const hash_value_t *
getSingleValue
(
IN const Datahash * h,
IN const char * key,
IN eDatahash_Flag flag,
IN eHashDataType type
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");
        ASSERT(eHashDataType_Invalid != type, "Bad type");

        int nValues = h->count(key);
        if (!nValues && (eDatahash_Optional & flag))
                return NULL;    // not found
        ASSERT_THROW(1 == nValues,
            "Expected exactly 1 value for key='" << key << "', found " <<
            nValues << " instead");

        Datahash::iterator_t i;
        h->getIterator(key, i);
        const hash_value_t * phv = h->getNextElementUnsafe(i);
        ASSERT_THROW(phv, "No value found for key='" << key << "'");
        ASSERT_THROW(type == phv->type,
            "value at key='" << key << "' is not the proper type "
            << "(string vs hash)");
        return phv;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Datahash Utilities -- Public API
//
////////////////////////////////////////////////////////////////////////////////

const char *
getString
(
IN const Datahash * h,
IN const char * key,
IN eDatahash_Flag flag
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");

        const hash_value_t * phv =
            getSingleValue(h, key, flag, eHashDataType_String);
        if (!phv) {
                return NULL;    // not there (only returns null if optional)
        }
        return phv->text.c_str();
}



const char *
getOptionalString
(
IN const Datahash * h,
IN const char * key,
IN const char * default_value
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");
        // ASSERT(default) -- we don't care!

        const char * val = getString(h, key, eDatahash_Optional);
        return val ? val : default_value;
}



long
getLong
(
IN const Datahash * h,
IN const char * key
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");

        return atol(getString(h, key));
}



long
getOptionalLong
(
IN const Datahash * h,
IN const char * key,
IN long default_value
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");

        const char * val = getString(h, key, eDatahash_Optional);
        if (!val)
                return default_value;
        return atol(val);
}



double
getDouble
(
IN const Datahash * h,
IN const char * key
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");

        return atof(getString(h, key));
}



bool
getBooleanValueFromString
(
IN const char * v
)
{
        ASSERT(v, "null");

        if (!strcasecmp(v, "true") ||
                !strcasecmp(v, "t") ||
                !strcasecmp(v, "1") ||
                !strcasecmp(v, "yes")) {
                // true or 1 or yes == true
                return true;
        }
        if (!strcasecmp(v, "false") ||
                !strcasecmp(v, "f") ||
                !strcasecmp(v, "0") ||
                !strcasecmp(v, "no")) {
                return false;
        }

        // if we got here, we can't figure it out.  Throw
        {
                WAVE_EX(wex);
                wex << "Cannot determine true or false from value: " << v;
        }

        return false;
}



bool
getBoolean
(
IN const Datahash * h,
IN const char * key
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");

        return getBooleanValueFromString(getString(h, key));
}



smart_ptr<Datahash>
getSubhash
(
IN const Datahash * h,
IN const char * key,
IN eDatahash_Flag flag
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");

        const hash_value_t * phv =
            getSingleValue(h, key, flag, eHashDataType_Hash);
        if (!phv) {
                return NULL;    // not there (only returns NULL if optional)
        }
        return phv->hash;
}



void
setTimestampAsDateString
(
IN Datahash * h,
IN const char * key_name,
IN long timestamp
)
{
        ASSERT(h, "null");
        ASSERT(key_name, "null");

        std::string display;
        getDateStringFromNetTime(timestamp, display);

        setValue(h, key_name, display);
}



long
getTimestampFromDateString
(
IN const Datahash * h,
IN const char * key
)
{
        ASSERT(h, "null");
        ASSERT(key, "null");

        std::string display = getString(h, key);
        return getNetTimeFromDateString(display.c_str());
}



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

        smart_ptr<Datahash> hash = new Datahash;
        ASSERT(hash, "Failed to create empty datahash");

        // we assume the string is a whitespace-separated list of
        //  tokens, each token of the form <key>:<value>

        eParseBehavior behavior = (eParseBehavior)
            (eParse_RespectQuotes);

        while (*s) {
                std::string token;
                s = getNextTokenFromString(s, token, behavior);
                if ("" == token) {
                        break;
                }

                int i = token.find(':', 0);
                if ((int) std::string::npos == i) {
                        // no colon in this token?
                        DPRINTF("Warning: malformed token: '%s'",
                            token.c_str());
                        continue;
                }

                std::string key = token.substr(0, i);
                std::string value = token.substr(i + 1);

//              DPRINTF("'%s' ==> '%s' = '%s'",
//                  token.c_str(), key.c_str(), value.c_str());

                hash->insert(key, value);
        }

        return hash;
}



void
getStringValues
(
IN const Datahash * hash,
IN const char * key,
OUT VecString& vec
)
{
        ASSERT(hash, "null");
        ASSERT(key, "null");
        vec.clear();

        Datahash::iterator_t i;
        hash->getIterator(key, i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                if (eHashDataType_String != phv->type)
                        continue;

                vec.push_back(phv->text);
        }
}