Pong.h

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko 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.

Calitko 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 Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#ifndef PONG_H
#define PONG_H

#include "Packet.h"
#include "Extensions/GgepBlock.h"

// Open containing namespaces:
namespace Gnutella {
namespace Packets {


class Pong : public Packet
{
public:
    static inline Pong &        castFrom (Packet & packet);
    static inline const Pong &  castFrom (const Packet & packet);

                                Pong (const QByteArray &rawHeader, const QByteArray &rawPayload);
                                Pong (quint16 port = 0, const QHostAddress &ipAddress = QHostAddress::Null, quint32 sharedFiles = 0, quint32 sharedKilobytes = 0);
    inline                      Pong (const Pong &other);
    Pong &                      operator= (const Pong &other);
                                ~Pong();

    inline Pong*                copy() const;

    QString                     name() const { return QString ("Pong"); }

    inline quint16              port() const;                                       
    inline QHostAddress         ipAddress() const;                                  
    inline quint32              sharedFiles() const;                                
    inline quint32              sharedKilobytes() const;                            
    inline const Extensions::GgepBlock  &   ggepBlock() const;                                  

    inline void                 setPort (quint16 port);                             
    inline void                 setIpAddress (const QHostAddress &address);         
    inline void                 setSharedFiles (quint32 files);                     
    inline void                 setSharedKilobytes (quint32 kilobytes);             
    inline void                 setGgepBlock (const Extensions::GgepBlock &block);  

protected:

    void                        invalidatePayload();

    bool                        prepareReadPayload (const QByteArray &rawPayload);
    void                        readPayload (QDataStream &stream);
    int                         prepareWritePayload() const;
    void                        writePayload (QDataStream &stream) const;

private:

    struct Data
    {
        QBasicAtomic            ref;                

        quint16                 port;               
        QHostAddress            ipAddress;          
        quint32                 sharedFiles;        
        quint32                 sharedKilobytes;    
        Extensions::GgepBlock   ggepBlock;          
    };

    Data                        *d;                 
};

// inline functions

inline Pong & Pong::castFrom (Packet & packet)
{ return dynamic_cast <Pong &> (packet); }

inline const Pong & Pong::castFrom (const Packet & packet)
{ return dynamic_cast <const Pong &> (packet); }

inline Pong::Pong (const Pong &other)
: Packet (other), d (other.d)
{ d->ref.ref(); }

inline Pong* Pong::copy() const
{ return new Pong (*this); }

inline quint16 Pong::port() const
{ return d->port; }

inline QHostAddress Pong::ipAddress() const
{ return d->ipAddress; }

inline quint32 Pong::sharedFiles() const
{ return d->sharedFiles; }

inline quint32 Pong::sharedKilobytes() const
{ return d->sharedKilobytes; }

inline const Extensions::GgepBlock & Pong::ggepBlock() const
{ return d->ggepBlock; }

inline void Pong::setPort (quint16 port)
{ invalidatePayload(); d->port = port; }

inline void Pong::setIpAddress (const QHostAddress &address)
{ invalidatePayload(); d->ipAddress = address; }

inline void Pong::setSharedFiles (quint32 files)
{ invalidatePayload(); d->sharedFiles = files; }

inline void Pong::setSharedKilobytes (quint32 kilobytes)
{ invalidatePayload(); d->sharedKilobytes = kilobytes; }

inline void Pong::setGgepBlock (const Extensions::GgepBlock &block)
{ invalidatePayload(); d->ggepBlock = block; }

// Close containing namespaces:
} // namespace Packets
} // namespace Gnutella

#endif // PONG_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.