Trace Class Reference
[Network Data Structures]

Aggregate containing a packet trace. More...

#include <Aggregate.h>

Inheritance diagram for Trace:

List of all members.

Public Types
typedef TraceIterator &	const_iterator
Public Member Functions
	Trace (uint32_t maxLen)
	Trace (const Trace &toCopy)
	Trace (const StreamKey &key)
virtual Trace *	clone (void) const
const TraceIterator &	begin (void) const
const TraceIterator &	end (void) const
void	setMaxLength (uint32_t maxLength)
virtual const TraceIterator &	addPacket (Packet *pkt)
virtual int	getPacketCount (void) const
uint32_t	getMaxLength (void)
Packet &	getPacket (int index) throw ( IndexOutOfBoundsException )
Trace *	subset (const PacketFilter &filter)
const Attribute &	getAttrib (const std::string &ident) const throw ( UnknownAttributeException )
	Return a reference to the requested attribute, or throw an exception if the attribute doesn't exist for this aggregate.
const StreamKey &	getStreamKey (void) const
virtual void	addAttrib (const std::string &ident, const Attribute &attrib, uint32_t tier=0)
	Add an attribute to the aggregate.
void	addListener (PacketListener &listener)
void	setParent (Aggregate &p)
void	setStreamKey (const StreamKey &stream)
virtual void	handlePacket (TraceIterator &newPkt)
void	copyFrom (const Aggregate &toCopy)
void	clear (void)
Protected Member Functions
virtual Trace &	operator= (const Trace &rhs)
void	callListeners (TraceIterator &newPkt)
Protected Attributes
std::vector< Packet * >	trace
uint32_t	maxLength
TraceIterator	beginning
TraceIterator	ending
std::map< std::string, Attribute * >	attributes
std::vector< std::vector< Attribute * > >	tiers
std::map< std::string, Aggregate * >	aggregates
std::vector< PacketListener * >	listeners
StreamKey *	streamKey
Aggregate *	parent
Static Protected Attributes
static const PacketCountAttribute	countAttrib

---

Detailed Description

Aggregate containing a packet trace.

Note:

Any references to packets obtained from a Trace should not be expected to persist. Eventually, Trace should be able to swap out its packets to disk transparently, so if you need to use data from the Trace, either grab a TraceIterator (which accesses the packet safely) or copy the data.

Examples:

profile_streams_thesis.cc, and test_harness.cc.

---

Member Function Documentation

void Aggregate::addAttrib (  const std::string &  ident, const Attribute &  attrib, uint32_t  tier = 0 )  [virtual, inherited]

Add an attribute to the aggregate. Parameters: [in]  attrib  is a pointer to an attribute to be added; the attribute includes a specification of how the attribute is to be computed. The attribute will be cloned before being added to the aggregate. Examples: profile_streams_thesis.cc, and test_harness.cc.

void Aggregate::addListener (  PacketListener &  listener  )  [inherited]

Add a PacketListener for the aggregate Parameters: listener  PacketListener wishing to be notified of new packets Note: Will not take responsibility for the listener; its memory will still have to be cleaned up. Note that this is NOT an issue for Attributes, as the attributes of an aggregate are cleaned up independently of its listeners. Examples: profile_streams_thesis.cc, and test_harness.cc.

const TraceIterator & Trace::addPacket (  Packet *  pkt  )  [virtual]

add a packet to the underlying trace Returns: TraceIterator pointing to the packet Note: When addPacket is called, the Trace takes responsibility for the Packet given to it, including for deallocating the memory when the Trace is destroyed. Also, the Trace will register the context with the Packet.

void Aggregate::callListeners (  TraceIterator &  newPkt  )  [protected, inherited]

Notify any listeners that a packet has been added to the Aggregate. Note: Any Aggregate subclasses have to invoke this method when a new packet is added; for now, it's too difficult to do a template method trick.

const Attribute & Aggregate::getAttrib (  const std::string &  ident  )  const throw ( UnknownAttributeException ) [inherited]

Return a reference to the requested attribute, or throw an exception if the attribute doesn't exist for this aggregate. Parameters: ident  string identifying the Attribute requested, will correspond, in the usual case, to the string used to add the attribute with addAttrib (q.v.). ident could also be of a compound form comprised of zero or more subaggregates followed by an attribute followed by zero or more subattributes, all dot-seperated. e.g. "forward.count" to get the value of the PacketCount attribute 'count' of the subaggregate 'forward', or "count.forward" to get the forward subattribute of the PacketCount attribute 'count', or "port80.count.forward" to get the 'forward' subattribute of the 'count' attribute of the 'port80' subaggregate. Exceptions: UnknownAttributeException  thrown if no Attribute of the requested name has been added to the Aggregate. Examples: profile_streams_thesis.cc, and test_harness.cc.

uint32_t Trace::getMaxLength (  void   )  [inline]

return the size of the sliding window, or UINT32_T_MAX if unlimited

virtual int Trace::getPacketCount (  void   )  const [inline, virtual]

get the number of packets in the underlying trace - including any that have been dropped off the end of the rolling window, if applicable Reimplemented from Aggregate.

void Aggregate::handlePacket (  TraceIterator &  newPkt  )  [virtual, inherited]

handler for a new packet Implements PacketListener.

Trace & Trace::operator= (  const Trace &  rhs  )  [protected, virtual]

not implemented; provided to avoid implicit definitions and for later implementation

void Trace::setMaxLength (  uint32_t  maxLength  )

Specify that the trace is only to hold a certain number of packets Parameters: maxLength  Maximum length, or UINT32_T_MAX for no limit

Trace * Trace::subset (  const PacketFilter &  filter  )

get a subset of the Aggregate matching the given filter Returns: a pointer to a new aggregate (allocated by new; caller is responsible for deleting it)

---

Member Data Documentation

std::map<std::string, Aggregate*> Aggregate::aggregates [protected, inherited]

sub-aggregates

std::map<std::string, Attribute*> Aggregate::attributes [protected, inherited]

attributes

const PacketCountAttribute Aggregate::countAttrib [static, protected, inherited]

prototype packet count attribute - a clone will be added by individual aggregates

std::vector<PacketListener*> Aggregate::listeners [protected, inherited]

ProtocolParsers listening for new packets

Aggregate* Aggregate::parent [protected, inherited]

Aggregate containing this one, if any

StreamKey* Aggregate::streamKey [protected, inherited]

Key indicating to which stream this Trace belongs, if applicable

std::vector< std::vector<Attribute*> > Aggregate::tiers [protected, inherited]

tiers for prioritizing attributes Todo: reimplement this to use a vector of pairs and the STL sort algorithm

---

The documentation for this class was generated from the following files:

• data_structures/Aggregate.h
• data_structures/Aggregate.cc

---