MNLCRTPRangeList.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MNLCRTPRANGELIST_H
#define MNLCRTPRANGELIST_H

/* 
LCRTPRangeList enthaelt die funktionalitaet der Range Liste
Es werden Bytecount bereiche gespeichert und ggf gemerged.
LCRTPLossList und ... benutzen diese Klasse
*/

#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include "mnstream.h"
#include "var_type.h"
#include "MNMsg.h" 
#include "MNList.h"

struct LossRange_t;

class LossRange_tList
    : private MNList<LossRange_t*>
{
public:
    void* first() {
        return MNList<LossRange_t*>::first();
    }

    void next( void*& pix ) {
        pix = MNList<LossRange_t*>::succ(pix);
    }

    void prev( void*& pix ) {
        pix = MNList<LossRange_t*>::pred(pix);
    }

    LossRange_t* operator()( void* pix ) {
        return MNList<LossRange_t*>::inf(pix);
    }

    void append( LossRange_t* p ) {
        MNList<LossRange_t*>::push_back ( p );
    }

    void clear() {
        MNList<LossRange_t*>::clear();
    }

    void del( void* pix ) {
        MNList<LossRange_t*>::del_item(pix);
    }

    void ins_after( void* pix, LossRange_t *n ) {
        MNList<LossRange_t*>::ins_after(pix,n);
    }

    void ins_before( void* pix, LossRange_t *n ) {
        MNList<LossRange_t*>::ins_before(pix,n);
    }
};

/**************************************************************
 * Klasse: MNLCRTPRangeList
 * Beschreibung: enthaelt die funktionalitaet der Rangeliste
 * September 99
 **************************************************************/
struct LossRange_t
{
  u_int64   range_begin;         /* begin of a bytecount range */
  u_int64   range_end;           /* end of a bytecount range */
  u_int32   counter;             /* counter, needed for the scheduler in the send_loss_list */
};

class MNLCRTPRangeList
{
private:
  /* vars */
  LossRange_tList data;
  typedef void* Pix;

  /* flags */
  bool         merge;               /* if true, adjacent ranges are merged together, works only if range_in_order is true */
  bool         range_in_order;      /* if true, - the ranges are kept in increasing order (begin < end)
                                                - range borders are kept, so overlapping ranges can exists in the list, if they are not merged 
                                       if false,- data is only appended */
 
  /* functions */
  void         clr();
  bool         overlapps(Pix elem, u_int64 begin_r, u_int64 end_r);
  Pix          get_place(u_int64 begin_r, u_int64 end_r);

public:
  MNLCRTPRangeList();
  ~MNLCRTPRangeList();

   /* create */
  void         insert_data(u_int64 begin_r, u_int64 end_r);
  void         insert_data_or_increment_counter(u_int64 begin_r, u_int64 end_r);

  /* destroy */
  void         delete_all();
  void         delete_range(u_int64 begin_r, u_int64 end_r);

  /* control */
  void         disable_merge();
  void         enable_merge();
  void         disable_in_order();
  void         enable_in_order();
  bool         range_exists(u_int64 begin_r);            /* true, if a range exists, where begin_R fits in */
  LossRange_t* get_first_data();
  LossRange_t* get_next_data(u_int64 begin_r);           /* return only an entry, if the range begins exactly on begin_r */
  LossRange_t* get_next_in_range_data(u_int64 begin_r);  /* return an entry, if a range exists, where begin_r is in it */
  int          get_counter(u_int64 begin_r);
  LossRange_t* get_worst_counter_data();
};

#endif

---