/// <summary>
/// 创建输出信息
/// </summary>
/// <param name="sender">TCP 服务套接字数据发送</param>
/// <param name="buildInfo">输出创建参数</param>
internal override OutputLink Build(ServerSocketSenderBase sender, ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = sender.OutputSerializer.Stream;
if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= outputInfo.MaxDataSize)
{
int streamLength = stream.ByteSize;
OutputLink nextBuild = LinkNext;
stream.PrepLength(sizeof(uint) + sizeof(int) * 2);
stream.ByteSize += sizeof(uint) + sizeof(int);
if ((Server.GetCommandFlags(ref CommandIndex) & CommandFlags.JsonSerialize) == 0)
{
sender.Serialize(outputInfo, ref outputParameter);
}
else
{
sender.JsonSerialize(ref outputParameter);
}
int dataLength = stream.ByteSize - streamLength - (sizeof(uint) + sizeof(int));
byte *dataFixed = stream.Data.Byte + streamLength;
*(uint *)dataFixed = CommandIndex;
*(int *)(dataFixed + sizeof(uint)) = dataLength;
outputInfo.CheckMaxDataSize(Math.Max(dataLength + (sizeof(uint) + sizeof(int)), stream.LastPrepSize - streamLength));
++buildInfo.Count;
LinkNext = null;
outputParameter = default(outputParameterType);
AutoCSer.Threading.RingPool <Output <outputParameterType> > .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
///// <summary>
///// 保持回调序号
///// </summary>
//protected int keepCallbackIdentity;
///// <summary>
///// 保持回调
///// </summary>
//internal bool SetKeepCallback()
//{
// int index = (int)(CommandIndex & Server.CommandIndexAnd);
// try
// {
// KeepCallback = new KeepCallback(this, ++keepCallbackIdentity);
// return true;
// }
// catch (Exception error)
// {
// Socket.Log.add(LogLevel.Error, error);
// }
// Socket.FreeIndex(index);
// return false;
//}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>下一个命令</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) + sizeof(uint))
{
CommandBase nextBuild = LinkNext;
int commandIndex = Socket.CommandPool.Push(this);
if (commandIndex != 0)
{
if (KeepCallback.SetCommandIndex(commandIndex))
{
stream.Data.Write(CommandInfo.Command, (uint)commandIndex | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData));
++buildInfo.Count;
LinkNext = null;
return(nextBuild);
}
Socket.CommandPool.Cancel(commandIndex);
}
else
{
KeepCallback.BuildCancel();
}
LinkNext = null;
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>下一个命令</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) + sizeof(uint))
{
CommandBase nextBuild = LinkNext;
int commandIndex = Socket.CommandPool.Push(this);
if (commandIndex != 0)
{
byte *write = stream.CurrentData;
*(int *)write = CommandInfo.Command;
*(uint *)(write + sizeof(int)) = (uint)commandIndex | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData);
++buildInfo.Count;
LinkNext = null;
stream.ByteSize += sizeof(int) + sizeof(uint);
return(nextBuild);
}
LinkNext = null;
ReturnType = ReturnType.ClientBuildError;
setTask();
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建输出信息
/// </summary>
/// <param name="sender">TCP 服务套接字数据发送</param>
/// <param name="buildInfo">输出创建参数</param>
internal override OutputLink Build(ServerSocketSenderBase sender, ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = sender.OutputSerializer.Stream;
int dataSize = (Data.Length + (sizeof(int) + 3)) & (int.MaxValue), prepLength = dataSize + (sizeof(uint) + sizeof(int));
if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= prepLength ||
(stream.Data.FreeSize >= prepLength && prepLength > buildInfo.SendBufferSize - TcpServer.ServerOutput.OutputLink.StreamStartIndex))
{
OutputLink nextBuild = LinkNext;
byte * write = stream.GetPrepSizeCurrent(prepLength);
*(uint *)write = ClientCommand.KeepCommand.CustomDataIndex;
*(int *)(write + sizeof(uint)) = dataSize;
*(int *)(write + (sizeof(uint) + sizeof(int))) = Data.Length;
if (Data.Length != 0)
{
fixed(byte *dataFixed = Data.GetFixedBuffer()) AutoCSer.Memory.Common.CopyNotNull(dataFixed + Data.Start, write + (sizeof(uint) + sizeof(int) * 2), Data.Length);
}
stream.Data.CurrentIndex += dataSize + (sizeof(uint) + sizeof(int));
++buildInfo.Count;
LinkNext = null;
Data.Array = null;
AutoCSer.Threading.RingPool <CustomDataOutput> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
int dataSize = (data.Length + 3) & (int.MaxValue), prepLength = dataSize + (sizeof(uint) + sizeof(int) * 2);
if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= prepLength ||
(stream.FreeSize >= prepLength && prepLength > buildInfo.SendBufferSize - TcpServer.ClientCommand.Command.StreamStartIndex))
{
CommandBase nextBuild = LinkNext;
stream.PrepLength(prepLength);
byte *write = stream.CurrentData;
*(int *)write = Server.CustomDataCommandIndex;
*(uint *)(write + sizeof(int)) = (uint)data.Length;
*(int *)(write + (sizeof(uint) + sizeof(int))) = dataSize;
if (data.Length != 0)
{
fixed(byte *dataFixed = data.Array) Memory.CopyNotNull(dataFixed + data.Start, write + (sizeof(uint) + sizeof(int) * 2), data.Length);
}
stream.ByteSize += dataSize + (sizeof(uint) + sizeof(int) * 2);
++buildInfo.Count;
data.Array = null;
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <CustomDataCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= CommandInfo.MaxDataSize)
{
int streamLength = stream.ByteSize;
stream.PrepLength(sizeof(uint) + sizeof(int) * 3);
CommandBase nextBuild = LinkNext;
stream.ByteSize += sizeof(uint) + sizeof(int) * 2;
if ((CommandInfo.CommandFlags & CommandFlags.JsonSerialize) == 0)
{
Socket.Serialize(CommandInfo, ref InputParameter);
}
else
{
Socket.JsonSerialize(ref InputParameter);
}
int dataLength = stream.ByteSize - streamLength - (sizeof(int) * 2 + sizeof(uint));
InputParameter = default(inputParameterType);
if (dataLength <= Socket.MaxInputSize)
{
int commandIndex = Socket.CommandPool.Push(this);
if (commandIndex != 0)
{
if (KeepCallback.SetCommandIndex(commandIndex))
{
byte *write = stream.Data.Byte + streamLength;
buildInfo.IsVerifyMethod |= CommandInfo.IsVerifyMethod;
++buildInfo.Count;
*(int *)write = CommandInfo.Command;
*(uint *)(write + sizeof(int)) = (uint)commandIndex | (uint)CommandInfo.CommandFlags;
*(int *)(write + (sizeof(uint) + sizeof(int))) = dataLength;
CommandInfo.CheckMaxDataSize(Math.Max(dataLength + (sizeof(int) * 2 + sizeof(uint)), stream.LastPrepSize - streamLength));
LinkNext = null;
return(nextBuild);
}
Socket.CommandPool.Cancel(commandIndex);
}
else
{
KeepCallback.BuildCancel();
}
}
else
{
KeepCallback.BuildCancel();
}
stream.ByteSize = streamLength;
LinkNext = null;
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>下一个命令</returns>
internal unsafe override TcpServer.ClientCommand.CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int))
{
*(int *)stream.CurrentData = CommandInfo.Command | (int)(uint)(CommandInfo.CommandFlags | CommandFlags.NullData);
stream.ByteSize += sizeof(int);
return(LinkNext);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override TcpServer.ClientCommand.CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if (stream.ByteSize == 0 && LinkNext == null)
{
*(int *)stream.CurrentData = Server.CheckCommandIndex | (int)(uint)TcpServer.CommandFlags.NullData;
stream.ByteSize += sizeof(int);
}
Interlocked.Exchange(ref FreeLock, 1);
IsBuildError = true;
Socket = null;
return(LinkNext);
}
/// <summary>
/// 创建输出信息
/// </summary>
/// <param name="sender">TCP 服务套接字数据发送</param>
/// <param name="buildInfo">输出创建参数</param>
internal unsafe override OutputLink Build(ServerSocketSenderBase sender, ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = sender.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(uint))
{
OutputLink nextBuild = LinkNext;
stream.Data.Write(CommandIndex);
LinkNext = null;
++buildInfo.Count;
AutoCSer.Threading.RingPool <ReturnTypeOutput> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
CommandBase nextBuild = LinkNext;
if (buildInfo.Count == 0 && nextBuild == null)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
buildInfo.Count = 1;
stream.Data.Write(Server.CheckCommandIndex, (uint)CommandFlags.NullData);
Socket = null;
AutoCSer.Threading.RingPool <CheckCommand> .Default.PushNotNull(this);
}
else
{
LinkNext = null;
}
return(nextBuild);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if (buildInfo.Count == 0 || (buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= CommandInfo.MaxDataSize)
{
int streamLength = stream.Data.CurrentIndex;
stream.PrepSize(sizeof(uint) + sizeof(int) * 3);
CommandBase nextBuild = LinkNext;
stream.Data.CurrentIndex += sizeof(uint) + sizeof(int) * 2;
if ((CommandInfo.CommandFlags & CommandFlags.JsonSerialize) == 0)
{
Socket.Serialize(CommandInfo, ref InputParameter);
}
else
{
Socket.JsonSerialize(ref InputParameter);
}
int dataLength = stream.Data.CurrentIndex - streamLength - (sizeof(int) * 2 + sizeof(uint));
if (dataLength <= Socket.MaxInputSize)
{
int commandIndex = Socket.CommandPool.Push(this);
if (commandIndex != 0)
{
byte *write = stream.Data.Byte + streamLength;
buildInfo.IsVerifyMethod |= CommandInfo.IsVerifyMethod;
++buildInfo.Count;
*(int *)write = CommandInfo.Command;
*(uint *)(write + sizeof(int)) = (uint)commandIndex | (uint)CommandInfo.CommandFlags;
*(int *)(write + (sizeof(uint) + sizeof(int))) = dataLength;
CommandInfo.CheckMaxDataSize(Math.Max(dataLength + (sizeof(int) * 2 + sizeof(uint)), stream.LastPrepSize - streamLength));
LinkNext = null;
return(nextBuild);
}
}
stream.Data.CurrentIndex = streamLength;
LinkNext = null;
ReturnType = ReturnType.ClientBuildError;
setTask();
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override TcpServer.ClientCommand.CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
int streamLength = stream.ByteSize;
if (streamLength == 0 || (buildInfo.SendBufferSize - stream.ByteSize) >= CommandInfo.MaxDataSize)
{
stream.PrepLength(sizeof(int) * 3);
stream.ByteSize += sizeof(int) * 2;
if ((CommandInfo.CommandFlags & CommandFlags.JsonSerialize) == 0)
{
Socket.Serialize(CommandInfo, ref InputParameter);
}
else
{
Socket.JsonSerialize(ref InputParameter);
}
int dataLength = stream.ByteSize - streamLength - sizeof(int) * 2;
if (dataLength <= Socket.MaxInputSize)
{
ulong markData = Socket.Sender.SendMarkData;
byte *write = stream.Data.Byte + streamLength;
buildInfo.IsVerifyMethod |= CommandInfo.IsVerifyMethod;
*(int *)write = CommandInfo.Command | (int)(uint)CommandInfo.CommandFlags;
*(int *)(write + sizeof(int)) = dataLength;
if (markData != 0)
{
TcpServer.CommandBase.Mark(write + sizeof(int) * 2, markData, dataLength);
}
CommandInfo.CheckMaxDataSize(Math.Max(dataLength + sizeof(int) * 2, stream.LastPrepSize - streamLength));
}
else
{
stream.ByteSize = streamLength;
OutputParameter.Type = ReturnType.ClientBuildError;
IsBuildError = true;
setTask();
}
return(LinkNext);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) + sizeof(uint))
{
CommandBase nextBuild = LinkNext;
stream.Data.Write(CommandInfo.Command, (uint)(CommandInfo.CommandFlags | CommandFlags.NullData));
++buildInfo.Count;
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <SendOnlyCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) * 3)
{
CommandBase nextBuild = LinkNext;
stream.Data.Write(Server.CancelKeepCommandIndex, cancelCommandIndex, 0);
++buildInfo.Count;
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <CancelKeepCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
CommandBase nextBuild = LinkNext;
if (buildInfo.Count == 0 && nextBuild == null)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
buildInfo.Count = 1;
byte *write = stream.CurrentData;
Socket = null;
*(int *)write = Server.CheckCommandIndex;
//*(uint*)(write + sizeof(int)) |= (uint)(CommandFlags.NullData | CommandFlags.NullIndex);
*(uint *)(write + sizeof(int)) |= (uint)CommandFlags.NullData;
stream.ByteSize += sizeof(int) + sizeof(uint);
AutoCSer.Threading.RingPool <CheckCommand> .Default.PushNotNull(this);
}
else
{
LinkNext = null;
}
return(nextBuild);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) + sizeof(uint))
{
byte * write = stream.CurrentData;
CommandBase nextBuild = LinkNext;
*(int *)write = CommandInfo.Command;
//*(uint*)(write + sizeof(int)) = (CommandIndex & Server.CommandIndexAnd) | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData);
*(uint *)(write + sizeof(int)) = (uint)(CommandInfo.CommandFlags | CommandFlags.NullData);
++buildInfo.Count;
stream.ByteSize += sizeof(int) + sizeof(uint);
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <SendOnlyCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>下一个命令</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.Data.CurrentIndex) >= sizeof(int) + sizeof(uint))
{
CommandBase nextBuild = LinkNext;
int commandIndex = Socket.CommandPool.Push(this);
if (commandIndex != 0)
{
stream.Data.Write(CommandInfo.Command, (uint)commandIndex | (uint)(CommandInfo.CommandFlags | CommandFlags.NullData));
++buildInfo.Count;
LinkNext = null;
return(nextBuild);
}
LinkNext = null;
OutputParameter.Type = ReturnType.ClientBuildError;
setTask();
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>是否成功</returns>
internal unsafe override CommandBase Build(ref SenderBuildInfo buildInfo)
{
UnmanagedStream stream = Socket.OutputSerializer.Stream;
if ((buildInfo.SendBufferSize - stream.ByteSize) >= sizeof(int) * 3)
{
CommandBase nextBuild = LinkNext;
byte * write = stream.CurrentData;
*(int *)write = Server.CancelKeepCommandIndex;
*(int *)(write + sizeof(int)) = cancelCommandIndex;
*(int *)(write + (sizeof(uint) + sizeof(int))) = 0;
stream.ByteSize += sizeof(int) * 3;
++buildInfo.Count;
Socket = null;
LinkNext = null;
AutoCSer.Threading.RingPool <CancelKeepCommand> .Default.PushNotNull(this);
return(nextBuild);
}
buildInfo.isFullSend = 1;
return(this);
}
/// <summary>
/// 创建命令输入数据
/// </summary>
/// <param name="buildInfo">TCP 客户端创建命令参数</param>
/// <returns>下一个命令</returns>
internal virtual CommandBase Build(ref SenderBuildInfo buildInfo)
{
throw new InvalidOperationException();
}
/// <summary> /// 创建输出信息 /// </summary> /// <param name="sender">TCP 服务套接字数据发送</param> /// <param name="buildInfo">输出创建参数</param> internal abstract outputLinkType Build(ServerSocketSenderBase sender, ref SenderBuildInfo buildInfo);
