// -*- C++ -*-
/*****************************************************************************\
 * Copyright (c) 2004 Mark Aylett <mark@emantic.co.uk>                       *
 *                                                                           *
 * Permission is hereby granted, free of charge, to any person obtaining a   *
 * copy of this software and associated documentation files (the             *
 * "Software"), to deal in the Software without restriction, including       *
 * without limitation the rights to use, copy, modify, merge, publish,       *
 * distribute, sublicense, and/or sell copies of the Software, and to permit *
 * persons to whom the Software is furnished to do so, subject to the        *
 * following conditions:                                                     *
 *                                                                           *
 * The above copyright notice and this permission notice shall be included   *
 * in all copies or substantial portions of the Software.                    *
 *                                                                           *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS   *
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF                *
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN *
 * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,  *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR     *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE *
 * USE OR OTHER DEALINGS IN THE SOFTWARE.                                    *
\*****************************************************************************/

/**
 * \file mar_key_cpp.h
 * \brief TODO
 */

#ifndef INCLUDED_MAR_KEY_CPP
#define INCLUDED_MAR_KEY_CPP

#ifndef INCLUDED_MAR_DEFS_CPP
#include "mar_defs_cpp.h"
#endif // INCLUDED_MAR_DEFS_CPP

#ifndef INCLUDED_MAR_STRING_C
#include "mar_string_c.h"
#endif // INCLUDED_MAR_STRING_C

#ifndef INCLUDED_IOSTREAM
#define INCLUDED_IOSTREAM
#include <iostream>
#endif // INCLUDED_IOSTREAM

#ifndef INCLUDED_CSTRING
#define INCLUDED_CSTRING
#include <cstring>
#endif // INCLUDED_CSTRING

namespace mar {

    class key {
        mar_key_t key_;
    public:
        key()
        {
            clear();
        }
        explicit
        key(const char* k)
        {
            mar_strncpy_(key_, k, sizeof(key_));
        }
        key&
        operator =(const char* k)
        {
            mar_strncpy_(key_, k, sizeof(key_));
            return *this;
        }
        void
        clear()
        {
            key_[0] = '\0';
        }
        bool
        empty() const
        {
            return '\0' != key_[0];
        }
        const char*
        get() const
        {
            return key_;
        }
    };
    inline bool
    operator ==(const key& lhs, const key& rhs)
    {
        return 0 == strcmp(lhs.get(), rhs.get());
    }
    inline bool
    operator ==(const key& lhs, const char* rhs)
    {
        return 0 == strncmp(lhs.get(), rhs, sizeof(mar_key_t));
    }
    inline bool
    operator <(const key& lhs, const key& rhs)
    {
        return 0 > strcmp(lhs.get(), rhs.get());
    }
    inline bool
    operator <(const key& lhs, const char* rhs)
    {
        return 0 > strncmp(lhs.get(), rhs, sizeof(mar_key_t));
    }
    inline bool
    operator !=(const key& lhs, const key& rhs)
    {
        return !(lhs == rhs);
    }
    inline bool
    operator !=(const key& lhs, const char* rhs)
    {
        return !(lhs == rhs);
    }
    inline bool
    operator >(const key& lhs, const key& rhs)
    {
        return rhs < lhs;
    }
    inline bool
    operator >(const key& lhs, const char* rhs)
    {
        return 0 < strncmp(lhs.get(), rhs, sizeof(mar_key_t));
    }
    inline bool
    operator <=(const key& lhs, const key& rhs)
    {
        return !(lhs > rhs);
    }
    inline bool
    operator <=(const key& lhs, const char* rhs)
    {
        return !(lhs > rhs);
    }
    inline bool
    operator >=(const key& lhs, const key& rhs)
    {
        return !(lhs < rhs);
    }
    inline bool
    operator >=(const key& lhs, const char* rhs)
    {
        return !(lhs < rhs);
    }
    inline std::ostream&
    operator <<(std::ostream& os, const key& rhs)
    {
        return os << rhs.get();
    }
}

#endif // INCLUDED_MAR_KEY_CPP