DummyList.h

Go to the documentation of this file.

/* Copyright (C) 2002 Carsten Griwodz
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, this code may be used in unmodified form
 * provided that this copyright notice and this permission notice appear
 * in supporting documentation.
 *
 * The code may be made subject to the terms of the GNU General Public
 * License, Version 2, and re-distributed under the terms of this license.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after negotiation of conditions with the authors.
 */
#ifndef DUMMY_LIST_H
#define DUMMY_LIST_H

#include <sys/types.h>

#include "MNList.h"
#include "MNTimeval.h"
#include "SHData.h"

namespace SH
{

class DummyLayerSourceSH;

class DummyListBase
{
public:
    struct entry
    {
        u_int32_t sequence_number;
        u_int32_t priority;
        u_int32_t length;
    };

    DummyListBase( ) { }
    virtual ~DummyListBase( ) { }

    virtual void      init( u_int32_t initial_fill,
                                    u_int32_t blocksize,
                                    u_int32_t bandwidth ) = 0;
    virtual u_int32_t runtimeSec( ) = 0;
    virtual void      setSeqno( u_int32_t ) = 0;
    virtual void      setMaxSeqno( u_int32_t ) = 0;
    virtual void      compress_queue( u_int32_t q_len ) = 0;

    virtual void fill( ) = 0;

    virtual u_int32_t get( DataPtr& item ) = 0;
    virtual void      put( DataPtr item ) = 0;

    virtual u_int32_t size() const = 0;

    virtual bool eof() const = 0;

private:
    DummyListBase( const DummyListBase& );
    DummyListBase& operator=( const DummyListBase& );
};

class DummyList : public DummyListBase
{
    struct EntryList
    {
        MNList<entry> _list;
        u_int32_t     _bytelen;

        inline void* first() {
            return _list.first();
        }
        inline void* succ(void* p) {
            return _list.succ(p);
        }
        inline bool  empty() const {
            return _list.empty();
        }
        inline void  push_back( entry& e ) {
            push_back(e);
            _bytelen += e.length;
        }
        inline entry inf(void* p) {
            return _list.inf(p);
        }
        inline const entry& inf(void* p) const {
            return _list.inf(p);
        }
        inline entry pop( ) {
            _bytelen -= _list.peek_front().length;
            return _list.pop();
        }
        inline void del_item(void* p) {
            _bytelen -= _list.inf(p).length;
            _list.del_item(p);
        }
        inline u_int32_t bytelength() const {
            return _bytelen;
        }
        inline u_int32_t length() const {
            return _list.length();
        }
    };

    EntryList l;
    bool      _autofill;        
    Timeval   _start_time;      
    Timeval   _run_time;        
    u_int32_t _seq_no;          
    u_int32_t _max_seq_no;      
    u_int32_t _pri_idx;         
    u_int32_t _pri_len;         
    uchar_t*  _pri;             
    u_int32_t _blocksize;       
    u_int32_t _initial_fill;    
    u_int32_t _q_len;           
    u_int32_t _packets_pulled;  
    u_int32_t _bandwidth;       
public:
    DummyList( bool autofill );
    ~DummyList( );

    void      init( u_int32_t initial_fill,
                    u_int32_t blocksize,
                    u_int32_t bandwidth );
    u_int32_t runtimeSec( );
    void      setPri( const char* pri );
    void      setSeqno( u_int32_t );
    void      setMaxSeqno( u_int32_t );
    void      compress_queue( u_int32_t q_len );

    void fill( );

    u_int32_t get( DataPtr& item );
    void      put( DataPtr item );

    inline u_int32_t getBlocksize() const {
        return _blocksize;
    }

    inline u_int32_t size() const {
        return l.length();
    }

    inline bool eof() const {
       return ( _seq_no >= _max_seq_no );
    }
private:
    bool remove_one_from_queue( u_int32_t pri );

    u_int32_t pull_dummy( u_int32_t& seqno, u_int32_t& pri );

private:
    DummyList( );
    DummyList( const DummyList& );
    DummyList& operator=( const DummyList& );
};


}; // namespace SH

#endif /* DUMMY_LIST_H */

---