OverlayKey.h

Go to the documentation of this file.

//
// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef __OVERLAYKEY_H_
#define __OVERLAYKEY_H_

#include <gmp.h>
#include <stdint.h>

class BinaryValue;
class OverlayKeyBit;
class cCommBuffer;

inline void omnet_random(mp_limb_t *r1p, mp_size_t r1n);

class OverlayKey
{
public:
    //-------------------------------------------------------------------------
    // constants
    //-------------------------------------------------------------------------

    static const OverlayKey UNSPECIFIED_KEY; 
    static const OverlayKey ZERO; 
    static const OverlayKey ONE; 
    //-------------------------------------------------------------------------
    // construction and destruction
    //-------------------------------------------------------------------------

    OverlayKey();

    OverlayKey( uint32_t num );

    OverlayKey( const unsigned char* buffer, uint32_t size);

    OverlayKey( const std::string& str, uint32_t base = 16 );

    OverlayKey( const OverlayKey& rhs );

    ~OverlayKey();

    //-------------------------------------------------------------------------
    // string representations & node key attributes
    //-------------------------------------------------------------------------



    std::string toString( uint32_t base = 16 ) const;

    friend std::ostream& operator<<(std::ostream& os, const OverlayKey& c);

    bool isUnspecified() const;

    //-------------------------------------------------------------------------
    // operators
    //-------------------------------------------------------------------------

    bool operator< ( const OverlayKey& compKey ) const;

    bool operator> ( const OverlayKey& compKey ) const;

    bool operator<=( const OverlayKey& compKey ) const;

    bool operator>=( const OverlayKey& compKey ) const;

    bool operator==( const OverlayKey& compKey ) const;

    bool operator!=( const OverlayKey& compKey ) const;

    int compareTo( const OverlayKey& compKey ) const;

    OverlayKey& operator= ( const OverlayKey& rhs );

    OverlayKey& operator--();

    OverlayKey& operator++();

    OverlayKey& operator+=( const OverlayKey& rhs );

    OverlayKey& operator-=( const OverlayKey& rhs );

    OverlayKey  operator+ ( const OverlayKey& rhs ) const;

    OverlayKey  operator- ( const OverlayKey& rhs ) const;

    OverlayKey  operator--( int );

    OverlayKey  operator++( int );

    OverlayKey  operator>>( uint32_t num ) const;

    OverlayKey  operator<<( uint32_t num ) const;

    OverlayKey  operator& ( const OverlayKey& rhs ) const;

    OverlayKey  operator| ( const OverlayKey& rhs ) const;

    OverlayKey  operator^ ( const OverlayKey& rhs ) const;

    OverlayKey  operator~ () const;

    OverlayKeyBit operator[]( uint32_t n );

    OverlayKey& setBit(uint32_t pos, bool value);

    //-------------------------------------------------------------------------
    // additional math
    //-------------------------------------------------------------------------

    uint32_t getBitRange(uint32_t p, uint32_t n) const;

    double toDouble() const;

    inline bool getBit(uint32_t p) const
    {
        return getBitRange(p, 1);
    };

    size_t hash() const;

    int log_2() const;

    OverlayKey randomSuffix(uint32_t pos) const;

    OverlayKey randomPrefix(uint32_t pos) const;

    uint32_t sharedPrefixLength(const OverlayKey& compKey,
                                uint32_t bitsPerDigit = 1) const;

    bool isBetween(const OverlayKey& keyA, const OverlayKey& keyB) const;

    bool isBetweenR(const OverlayKey& keyA, const OverlayKey& keyB) const;

    bool isBetweenL(const OverlayKey& keyA, const OverlayKey& keyB) const;

    bool isBetweenLR(const OverlayKey& keyA, const OverlayKey& keyB) const;

    //-------------------------------------------------------------------------
    // static methods
    //-------------------------------------------------------------------------

    static void setKeyLength(uint32_t length);

    static uint32_t getLength();

    static OverlayKey random();

    static OverlayKey getMax();

    static OverlayKey sha1(const BinaryValue& value);

    static OverlayKey pow2(uint32_t exponent);

    static void test();

private:
    // private constants

    static const uint32_t MAX_KEYLENGTH = 160; 
    static uint32_t keyLength; 
    static uint32_t aSize; 
    static mp_limb_t GMP_MSB_MASK; 
    // private fields
    bool isUnspec; 
    mp_limb_t key[MAX_KEYLENGTH / (8*sizeof(mp_limb_t)) +
              (MAX_KEYLENGTH % (8*sizeof(mp_limb_t))!=0 ? 1 : 0)];
    // private "helper" methods
    void trim();

    void clear();

public:

    void netPack(cCommBuffer *b);

    void netUnpack(cCommBuffer *b);
};

class OverlayKeyBit
{
 public:

    OverlayKeyBit(bool value, uint32_t pos, OverlayKey* key)
        : bit(value), pos(pos), key(key)
    {};

    inline operator bool()
    {
        return bit;
    };

    inline OverlayKeyBit& operator=(const OverlayKeyBit& value)
    {
        key->setBit(pos, value.bit);
        return *this;
    };

    inline OverlayKeyBit& operator=(bool value)
    {
        key->setBit(pos, value);
        return *this;
    };

    inline OverlayKeyBit& operator^=(bool value)
    {
        key->setBit(pos, (*key)[pos] ^ value);
        return *this;
    };

 private:

    bool bit;
    uint32_t pos;
    OverlayKey* key;
};


inline void doPacking(cCommBuffer *b, OverlayKey& obj) {obj.netPack(b);}

inline void doUnpacking(cCommBuffer *b, OverlayKey& obj) {obj.netUnpack(b);}

#endif