private int getByteArrayLength()
{
int blength = 0;
// length of class, method, returnType and compress flag
blength += TransferUtil.getLengthOfString(calleeClass);
blength += TransferUtil.getLengthOfString(calleeMethod);
blength += TransferUtil.getLengthOfByte();
blength += TransferUtil.getLengthOfByte();
// length of maps data
blength += BooleanMapHelper.getByteArrayLength(booleanMap);
blength += ByteMapHelper.getByteArrayLength(byteMap);
blength += ShortMapHelper.getByteArrayLength(shortMap);
blength += CharMapHelper.getByteArrayLength(charMap);
blength += IntMapHelper.getByteArrayLength(intMap);
blength += LongMapHelper.getByteArrayLength(longMap);
blength += FloatMapHelper.getByteArrayLength(floatMap);
blength += DoubleMapHelper.getByteArrayLength(doubleMap);
blength += DateMapHelper.getByteArrayLength(dateMap);
blength += StringMapHelper.getByteArrayLength(stringMap);
blength += WrapperMapHelper.getByteArrayLength(wrapperMap);
blength += ByteArrayMapHelper.getByteArrayLength(byteArrayMap);
blength += IntArrayMapHelper.getByteArrayLength(intArrayMap);
blength += LongArrayMapHelper.getByteArrayLength(longArrayMap);
blength += FloatArrayMapHelper.getByteArrayLength(floatArrayMap);
blength += DoubleArrayMapHelper.getByteArrayLength(doubleArrayMap);
blength += StringArrayMapHelper.getByteArrayLength(stringArrayMap);
return(blength);
}
public TransferObjectWrapper readWrapper()
{
int len = readInt();
if (len == TransferOutputStream.NULL_PLACE_HOLDER)
{
return(null);
}
String wrapperClassName = readString();
len -= TransferUtil.getLengthOfString(wrapperClassName);
byte[] bytearr = new byte[len];
readFully(bytearr, 0, len);
Object retobj = null;
try {
Type type = Type.GetType(wrapperClassName);
Object instance = Activator.CreateInstance(type);
TransferInputStream tins = new TransferInputStream(bytearr);
MethodInfo method = type.GetMethod("getObjectWrapper");
retobj = method.Invoke(instance, new object[] { tins });
} catch (Exception e) {
Logging.LogError(e.ToString());
}
return((TransferObjectWrapper)retobj);
}
public override byte[] getByteData()
{
int blength = getByteArrayLength();
byte[] byteArray = new byte[TransferUtil.getLengthOfInt() + blength];
TransferOutputStream touts = new TransferOutputStream(byteArray);
touts.writeInt(blength);
touts.writeString(calleeClass);
touts.writeString(calleeMethod);
touts.writeByte(returnType);
touts.writeBoolean(compress);
BooleanMapHelper.getByteArray(booleanMap, touts);
ByteMapHelper.getByteArray(byteMap, touts);
ShortMapHelper.getByteArray(shortMap, touts);
CharMapHelper.getByteArray(charMap, touts);
IntMapHelper.getByteArray(intMap, touts);
LongMapHelper.getByteArray(longMap, touts);
FloatMapHelper.getByteArray(floatMap, touts);
DoubleMapHelper.getByteArray(doubleMap, touts);
DateMapHelper.getByteArray(dateMap, touts);
StringMapHelper.getByteArray(stringMap, touts);
WrapperMapHelper.getByteArray(wrapperMap, touts);
ByteArrayMapHelper.getByteArray(byteArrayMap, touts);
IntArrayMapHelper.getByteArray(intArrayMap, touts);
LongArrayMapHelper.getByteArray(longArrayMap, touts);
FloatArrayMapHelper.getByteArray(floatArrayMap, touts);
DoubleArrayMapHelper.getByteArray(doubleArrayMap, touts);
StringArrayMapHelper.getByteArray(stringArrayMap, touts);
return(byteArray);
}
private void Receive()
{
//if handleFlag is true, execute
if (handleFlag)
{
byte[] receiveData = mStateObject.memoryStream.ToArray();
if (TransferUtil.isServerCall(receiveData[0]))
{
//it is server call
ExecuteDelegate executeDelegate = delegate() {
handleServerCall(receiveData);
};
executeDelegate.BeginInvoke(null, null);
//ThreadPool.QueueUserWorkItem(handleServerCall, receiveData);
}
else
{
//it is server response
receiveQueue.Enqueue(receiveData);
}
handleFlag = false;
firsttime = true;
expectReceiveLength = 0;
receiveLength = 0;
//reset memory stream
mStateObject.memoryStream.Position = 0;
mStateObject.memoryStream.SetLength(0);
}
Socket socket = mStateObject.workSocket;
socket.BeginReceive(mStateObject.buffer, 0, StateObject.BUFFER_SIZE, SocketFlags.None, new AsyncCallback(ReceiveCallback), mStateObject);
}
private void Send(StateObject stateObject)
{
TransferObject to = stateObject.transferObject;
Socket client = stateObject.workSocket;
byte[] sendData = TransferUtil.transferObjectToByteArray(to);
client.Send(sendData);
}
// client call
public static Object convertReturnInputStream(Stream ins)
{
// get byte array length
int blength = TransferUtil.readInt(ins);
byte[] buf = new byte[blength];
ins.Read(buf, 0, blength);
return(convertReturnByteArray(buf));
}
private void Send(StateObject stateObject)
{
TransferObject to = stateObject.transferObject;
Socket socket = stateObject.workSocket;
byte[] sendData = TransferUtil.transferObjectToByteArray(to);
//socket.Send(sendData);
// Begin sending the data to the remote device.
socket.BeginSend(sendData, 0, sendData.Length, SocketFlags.None, new AsyncCallback(SendCallback), socket);
}
public int getLength()
{
return(TransferUtil.getLengthOfBoolean() +
TransferUtil.getLengthOfByte() +
TransferUtil.getLengthOfShort() +
TransferUtil.getLengthOfChar() +
TransferUtil.getLengthOfInt() +
TransferUtil.getLengthOfLong() +
TransferUtil.getLengthOfFloat() +
TransferUtil.getLengthOfDouble() +
TransferUtil.getLengthOfDate() +
TransferUtil.getLengthOfString(allTypeBean.getAstring()));
}
private void handleServerCall(object receiveObj)
{
byte[] receiveData = (byte[])receiveObj;
TransferObject to = new StandardTransferObject();
try {
to = TransferUtil.byteArrayToTransferObject(receiveData);
execute(to);
} catch (Exception e) {
Logging.LogError("Callee Class and Method: [" + to.getCalleeClass() + "." + to.getCalleeMethod() + "]");
Logging.LogError("Handle Receive Data error: " + e);
Close(mStateObject);
}
}
public static int getByteArrayLength(Dictionary <String, Double> doubleMap)
{
int blength = 0;
foreach (KeyValuePair <String, Double> item in doubleMap)
{
// type
blength += TransferUtil.getLengthOfByte();
// key
String key = item.Key;
blength += TransferUtil.getLengthOfString(key);
// value
blength += TransferUtil.getLengthOfDouble();
}
return(blength);
}
private Object Receive(StateObject stateObject)
{
Object resultObject = null;
//if return void, don't call socket receive
if (stateObject.transferObject.getReturnType() == TransferObject.DATATYPE_VOID)
{
return(resultObject);
}
Socket client = stateObject.workSocket;
int receiveLength = 0;
int expectReceiveLength = 0;
bool firsttime = true;
while (true)
{
int bytesReceived = client.Receive(stateObject.buffer, 0, StateObject.BufferSize, SocketFlags.None);
stateObject.memoryStream.Write(stateObject.buffer, 0, bytesReceived);
receiveLength += bytesReceived;
//check whether one server response is done or not
if (bytesReceived < StateObject.BufferSize)
{
break;
}
if (bytesReceived == StateObject.BufferSize)
{
if (firsttime)
{
expectReceiveLength = TransferUtil.getExpectReceiveLength(stateObject.buffer);
}
//if expectReceiveLength equal receiveLength, the server response is done
if (expectReceiveLength == receiveLength)
{
break;
}
}
firsttime = false;
}
byte[] receiveData = stateObject.memoryStream.ToArray();
resultObject = TransferUtil.byteArrayToReturnObject(receiveData);
return(resultObject);
}
public static int getByteArrayLength(Dictionary <String, int[]> intArrayMap)
{
int blength = 0;
foreach (KeyValuePair <String, int[]> item in intArrayMap)
{
// type
blength += TransferUtil.getLengthOfByte();
// key
String key = item.Key;
blength += TransferUtil.getLengthOfString(key);
// value
int[] values = item.Value;
blength += TransferUtil.getLengthOfIntArray(values);
}
return(blength);
}
public static int getByteArrayLength(Dictionary <String, TransferObjectWrapper> wrapperMap)
{
int blength = 0;
foreach (KeyValuePair <String, TransferObjectWrapper> item in wrapperMap)
{
// type
blength += TransferUtil.getLengthOfByte();
// key
String key = item.Key;
blength += TransferUtil.getLengthOfString(key);
// value
TransferObjectWrapper value = item.Value;
blength += TransferUtil.getLengthOfWrapper(value);
}
return(blength);
}
public static int getByteArrayLength(Dictionary <String, String> stringMap)
{
int blength = 0;
foreach (KeyValuePair <String, String> item in stringMap)
{
// type
blength += TransferUtil.getLengthOfByte();
// key
String key = item.Key;
blength += TransferUtil.getLengthOfString(key);
// value
String value = item.Value;
blength += TransferUtil.getLengthOfString(value);
}
return(blength);
}
public void writeWrapper(TransferObjectWrapper v)
{
if (v == null)
{
writeNull();
return;
}
int blength = TransferUtil.getLengthOfString(v.GetType().FullName) + v.getLength();
byte[] byteArray = new byte[TransferUtil.getLengthOfInt() + blength];
TransferOutputStream touts = new TransferOutputStream(byteArray);
touts.writeInt(blength);
touts.writeString(v.GetType().FullName);
v.getByteArray(touts);
write(byteArray, 0, byteArray.Length);
}
private Object Receive(StateObject stateObject)
{
Object resultObject = null;
//if return void, don't call socket receive
if (stateObject.transferObject.getReturnType() == TransferObject.DATATYPE_VOID)
{
return(resultObject);
}
//if receiveQueue is empty, wait a while, until server response come
byte[] receiveData = (byte[])receiveQueue.Dequeue(timeout);
if (receiveData != null)
{
resultObject = TransferUtil.byteArrayToReturnObject(receiveData);
}
else
{
Logging.LogError("receive timeout return null");
}
return(resultObject);
}
public void CheckOneReceiveDone(int receivedCount, byte[] receiveData)
{
receiveLength += receivedCount;
//if finish receive one client request, set handle flag is true
if (receivedCount < StateObject.BUFFER_SIZE)
{
handleFlag = true;
}
if (receivedCount == StateObject.BUFFER_SIZE)
{
if (firsttime)
{
expectReceiveLength = TransferUtil.getExpectReceiveLength(receiveData);
}
//if expectReceiveLength equal receiveLength, the server response is done
if (expectReceiveLength == receiveLength)
{
handleFlag = true;
}
}
firsttime = false;
}
private int getByteArrayLength()
{
int blength = 0;
// length of class, method, returnType and compress flag
blength += TransferUtil.getLengthOfString(calleeClass);
blength += TransferUtil.getLengthOfString(calleeMethod);
blength += TransferUtil.getLengthOfByte();
blength += TransferUtil.getLengthOfByte();
// length of list data
foreach (ValueObject vo in paramList)
{
if (vo.dataType == DATATYPE_BOOLEAN)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfBoolean();
}
else if (vo.dataType == DATATYPE_BYTE)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfByte();
}
else if (vo.dataType == DATATYPE_SHORT)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfShort();
}
else if (vo.dataType == DATATYPE_CHAR)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfChar();
}
else if (vo.dataType == DATATYPE_INT)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfInt();
}
else if (vo.dataType == DATATYPE_LONG)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfLong();
}
else if (vo.dataType == DATATYPE_FLOAT)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfFloat();
}
else if (vo.dataType == DATATYPE_DOUBLE)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfDouble();
}
else if (vo.dataType == DATATYPE_DATE)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfDate();
}
else if (vo.dataType == DATATYPE_STRING)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfString((string)vo.dataObject);
}
else if (vo.dataType == DATATYPE_BYTEARRAY)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfByteArray((byte[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_INTARRAY)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfIntArray((int[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_LONGARRAY)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfLongArray((long[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_FLOATARRAY)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfFloatArray((float[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_DOUBLEARRAY)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfDoubleArray((double[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_STRINGARRAY)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfStringArray((string[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_WRAPPER)
{
blength += TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfWrapper((TransferObjectWrapper)vo.dataObject);
}
}
return(blength);
}
public override byte[] getByteData()
{
int blength = getByteArrayLength();
byte[] byteArray = new byte[TransferUtil.getLengthOfInt() + blength];
TransferOutputStream touts = new TransferOutputStream(byteArray);
touts.writeInt(blength);
touts.writeString(calleeClass);
touts.writeString(calleeMethod);
touts.writeByte(returnType);
touts.writeBoolean(compress);
foreach (ValueObject vo in paramList)
{
if (vo.dataType == DATATYPE_BOOLEAN)
{
touts.writeByte(DATATYPE_BOOLEAN);
touts.writeBoolean((bool)vo.dataObject);
}
else if (vo.dataType == DATATYPE_BYTE)
{
touts.writeByte(DATATYPE_BYTE);
touts.writeByte((byte)vo.dataObject);
}
else if (vo.dataType == DATATYPE_SHORT)
{
touts.writeByte(DATATYPE_SHORT);
touts.writeShort((short)vo.dataObject);
}
else if (vo.dataType == DATATYPE_CHAR)
{
touts.writeByte(DATATYPE_CHAR);
touts.writeChar((char)vo.dataObject);
}
else if (vo.dataType == DATATYPE_INT)
{
touts.writeByte(DATATYPE_INT);
touts.writeInt((int)vo.dataObject);
}
else if (vo.dataType == DATATYPE_LONG)
{
touts.writeByte(DATATYPE_LONG);
touts.writeLong((long)vo.dataObject);
}
else if (vo.dataType == DATATYPE_FLOAT)
{
touts.writeByte(DATATYPE_FLOAT);
touts.writeFloat((float)vo.dataObject);
}
else if (vo.dataType == DATATYPE_DOUBLE)
{
touts.writeByte(DATATYPE_DOUBLE);
touts.writeDouble((double)vo.dataObject);
}
else if (vo.dataType == DATATYPE_DATE)
{
touts.writeByte(DATATYPE_DATE);
touts.writeDate((DateTime)vo.dataObject);
}
else if (vo.dataType == DATATYPE_STRING)
{
touts.writeByte(DATATYPE_STRING);
touts.writeString((string)vo.dataObject);
}
else if (vo.dataType == DATATYPE_BYTEARRAY)
{
touts.writeByte(DATATYPE_BYTEARRAY);
touts.writeByteArray((byte[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_INTARRAY)
{
touts.writeByte(DATATYPE_INTARRAY);
touts.writeIntArray((int[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_LONGARRAY)
{
touts.writeByte(DATATYPE_LONGARRAY);
touts.writeLongArray((long[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_FLOATARRAY)
{
touts.writeByte(DATATYPE_FLOATARRAY);
touts.writeFloatArray((float[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_DOUBLEARRAY)
{
touts.writeByte(DATATYPE_DOUBLEARRAY);
touts.writeDoubleArray((double[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_STRINGARRAY)
{
touts.writeByte(DATATYPE_STRINGARRAY);
touts.writeStringArray((string[])vo.dataObject);
}
else if (vo.dataType == DATATYPE_WRAPPER)
{
touts.writeByte(DATATYPE_WRAPPER);
touts.writeWrapper((TransferObjectWrapper)vo.dataObject);
}
}
return(byteArray);
}
public int getLength()
{
return(TransferUtil.getLengthOfInt() +
TransferUtil.getLengthOfString(account.getName()) +
TransferUtil.getLengthOfString(account.getAddress()));
}
/// <summary>
/// Creates the transfers. Forgets the previous transfers.
/// </summary>
public void createTransfers()
{
cacheContent = TransferUtil.createTransfersForAllLines();
}
