QHostAddress.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                             IP address container                              *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003 by Niall Douglas.   All Rights Reserved.            *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code 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.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/


#ifndef QHOSTADDRESS_H
#define QHOSTADDRESS_H

#include "FXMaths.h"
#include "qdictbase.h"

namespace FX {

class FXString;

#define QHOSTADDRESS_LOCALHOST QHostAddress(0x7f000001)

struct QHostAddressPrivate;
class FXAPIR QHostAddress
{
    QHostAddressPrivate *p;
public:
    QHostAddress();
    QHostAddress(FXuint ip4addr);
    QHostAddress(const Maths::Vector<FXuchar, 16> &ip6addr);
    QHostAddress(const FXuchar *ip6addr);
    QHostAddress(const QHostAddress &o);
    QHostAddress &operator=(const QHostAddress &o);
    ~QHostAddress();
    bool operator!() const { return isNull(); }
    bool operator==(const QHostAddress &o) const;
    bool operator!=(const QHostAddress &o) const { return !(*this==o); }
    bool operator<(const QHostAddress &o) const;
    bool operator>(const QHostAddress &o) const;
    bool operator<=(const QHostAddress &o) const { return !(*this>o); }
    bool operator>=(const QHostAddress &o) const { return !(*this<o); }
    QHostAddress operator&(const QHostAddress &o) const;
    QHostAddress operator|(const QHostAddress &o) const;
    QHostAddress operator^(const QHostAddress &o) const;

    void setAddress(FXuint ip4addr);
    void setAddress(const Maths::Vector<FXuchar, 16> &ip6addr);
    void setAddress(const FXuchar *ip6addr);
    bool setAddress(const FXString &addr);
    bool isNull() const;
    bool isIp4Addr() const;
    FXuint ip4Addr() const;
    bool isIp6Addr() const;
    const Maths::Vector<FXuchar, 16> &ip6Addr() const;
    const FXuchar *ip6AddrData() const;
    FXString toString() const;
    bool isLocalMachine() const;

    friend FXAPIR FXStream &operator<<(FXStream &s, const QHostAddress &i);
    friend FXAPIR FXStream &operator>>(FXStream &s, QHostAddress &i);
};

template<class type> class QHostAddressDict : public QDictBase<QHostAddress, type>
{
    typedef QDictBase<QHostAddress, type> Base;
    FXuint hash(const QHostAddress &a) const
    {
        if(a.isIp4Addr()) return a.ip4Addr();
        const FXuchar *txt=a.ip6AddrData();
        const FXuchar *end=txt+16;
        FXuint h=0;
        for(; end>=txt; end--)
            h=(h & 0xffffff80)^(h<<8)^(*end);
        return h;
    }
public:
    enum { HasSlowKeyCompare=true };
    explicit QHostAddressDict(int size=13, bool wantAutoDel=false)
        : Base(size, wantAutoDel)
    {
    }
    QHostAddressDict(const QHostAddressDict<type> &o) : Base(o) { }
    ~QHostAddressDict() { Base::clear(); }
    FXADDMOVEBASECLASS(QHostAddressDict, Base)
    void insert(const QHostAddress &k, const type *d)
    {
        Base::insert(hash(k), k, const_cast<type *>(d));
    }
    void replace(const QHostAddress &k, const type *d)
    {
        Base::replace(hash(k), k, const_cast<type *>(d));
    }
    bool remove(const QHostAddress &k)
    {
        return Base::remove(hash(k), k);
    }
    type *take(const QHostAddress &k)
    {
        return Base::take(hash(k), k);
    }
    type *find(const QHostAddress &k) const
    {
        return Base::find(hash(k), k);
    }
    type *operator[](const QHostAddress &k) const { return find(k); }
protected:
    virtual void deleteItem(type *d);
};

template<class type> inline void QHostAddressDict<type>::deleteItem(type *d)
{
    if(Base::autoDelete())
    {
        //fxmessage("QDB delete %p\n", d);
        delete d;
    }
}
// Don't delete void *
template<> inline void QHostAddressDict<void>::deleteItem(void *)
{
}

template<class type> class QHostAddressDictIterator : public QDictBaseIterator<QHostAddress, type>
{
public:
    QHostAddressDictIterator() { }
    QHostAddressDictIterator(const QHostAddressDict<type> &d) : QDictBaseIterator<QHostAddress, type>(d) { }
};

template<class type> FXStream &operator<<(FXStream &s, const QHostAddressDict<type> &i)
{
    FXuint mysize=i.count();
    s << mysize;
    for(QHostAddressDictIterator<type> it(i); it.current(); ++it)
    {
        s << it.currentKey();
        s << *it.current();
    }
    return s;
}
template<class type> FXStream &operator>>(FXStream &s, QHostAddressDict<type> &i)
{
    FXuint mysize;
    s >> mysize;
    i.clear();
    QHostAddress key;
    for(FXuint n=0; n<mysize; n++)
    {
        type *item;
        FXERRHM(item=new type);
        s >> key;
        s >> *item;
        i.insert(key, item);
    }
    return s;
}

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.