SHData.h

Go to the documentation of this file.

#ifndef MN_SH_DATA_H
#define MN_SH_DATA_H

#include "SHRPtr.h"
#include "MNValid.h"

class MNRTPPacket;

namespace SH
{
class SHPlainData;
class SHOrderedData;
class DummyData;
class OrderedDummyData;
 class SHRTPData;

class Data
{
    DECLARE_VALID
private:
    size_t _ref;
    // no memory leak trouble right now with this class
    // static size_t _total_cnt;     ///< look for memory leaks
    // static void inc_total_cnt( );
    // static void dec_total_cnt( );
public:
    Data( )
        : _ref( 0 )
    {
        MAKE_VALID
        // inc_total_cnt();
    }

    virtual ~Data()
    {
        CHECK_VALID
        // dec_total_cnt();
        assert( _ref == 0 );
        MAKE_INVALID
    }

    virtual RPtr<Data> clone() = 0;

    virtual size_t getByteSize( ) const = 0;

    virtual bool isPlainData( ) const = 0;

    virtual bool isOrderedData( ) const = 0;

    virtual bool isRTPData( ) const = 0;

    virtual bool isDummyData( ) const = 0;

    virtual bool isSHRTPData( ) const = 0;

    void ref( )
    {
        CHECK_VALID
        _ref += 1;
    }

    void unref()
    {
        CHECK_VALID
        _ref -= 1;
        if( _ref == 0 )
        {
            delete this;
        }
    }

    inline SHPlainData*      asPlainData( );

    inline SHOrderedData*    asOrderedData( );      
    inline MNRTPPacket*      asRTPData( );          
    inline DummyData*        asDummyData( );        
    inline OrderedDummyData* asOrderedDummyData( ); 
    inline SHRTPData*        asSHRTPData( );        
private:
    Data( const Data& orig );
    Data& operator=( const Data& orig );
};

typedef RPtr<Data> DataPtr;

inline SHPlainData* Data::asPlainData( )
{
    if( isPlainData() ) return (SHPlainData*)this;
    return NULL;
}

inline SHOrderedData* Data::asOrderedData( )
{
    if( isOrderedData() && !isDummyData() ) return (SHOrderedData*)this;
    return NULL;
}

inline MNRTPPacket* Data::asRTPData( )
{
    if( isRTPData() ) return (MNRTPPacket*)this;
    return NULL;
}

inline DummyData* Data::asDummyData( )
{
    if( isDummyData() ) return (DummyData*)this;
    return NULL;
}

inline OrderedDummyData* Data::asOrderedDummyData( )
{
    if( isDummyData() && isOrderedData() ) return (OrderedDummyData*)this;
    return NULL;
}

inline SHRTPData* Data::asSHRTPData( )
{
  if ( isSHRTPData() ) return (SHRTPData*) this;
  return NULL;
}


}; // namespace SH

#endif /* MN_SH_DATA_H */

---