Bundle.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 __DTN_BUNDLE_H__
#define __DTN_BUNDLE_H__

#include "config.h"
#include "ByteString.h"
#include <sys/time.h>

namespace DTN
{

struct timeval dtn_time();
   
class Bundle
{
   public :
      typedef unsigned char  BundleType;

      enum
      {
         kData      = 1 << 0, 
         kACK       = 1 << 1, 
         kNoACK     = 1 << 2, 
         kCustodial = 1 << 3, 
         kBcast     = 1 << 4, 
      };

      Bundle( uint32_t seq,
              const ByteString& src,
              const struct timeval& creat,
              const struct timeval& expir,
              BundleType t = kData,
              const ByteString& app = ByteString() );

      Bundle( const Bundle& aOther );

      Bundle( uint32_t seq,
              const ByteString& src,
              const ByteString& dest,
              const struct timeval& creat,
              const struct timeval& expir,
              BundleType t = kData,
              const ByteString& app = ByteString() );

      Bundle( uint32_t seq,
              const ByteString& src,
              const ByteString& dest,
              const ByteString& data,
              const struct timeval& creat,
              const struct timeval& expir,
              BundleType t = kData,
              const ByteString& app = ByteString() );

      virtual ~Bundle();

      virtual Bundle* clone() const;

      virtual unsigned int size() const { return
                                             4 + // seqNum
                                             m_source.length() +
                                             m_destination.length() +
                                             m_custodian.length() +
                                             m_send.length() +
                                             m_recv.length() +
                                             m_payload.length() +
                                             8 + // created
                                             8 + // TTL
                                             1 + // type
                                             m_app.length() +
                                             4; } // hop count

      uint32_t seqNum()              const { return m_seqNum; }
      const ByteString& source()      const { return m_source; }
      const ByteString& destination() const { return m_destination; }
      const ByteString& custodian()   const { return m_custodian; }
      const ByteString& send()        const { return m_send; }
      const ByteString& recv()        const { return m_recv; }
      const ByteString& payload()     const { return m_payload; }
      const struct timeval& created() const { return m_created; }
      const struct timeval& expiry()  const { return m_expiry; }
      BundleType type()               const { return m_type; }
      const ByteString& app()         const { return m_app; }
      uint32_t hopCount()            const { return m_hopCount; }

      ByteString& destination() { return m_destination; }
      ByteString& custodian()   { return m_custodian; }
      ByteString& send()        { return m_send; }
      ByteString& recv()        { return m_recv; }
      ByteString& payload()     { return m_payload; }
      struct timeval& created() { return m_created;}
      struct timeval& expiry() { return m_expiry;}
      BundleType& type()        { return m_type; }

      virtual bool expired() const;

      void incrHop() { ++m_hopCount; }

   private :
      Bundle();

      uint32_t       m_seqNum; 
      ByteString      m_source; 
      ByteString      m_destination; 
      ByteString      m_custodian; 
      ByteString      m_send; 
      ByteString      m_recv; 
      ByteString      m_payload; 
      struct timeval  m_created; 
      struct timeval  m_expiry; 
      BundleType      m_type; 
      ByteString      m_app; 
      uint32_t       m_hopCount; 
};

}; // DTN

#endif /* __DTN_BUNDLE_H__ */

---