Ggep.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 GGEP_H
#define GGEP_H

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


class Ggep
{
public:
    enum HeaderFlag
    {
        LastExtension   = 0x80,
        Encoding        = 0x40,
        Compression     = 0x20,
        Reserved        = 0x10,
        IDLength        = 0x0f
    };

    Q_DECLARE_FLAGS(HeaderFlags, HeaderFlag)

    

    typedef QByteArray GgepId;

    static Ggep *           fromId (const GgepId &id, int flags, int dataSize);
    virtual                 ~Ggep();
    virtual Ggep *          copy() const = 0;

    void                    prepareRead (const QByteArray &rawData);
    void                    read (QDataStream &stream);
    int                     prepareWrite() const;
    void                    write (QDataStream &stream) const;

    // \todo GgepBlock may set the LastExtensionFlag too often and degrade the use of shared data.
    inline bool             isFlagSet (HeaderFlag flag) const;
    inline void             setFlag (HeaderFlag flag);
    inline void             resetFlag (HeaderFlag flag);

    GgepId                  id() const;

protected:
                            Ggep (const GgepId &id, int flags = 0, int dataSize = 0);
    inline                  Ggep (const Ggep &other);
    Ggep &                  operator= (const Ggep &other);

    inline int              dataLength() const;

    virtual bool            prepareReadData (const QByteArray &rawData) = 0;    
    virtual void            readData (QDataStream &stream) = 0;                 
    virtual int             prepareWriteData() const = 0;                       
    virtual void            writeData (QDataStream &stream) const = 0;          

private:
    void                    invalidateData();

    struct Data
    {
        QBasicAtomic            ref;

        bool                    isValid;
        HeaderFlags             flags;
        GgepId                  id;
    };

    // \todo How good is this separation of shared and private data?
    // Doesn't keeping the private data reduce the gain of the shared?
    // dataLength may change eventually on write, if the data in the
    // derived class has changed. Separate encodedData is needed only
    // in multithread environment. The class Packet has a payloadLength()
    // function that calls rawPayload() to force rebuilding the payload
    // and get the actual length. The generated bytes are cached. This
    // is not the case here in the extensions. We do not need to double
    // cache the same extension data. We just want to make it cheap to
    // copy Ggeps when passing them on into a GGEP block.
    struct Private // Put these fields in the shared data as well?What about reentrancy and thread safety.
    {
        mutable int                 dataLength;     
        mutable QByteArray          encodedData;    
    };

    Data                        *d;                 // Shared object data with reference counting.
    Private                     p;                  // Private object data.
};

Q_DECLARE_OPERATORS_FOR_FLAGS(Ggep::HeaderFlags)


// inline functions

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

inline bool Ggep::isFlagSet (HeaderFlag flag) const
{ return d->flags & flag; }

inline void Ggep::setFlag (HeaderFlag flag)
{ invalidateData(); d->flags |= flag; }

inline void Ggep::resetFlag (HeaderFlag flag)
{ invalidateData(); d->flags &= ~flag; }

inline Ggep::GgepId Ggep::id() const
{ return d->id; }

inline int Ggep::dataLength() const
{ return p.dataLength; }

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

#endif // _GGEP_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.