ostinato/common/streambase.cpp

#include "streambase.h"
#include "abstractprotocol.h"
#include "protocollist.h"
#include "protocollistiterator.h"
#include "protocolmanager.h"

extern ProtocolManager OstProtocolManager;

StreamBase::StreamBase() :
	mStreamId(new OstProto::StreamId),
	mCore(new OstProto::StreamCore),
	mControl(new OstProto::StreamControl)
{
	AbstractProtocol *proto;
	ProtocolListIterator *iter;

	mStreamId->set_id(0xFFFFFFFF);

	currentFrameProtocols = new ProtocolList;

	iter = createProtocolListIterator();
	// By default newly created streams have the mac and payload protocols
	proto = OstProtocolManager.createProtocol(
			OstProto::Protocol::kMacFieldNumber, this);
	iter->insert(proto);
	qDebug("stream: mac = %p", proto);

	proto = OstProtocolManager.createProtocol(
			OstProto::Protocol::kPayloadFieldNumber, this);
	iter->insert(proto);
	qDebug("stream: payload = %p", proto);

	{
		iter->toFront();
		while (iter->hasNext())
		{
			qDebug("{{%p}}", iter->next());
		//	qDebug("{{%p}: %d}", iter->peekNext(), iter->next()->protocolNumber());
		}
		iter->toFront();
		while (iter->hasNext())
		{
			qDebug("{[%d]}", iter->next()->protocolNumber());
		//	qDebug("{{%p}: %d}", iter->peekNext(), iter->next()->protocolNumber());
		}
	}

	delete iter;
}

StreamBase::~StreamBase()
{
	delete mStreamId;
	delete mCore;
	delete mControl;
}

void StreamBase::protoDataCopyFrom(const OstProto::Stream &stream)
{
	AbstractProtocol		*proto;
	ProtocolListIterator	*iter;

	mStreamId->CopyFrom(stream.stream_id());
	mCore->CopyFrom(stream.core());
	mControl->CopyFrom(stream.control());

	currentFrameProtocols->destroy();
	iter = createProtocolListIterator();
	for (int i=0; i < stream.protocol_size(); i++)
	{
		proto = OstProtocolManager.createProtocol(
			stream.protocol(i).protocol_id().id(), this);
		proto->protoDataCopyFrom(stream.protocol(i));
		iter->insert(proto);
	}

	delete iter;
}

void StreamBase::protoDataCopyInto(OstProto::Stream &stream) const
{
	stream.mutable_stream_id()->CopyFrom(*mStreamId);
	stream.mutable_core()->CopyFrom(*mCore);
	stream.mutable_control()->CopyFrom(*mControl);

	stream.clear_protocol();
	foreach (const AbstractProtocol* proto, *currentFrameProtocols)
	{
		OstProto::Protocol *p;

		p = stream.add_protocol();
		proto->protoDataCopyInto(*p);
	}
}

#if 0
ProtocolList StreamBase::frameProtocol()
{
	return currentFrameProtocols;
}

void StreamBase::setFrameProtocol(ProtocolList protocolList)
{
	//currentFrameProtocols.destroy();
	currentFrameProtocols = protocolList;
}
#endif

ProtocolListIterator*  StreamBase::createProtocolListIterator() const
{
	return new ProtocolListIterator(*currentFrameProtocols);
}

bool StreamBase::operator < (const StreamBase &s) const
{
	return(mCore->ordinal() < s.mCore->ordinal());
}

quint32	StreamBase::id()
{
	return mStreamId->id();
}

bool StreamBase::setId(quint32 id)
{
	mStreamId->set_id(id);
	return true;
}

quint32	StreamBase::ordinal()
{
	return mCore->ordinal();
}

bool StreamBase::setOrdinal(quint32	ordinal)
{
	mCore->set_ordinal(ordinal);
	return true;
}

bool StreamBase::isEnabled() const
{
	return mCore->is_enabled();
}

bool StreamBase::setEnabled(bool flag)
{
	mCore->set_is_enabled(flag);
	return true;
}

const QString StreamBase::name() const 
{
	return QString().fromStdString(mCore->name());
}

bool StreamBase::setName(QString name) 
{
	mCore->set_name(name.toStdString());
	return true;
}

StreamBase::FrameLengthMode	StreamBase::lenMode() const
{
	return (StreamBase::FrameLengthMode) mCore->len_mode();
}

bool StreamBase::setLenMode(FrameLengthMode	lenMode)
{
	mCore->set_len_mode((OstProto::StreamCore::FrameLengthMode) lenMode); 
	return true;
}

quint16	StreamBase::frameLen(int streamIndex) const
{
	int		pktLen;

	// Decide a frame length based on length mode
	switch(lenMode())
	{
		case OstProto::StreamCore::e_fl_fixed:
			pktLen = mCore->frame_len();
			break;
		case OstProto::StreamCore::e_fl_inc:
			pktLen = frameLenMin() + (streamIndex %
				(frameLenMax() - frameLenMin() + 1));
			break;
		case OstProto::StreamCore::e_fl_dec:
			pktLen = frameLenMax() - (streamIndex %
				(frameLenMax() - frameLenMin() + 1));
			break;
		case OstProto::StreamCore::e_fl_random:
			//! \todo (MED) This 'random' sequence is same across iterations
			qsrand(((uint) this));
			for (int i = 0; i <= streamIndex; i++)
				pktLen = qrand();
			pktLen = frameLenMin() + (pktLen %
				(frameLenMax() - frameLenMin() + 1));
			break;
		default:
			qWarning("Unhandled len mode %d. Using default 64", 
					lenMode());
			pktLen = 64;
			break;
	}

	return pktLen;
}

bool StreamBase::setFrameLen(quint16 frameLen)
{
	mCore->set_frame_len(frameLen);  
	return true;
}

quint16	StreamBase::frameLenMin() const
{
	return mCore->frame_len_min();
}

bool StreamBase::setFrameLenMin(quint16 frameLenMin)
{
	mCore->set_frame_len_min(frameLenMin);  
	return true;
}

quint16	StreamBase::frameLenMax() const
{
	return mCore->frame_len_max();
}

bool StreamBase::setFrameLenMax(quint16 frameLenMax)
{
	mCore->set_frame_len_max(frameLenMax);  
	return true;
}

StreamBase::SendUnit StreamBase::sendUnit() const
{
	return (StreamBase::SendUnit) mControl->unit();
}

bool StreamBase::setSendUnit(SendUnit sendUnit)
{
	mControl->set_unit((OstProto::StreamControl::SendUnit) sendUnit); 
	return true;
}

StreamBase::SendMode StreamBase::sendMode() const
{
	return (StreamBase::SendMode) mControl->mode();
}

bool StreamBase::setSendMode(SendMode sendMode)
{
	mControl->set_mode(
		(OstProto::StreamControl::SendMode) sendMode); 
	return true;
}

StreamBase::NextWhat StreamBase::nextWhat() const
{
	return (StreamBase::NextWhat) mControl->next();
}

bool StreamBase::setNextWhat(NextWhat nextWhat)
{
	mControl->set_next((OstProto::StreamControl::NextWhat) nextWhat); 
	return true;
}

quint32 StreamBase::numPackets() const
{
	return (quint32) mControl->num_packets();
}

bool StreamBase::setNumPackets(quint32 numPackets)
{
	mControl->set_num_packets(numPackets); 
	return true;
}

quint32 StreamBase::numBursts() const
{
	return (quint32) mControl->num_bursts();
}

bool StreamBase::setNumBursts(quint32 numBursts)
{
	mControl->set_num_bursts(numBursts); 
	return true;
}

quint32 StreamBase::burstSize() const
{
	return (quint32) mControl->packets_per_burst();
}

bool StreamBase::setBurstSize(quint32 packetsPerBurst)
{
	mControl->set_packets_per_burst(packetsPerBurst); 
	return true;
}

quint32 StreamBase::packetRate() const
{
	return (quint32) mControl->packets_per_sec();
}

bool StreamBase::setPacketRate(quint32 packetsPerSec)
{
	mControl->set_packets_per_sec(packetsPerSec); 
	return true;
}

quint32 StreamBase::burstRate() const
{
	return (quint32) mControl->bursts_per_sec();
}

bool StreamBase::setBurstRate(quint32 burstsPerSec)
{
	mControl->set_bursts_per_sec(burstsPerSec); 
	return true;
}

bool StreamBase::isFrameVariable() const
{
	ProtocolListIterator	*iter;

	iter = createProtocolListIterator();
	while (iter->hasNext())
	{
		AbstractProtocol	*proto;

		proto = iter->next();
		if (proto->isProtocolFrameValueVariable())
			goto _exit;
	}
	delete iter;
	return false;

_exit:
	delete iter;
	return true;
}

int StreamBase::frameValue(uchar *buf, int bufMaxSize, int n) const
{
	int		pktLen, len = 0;

	pktLen = frameLen(n);

	// pktLen is adjusted for CRC/FCS which will be added by the NIC
	pktLen -=  4;

	if ((pktLen < 0) || (pktLen > bufMaxSize))
		return 0;

	ProtocolListIterator	*iter;

	iter = createProtocolListIterator();
	while (iter->hasNext())
	{
		AbstractProtocol	*proto;
		QByteArray			ba;

		proto = iter->next();
		ba = proto->protocolFrameValue(n);

		if (len + ba.size() < bufMaxSize)
			memcpy(buf+len, ba.constData(), ba.size());
		len += ba.size();
	}
	delete iter;

	return pktLen;
}