datahash.cpp

Go to the documentation of this file.

/*
 * datahash.cpp
 *
 * Copyright (C) 2003, 2008, 2010 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 recursive data hash.
 */

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

#include "common/wave_ex.h"
#include "util/parsing.h"


static const int s_maxHashKeyLength             = 32;


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

static bool
isValidHashKeyCharacter
(
IN char a,
IN bool isFirstCharacter
)
throw()
{
        // must be single byte character!
        if (!isSingleByteUTF8Character(a))
                return false;

        // any alphabetic character a-zA-Z is fine
        if (a >= 'a' && a <= 'z')
                return true;
        if (a >= 'A' && a <= 'Z')
                return true;

        // first character must be alphabetic
        if (isFirstCharacter)
                return false;

        // later characters can also be numeric
        if (a >= '0' && a <= '9')
                return true;

        // not alphanumeric!
        return false;
}



////////////////////////////////////////////////////////////////////////////////
//
//      hash_value_t methods
//
////////////////////////////////////////////////////////////////////////////////

hash_value_t::hash_value_t
(
IN const char * txt
)
{
        // ASSERT(txt) -- we don't care
        type = eHashDataType_String;
        text = (txt) ? txt : "";
}



hash_value_t::hash_value_t
(
IN const std::string& s
)
{
        type = eHashDataType_String;
        text = s;
}



hash_value_t::hash_value_t
(
IN smart_ptr<Datahash>& h
)
{
        // ASSERT(h) -- we don't care
        type = eHashDataType_Hash;
        hash = h;
}



void
hash_value_t::clear
(
void
)
throw()
{
        type = eHashDataType_Invalid;
        text.clear();
        hash = NULL;
}



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

bool
isValidHashKeyName
(
IN const char * key_name
)
throw()
{
        ASSERT(key_name, "null");

        // Why so restrictive?  Mainly because it is best to ensure that
        //   key names can easily be put into URLs, etc. without encoding.
        //   Also, keys could potentially be used to generate code (variables
        //   that have the same name).
        // This imposes a lot of restrictions on the key names but being
        //   very restrictive at first and perhaps relaxing the restrictions
        //   later is much better (more feasible) than the reverse.

        // Why enforce length?  Partly to catch garbage, but mainly because
        //   very long names are probably an indication that someone is
        //   encoding structure into the key names instead of using the hash.

        const char * p = key_name;
        for (; *p; ++p) {
                if (!isValidHashKeyCharacter(*p, p == key_name))
                        return false;

                // too long?
                if (p - key_name > s_maxHashKeyLength) {
                        return false;
                }
        }

        return true;
}



void
validateHashKeyName
(
IN const char * key_name
)
{
        ASSERT(key_name, "null");
        if (!isValidHashKeyName(key_name)) {
                WAVE_EX(wex);
                wex << "Invalid data hash key name: '" << key_name << "'\n";
                wex << "Only ASCII alphanumeric characters are allowed.\n";
                wex << "The first character must be alphabetic.\n";
                wex << "The full key must be less than ";
                wex << s_maxHashKeyLength << " characters in length.";
        }
}