add

+/*
+ * Copyright 2007-2008 Stephen Liu
+ * For license terms, see the file COPYING along with this library.
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "spporting.hpp"
+
+#include "spsession.hpp"
+#include "sphandler.hpp"
+#include "spbuffer.hpp"
+#include "sputils.hpp"
+#include "sprequest.hpp"
+#include "spiochannel.hpp"
+
+#ifndef WIN32
+#include "event.h"
+#endif
+
+//-------------------------------------------------------------------
+
+typedef struct tagSP_SessionEntry {
+	uint16_t mSeq;
+	uint16_t mNext;
+
+	SP_Session * mSession;
+} SP_SessionEntry;
+
+SP_SessionManager :: SP_SessionManager()
+{
+	mFreeCount = 0;
+	mFreeList = 0;
+	mCount = 0;
+	memset( mArray, 0, sizeof( mArray ) );
+}
+
+SP_SessionManager :: ~SP_SessionManager()
+{
+	for( int i = 0; i < (int)( sizeof( mArray ) / sizeof( mArray[0] ) ); i++ ) {
+		SP_SessionEntry_t * list = mArray[ i ];
+		if( NULL != list ) {
+			SP_SessionEntry_t * iter = list;
+			for( int i = 0; i < eColPerRow; i++, iter++ ) {
+				if( NULL != iter->mSession ) {
+					delete iter->mSession;
+					iter->mSession = NULL;
+				}
+			}
+			free( list );
+		}
+	}
+
+	memset( mArray, 0, sizeof( mArray ) );
+}
+
+uint16_t SP_SessionManager :: allocKey( uint16_t * seq )
+{
+	uint16_t key = 0;
+
+	if( mFreeList <= 0 ) {
+		int avail = -1;
+		for( int i = 1; i < (int)( sizeof( mArray ) / sizeof( mArray[0] ) ); i++ ) {
+			if( NULL == mArray[i] ) {
+				avail = i;
+				break;
+			}
+		}
+
+		if( avail > 0 ) {
+			mFreeCount += eColPerRow;
+			mArray[ avail ] = ( SP_SessionEntry_t * )calloc(
+					eColPerRow, sizeof( SP_SessionEntry_t ) );
+			for( int i = eColPerRow - 1; i >= 0; i-- ) {
+				mArray[ avail ] [ i ].mNext = mFreeList;
+				mFreeList = eColPerRow * avail + i;
+			}
+		}
+	}
+
+	if( mFreeList > 0 ) {
+		key = mFreeList;
+		--mFreeCount;
+
+		int row = mFreeList / eColPerRow, col = mFreeList % eColPerRow;
+
+		*seq = mArray[ row ] [ col ].mSeq;
+		mFreeList = mArray[ row ] [ col ].mNext;
+	}
+
+	return key;
+}
+
+int SP_SessionManager :: getCount()
+{
+	return mCount;
+}
+
+int SP_SessionManager :: getFreeCount()
+{
+	return mFreeCount;
+}
+
+void SP_SessionManager :: put( uint16_t key, uint16_t seq, SP_Session * session )
+{
+	int row = key / eColPerRow, col = key % eColPerRow;
+
+	assert( NULL != mArray[ row ] );
+
+	SP_SessionEntry_t * list = mArray[ row ];
+
+	assert( NULL == list[ col ].mSession );
+	assert( seq == list[ col ].mSeq );
+
+	list[ col ].mSession = session;
+
+	mCount++;
+}
+
+SP_Session * SP_SessionManager :: get( uint16_t key, uint16_t * seq )
+{
+	int row = key / eColPerRow, col = key % eColPerRow;
+
+	SP_Session * ret = NULL;
+
+	SP_SessionEntry_t * list = mArray[ row ];
+	if( NULL != list ) {
+		ret = list[ col ].mSession;
+		* seq = list[ col ].mSeq;
+	} else {
+		* seq = 0;
+	}
+
+	return ret;
+}
+
+SP_Session * SP_SessionManager :: remove( uint16_t key, uint16_t seq )
+{
+	int row = key / eColPerRow, col = key % eColPerRow;
+
+	SP_Session * ret = NULL;
+
+	SP_SessionEntry_t * list = mArray[ row ];
+	if( NULL != list ) {
+		assert( seq == list[ col ].mSeq );
+
+		ret = list[ col ].mSession;
+
+		list[ col ].mSession = NULL;
+		list[ col ].mSeq++;
+
+		list[ col ].mNext = mFreeList;
+		mFreeList = key;
+		++mFreeCount;
+
+		mCount--;
+	}
+
+	return ret;
+}
+
+//-------------------------------------------------------------------
+
+SP_Session :: SP_Session( SP_Sid_t sid )
+{
+	mSid = sid;
+
+	mReadEvent = NULL;
+	mWriteEvent = NULL;
+
+#ifndef WIN32
+	mReadEvent = (struct event*)malloc( sizeof( struct event ) );
+	mWriteEvent = (struct event*)malloc( sizeof( struct event ) );
+#endif
+
+	mHandler = NULL;
+	mArg = NULL;
+
+	mInBuffer = new SP_Buffer();
+	mRequest = new SP_Request();
+
+	mOutOffset = 0;
+	mOutList = new SP_ArrayList();
+
+	mStatus = eNormal;
+	mRunning = 0;
+	mWriting = 0;
+	mReading = 0;
+
+	mTotalRead = mTotalWrite = 0;
+
+	mIOChannel = NULL;
+}
+
+SP_Session :: ~SP_Session()
+{
+	if( NULL != mReadEvent ) free( mReadEvent );
+	mReadEvent = NULL;
+
+	if( NULL != mWriteEvent ) free( mWriteEvent );
+	mWriteEvent = NULL;
+
+	if( NULL != mHandler ) {
+		delete mHandler;
+		mHandler = NULL;
+	}
+
+	delete mRequest;
+	mRequest = NULL;
+
+	delete mInBuffer;
+	mInBuffer = NULL;
+
+	delete mOutList;
+	mOutList = NULL;
+
+	if( NULL != mIOChannel ) {
+		delete mIOChannel;
+		mIOChannel = NULL;
+	}
+}
+
+struct event * SP_Session :: getReadEvent()
+{
+	return mReadEvent;
+}
+
+struct event * SP_Session :: getWriteEvent()
+{
+	return mWriteEvent;
+}
+
+void SP_Session :: setHandler( SP_Handler * handler )
+{
+	mHandler = handler;
+}
+
+SP_Handler * SP_Session :: getHandler()
+{
+	return mHandler;
+}
+
+void SP_Session :: setArg( void * arg )
+{
+	mArg = arg;
+}
+
+void * SP_Session :: getArg()
+{
+	return mArg;
+}
+
+SP_Sid_t SP_Session :: getSid()
+{
+	return mSid;
+}
+
+SP_Buffer * SP_Session :: getInBuffer()
+{
+	return mInBuffer;
+}
+
+SP_Request * SP_Session :: getRequest()
+{
+	return mRequest;
+}
+
+void SP_Session :: setOutOffset( int offset )
+{
+	mOutOffset = offset;
+}
+
+int SP_Session :: getOutOffset()
+{
+	return mOutOffset;
+}
+
+SP_ArrayList * SP_Session :: getOutList()
+{
+	return mOutList;
+}
+
+void SP_Session :: setStatus( int status )
+{
+	mStatus = status;
+}
+
+int SP_Session :: getStatus()
+{
+	return mStatus;
+}
+
+int SP_Session :: getRunning()
+{
+	return mRunning;
+}
+
+void SP_Session :: setRunning( int running )
+{
+	mRunning = running;
+}
+
+int SP_Session :: getWriting()
+{
+	return mWriting;
+}
+
+void SP_Session :: setWriting( int writing )
+{
+	mWriting = writing;
+}
+
+int SP_Session :: getReading()
+{
+	return mReading;
+}
+
+void SP_Session :: setReading( int reading )
+{
+	mReading = reading;
+}
+
+SP_IOChannel * SP_Session :: getIOChannel()
+{
+	return mIOChannel;
+}
+
+void SP_Session :: setIOChannel( SP_IOChannel * ioChannel )
+{
+	mIOChannel = ioChannel;
+}
+
+unsigned int SP_Session :: getTotalRead()
+{
+	return mTotalRead;
+}
+
+void SP_Session :: addRead( int len )
+{
+	mTotalRead += len;
+}
+
+unsigned int SP_Session :: getTotalWrite()
+{
+	return mTotalWrite;
+}
+
+void SP_Session :: addWrite( int len )
+{
+	mTotalWrite += len;
+}