Statistics.h

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn 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 3 of the License, or
// (at your option) any later version.
//
// pydtn 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 pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#ifndef __WRAPPERS_HARNESS_STATISTICS_H__
#define __WRAPPERS_HARNESS_STATISTICS_H__

#include "config.h"

#include "dtn/Consumer.h"
#include "dtn/ByteString.h"
#include "Sequencer.h"
#include <map>
#include <set>


class Stat
{
   public :
      Stat() : m_n(0), m_s(0), m_w(0) {}
      ~Stat() {}

      unsigned long n() const { return m_n; }
      unsigned long s() const { return m_s; }
      unsigned long w() const { return m_w; }

      double mean() const;
      double var() const;
      double sigma() const;

      void add( unsigned long val );
      void reset();

   private :
      unsigned long m_n;
      unsigned long m_s;
      unsigned long m_w;
};

class UniqueStat
{
   public :
      typedef std::map< DTN::ByteString , Sequencer > BundleMap;

      UniqueStat();
      virtual ~UniqueStat();

      void add( const DTN::Bundle& b );
      void reset();

      const Stat& unique() const { return m_unique; }
      const Stat& duplicate() const { return m_duplicate; }

   private :
      Stat       m_unique;
      Stat       m_duplicate;
      BundleMap  m_seen;
};

class StatCollection
{
   public :
      StatCollection() : m_exhausted(false) {}

      const UniqueStat& originated() const { return m_originated; }
      const Stat& sent() const { return m_sent; }
      const Stat& received() const { return m_received; }
      const UniqueStat& delivered() const { return m_delivered; }
      const Stat& deliverHops() const { return m_deliverHops; }
      const Stat& dropped() const { return m_dropped; }
      const Stat& dropHops() const { return m_dropHops; }
      bool exhausted() const { return m_exhausted; }

      void addOriginated( const DTN::Bundle& b );
      void addSent( unsigned long int val );
      void addReceived( unsigned long int val );
      void addDelivered( const DTN::Bundle& b );
      void addDropped( const DTN::Bundle& b );
      void setExhausted() { m_exhausted = true; }

      void reset();

   private :
      UniqueStat m_originated;
      Stat m_sent;
      Stat m_received;
      UniqueStat m_delivered;
      Stat m_deliverHops;
      Stat m_dropped;
      Stat m_dropHops;
      bool m_exhausted;
};

class Statistics : public DTN::Consumer
{
   public :
      Statistics( DTN::Node* owner );
      virtual ~Statistics();

      virtual void operator()( const DTN::Bundle& b );

      virtual void drop( const DTN::Bundle& b, const DTN::DropCause& c );

      virtual void custody( const DTN::Bundle& b );

      virtual void persistentStore( const DTN::Bundle& b );

      virtual void persistentRemove( const DTN::Bundle& b, bool cleanup=true );

      virtual void send( const DTN::Bundle& b );

      virtual void recv( const DTN::Bundle& b );

      virtual void exhausted( const DTN::Bundle& b );

      const StatCollection& since() const { return m_since; }

      const StatCollection& total() const { return m_total; }

      void reset() { m_since.reset(); }

      void resetTotals() { m_since.reset(); m_total.reset(); }

      virtual unsigned long int used() const;
      virtual unsigned long int capacity() const;

   protected :
      void testOrigin( const DTN::Bundle& b );

      StatCollection  m_total;
      StatCollection  m_since;
};


#endif /* __WRAPPERS_HARNESS_STATISTICS_H__ */

---