public static byte Parse(
Level lvl,
SegmentOffset segOff)
{
Material mat = Material.Default;
return(Parse(lvl, ref mat, segOff));
}
/// <summary>
/// 根据偏移发送缓冲区数据
/// </summary>
/// <param name="sendSegment"></param>
/// <param name="waiting"></param>
public bool Send(SegmentOffset sendSegment, bool waiting = true)
{
try
{
if (IsClose())
{
Close();
return(false);
}
var segItems = _sBufferManager.BufferToSegments(sendSegment.Buffer, sendSegment.Offset, sendSegment.Size);
var isWillEvent = true;
foreach (var seg in segItems)
{
var tArgs = GetSocketAsyncFromSendPool(waiting);
if (tArgs == null)
{
return(false);
}
if (!_sBufferManager.WriteBuffer(tArgs, seg.Array, seg.Offset, seg.Count))
{
_sendTokenManager.Set(tArgs);
throw new Exception(string.Format("发送缓冲区溢出...buffer block max size:{0}", _sBufferManager.BlockSize));
}
if (tArgs.UserToken == null)
{
((SocketToken)tArgs.UserToken).TokenSocket = socket;
}
if (IsClose())
{
Close();
return(false);
}
isWillEvent &= socket.SendAsync(tArgs);
if (!isWillEvent)//can't trigger the io complated event to do
{
ProcessSentCallback(tArgs);
}
if (_sendTokenManager.Count < (_sendTokenManager.Capacity >> 2))
{
Thread.Sleep(2);
}
}
return(isWillEvent);
}
catch (Exception)
{
Close();
throw;
}
}
public SegmentOffset ToSegmentFrame(SegmentOffset data, OpCodeType code = OpCodeType.Text)
{
OpCode = (byte)code;
Payload = data;
PayloadLength = Payload.buffer.LongLength;
return(new SegmentOffset(EncodingToBytes()));
}
public bool Send(SegmentOffset data, bool waiting = true)
{
if (IsConnected == false)
{
return(false);
}
clientProvider.Send(data, waiting);
return(true);
}
public static GeoRoot Parse(
Model3D mdl,
Level lvl,
#if !NO_LEVEL_MAT
ref Material material,
#endif
SegmentOffset segOff)
{
var root = new GeoRoot(mdl);
var rt = new Runtime(lvl, mdl, root)
#if !NO_GEO_MAT && !NO_LEVEL_MAT
{
material = material,
}
#elif !NO_GEO_MAT
{ material = Material.Default, }
#endif
;
Runtime.SetSegment(rt, segOff);
root.Code = Runtime.Evaluate(rt);
var endingNode = rt.nodeCurrent;
#if DEBUG
rt.log.AppendLine("End parse:" + (null == endingNode?"null":endingNode.Depth.ToString()));
{
for (int i = 0; i < 256; i++)
{
if (rt.counter[i] != 0)
{
rt.log.AppendLine(i.ToString("X2") + ":" + rt.counter[i]);
}
}
rt.log.AppendLine(rt.counter[256].ToString());
}
#endif
root.Bind();
#if !NO_GEO_MAT
material = rt.material;
#endif
#if DEBUG
if (rt.nodeCurrent != null)
{
rt.log.AppendLine("!+" + (1u + rt.nodeCurrent.Depth));
System.Console.WriteLine(rt.log);
}
else if (rt.counter[256] != 0)
{
System.Console.WriteLine(rt.log);
}
#endif
return(mdl.root = root);
}
public static GeoRoot Parse(Area area,
#if !NO_LEVEL_MAT
ref Material material,
#endif
SegmentOffset segOff)
{
return(Parse(area.AreaModel, area.level,
#if !NO_LEVEL_MAT
ref material,
#endif
segOff));
}
public SegmentOffset ToSegmentFrame(string content)
{
var buf = encoding.GetBytes(content);
Payload = new SegmentOffset()
{
buffer = buf
};
PayloadLength = Payload.buffer.LongLength;
return(new SegmentOffset(EncodingToBytes()));
}
public AccessInfo GetHandshakePackage(SegmentOffset segOffset)
{
string msg = encoding.GetString(segOffset.buffer, segOffset.offset, segOffset.size);
string[] items = msg.Split(BaseInfo.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (items.Length < 6)
{
throw new Exception("access format error..." + msg);
}
AccessInfo access = new AccessInfo()
{
HttpProto = items[0]
};
foreach (var item in items)
{
string[] kv = item.Split(splitChars, StringSplitOptions.RemoveEmptyEntries);
switch (kv[0])
{
case "Connection":
access.Connection = kv[1];
break;
case "Host":
access.Host = kv[1];
break;
case "Origin":
access.Origin = kv[1];
break;
case "Upgrade":
access.Upgrade = kv[1];
break;
case "Sec-WebSocket-Key":
access.SecWebSocketKey = kv[1];
break;
case "Sec-WebSocket-Version":
access.SecWebSocketVersion = kv[1];
break;
case "Sec-WebSocket-Extensions":
access.SecWebSocketExtensions = kv[1];
break;
}
}
return(access);
}
/// <summary>
/// 同步发送
/// </summary>
/// <param name="sendSegment"></param>
/// <param name="receiveSegment"></param>
/// <returns></returns>
public int SendSync(SegmentOffset sendSegment, SegmentOffset receiveSegment)
{
var sent = Socket.SendTo(sendSegment.Buffer, sendSegment.Offset, sendSegment.Size, 0, IpEndPoint);
if (receiveSegment?.Buffer == null || receiveSegment.Size == 0)
{
return(sent);
}
Socket.ReceiveFrom(receiveSegment.Buffer,
receiveSegment.Size,
SocketFlags.None,
ref IpEndPoint);
return(sent);
}
/// <summary>
/// 同步接收
/// </summary>
/// <param name="receiveSegment"></param>
/// <param name="receiveAction"></param>
public void ReceiveSync(SegmentOffset receiveSegment, Action <SegmentOffset> receiveAction)
{
do
{
var cnt = Socket.ReceiveFrom(receiveSegment.Buffer,
receiveSegment.Size,
SocketFlags.None,
ref IpEndPoint);
if (cnt <= 0)
{
break;
}
receiveAction(receiveSegment);
} while (true);
}
/// <summary>
/// 同步发送
/// </summary>
/// <param name="buffer"></param>
/// <param name="recAct"></param>
/// <param name="recBufferSize"></param>
/// <returns></returns>
public int SendSync(SegmentOffset sendSegment, SegmentOffset receiveSegment)
{
int sent = socket.SendTo(sendSegment.buffer, sendSegment.offset, sendSegment.size, 0, ipEndPoint);
if (receiveSegment == null ||
receiveSegment.buffer == null ||
receiveSegment.size == 0)
{
return(sent);
}
int cnt = socket.ReceiveFrom(receiveSegment.buffer,
receiveSegment.size,
SocketFlags.None,
ref ipEndPoint);
return(sent);
}
/// <summary>
/// 同步发送数据
/// </summary>
/// <param name="sendSegment"></param>
/// <param name="receiveSegment"></param>
/// <returns></returns>
public int SendSync(SegmentOffset sendSegment, SegmentOffset receiveSegment)
{
if (_channelProviderState != ChannelProviderType.Sync)
{
throw new Exception("需要使用同步连接...ConnectSync");
}
var sent = socket.Send(sendSegment.Buffer, sendSegment.Offset, sendSegment.Size, SocketFlags.None);
if (receiveSegment?.Buffer == null || receiveSegment.Size == 0)
{
return(sent);
}
socket.Receive(receiveSegment.Buffer, receiveSegment.Size, 0);
return(sent);
}
public HttpPayload GetDo(SegmentToken sToken)
{
var paylaod = new HttpPayload()
{
Header = header,
HttpUri = new HttpUri(header.RelativeUri),
Token = sToken.sToken
};
if (header.ContentLength > 0)
{
SegmentOffset seg = sToken.Data;
paylaod.stream = new MemoryStream(seg.buffer,
seg.offset + (int)header.StreamPosition,
(int)header.ContentLength);
}
return(paylaod);
}
/// <summary>
/// 同步接收
/// </summary>
/// <param name="recAct"></param>
/// <param name="recBufferSize"></param>
public void ReceiveSync(SegmentOffset receiveSegment, Action <SegmentOffset> receiveAction)
{
int cnt = 0;
do
{
cnt = socket.ReceiveFrom(receiveSegment.buffer,
receiveSegment.size,
SocketFlags.None,
ref ipEndPoint);
if (cnt <= 0)
{
break;
}
receiveAction(receiveSegment);
} while (true);
}
public bool Send(SegmentOffset sendSegment, bool waiting = true)
{
try
{
bool isWillEvent = true;
ArraySegment <byte>[] segItems = sendBufferManager.BufferToSegments(sendSegment.buffer, sendSegment.offset, sendSegment.size);
foreach (var seg in segItems)
{
SocketAsyncEventArgs tArgs = sendTokenManager.GetEmptyWait((retry) =>
{
return(true);
}, waiting);
if (tArgs == null)
{
throw new Exception("发送缓冲池已用完,等待回收...");
}
tArgs.RemoteEndPoint = ipEndPoint;
if (!sendBufferManager.WriteBuffer(tArgs, seg.Array, seg.Offset, seg.Count))
{
sendTokenManager.Set(tArgs);
throw new Exception(string.Format("发送缓冲区溢出...buffer block max size:{0}", sendBufferManager.BlockSize));
}
isWillEvent &= socket.SendToAsync(tArgs);
if (!isWillEvent)
{
ProcessSent(tArgs);
}
}
return(isWillEvent);
}
catch (Exception ex)
{
Close();
throw ex;
}
}
public static byte Parse(
Level lvl,
#if !NO_LEVEL_MAT
ref Material material,
#endif
SegmentOffset segOff)
{
var rt = new Runtime(lvl)
#if !NO_LEVEL_MAT
{
material = material,
}
#endif
;
Runtime.SetSegment(rt, segOff);
var ret = Runtime.Evaluate(rt);
return(ret);
}
public HttpHeader(SegmentOffset segment)
{
using (MemoryStream ms = new MemoryStream(segment.buffer, segment.offset, segment.size))
using (StreamReader reader = new StreamReader(ms, Encoding.UTF8))
{
string line = reader.ReadLine();// first line
GetHeaderLine(line);
while ((line = reader.ReadLine()) != null)
{
if (line == string.Empty)
{
ContentLength = ms.Length - ms.Position;
StreamPosition = ms.Position;
break;
}
GetHeader(line);
}
}
}
public bool Send(SegmentOffset sendSegment, bool waiting = true)
{
try
{
var isWillEvent = true;
var segItems = _sendBufferManager.BufferToSegments(sendSegment.Buffer, sendSegment.Offset, sendSegment.Size);
foreach (var seg in segItems)
{
var tArgs = _sendTokenManager.GetEmptyWait((retry) => true, waiting);
if (tArgs == null)
{
throw new Exception("发送缓冲池已用完,等待回收...");
}
tArgs.RemoteEndPoint = IpEndPoint;
if (!_sendBufferManager.WriteBuffer(tArgs, seg.Array, seg.Offset, seg.Count))
{
_sendTokenManager.Set(tArgs);
throw new Exception(string.Format("发送缓冲区溢出...buffer block max size:{0}", _sendBufferManager.BlockSize));
}
isWillEvent &= Socket.SendToAsync(tArgs);
if (!isWillEvent)
{
ProcessSent(tArgs);
}
}
return(isWillEvent);
}
catch (Exception)
{
Close();
throw;
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="dataSegment"></param>
/// <param name="remoteEp"></param>
/// <param name="waiting"></param>
public bool Send(SegmentOffset dataSegment, IPEndPoint remoteEp, bool waiting)
{
var isWillEvent = true;
var segItems = _sendBufferManager.BufferToSegments(dataSegment.Buffer, dataSegment.Offset, dataSegment.Size);
foreach (var seg in segItems)
{
var tArgs = _sendTokenManager.GetEmptyWait(retry => true, waiting);
if (tArgs == null)
{
throw new Exception("发送缓冲池已用完,等待回收超时...");
}
tArgs.RemoteEndPoint = remoteEp;
var s = SocketVersion(remoteEp);
tArgs.UserToken = s;
if (!_sendBufferManager.WriteBuffer(tArgs, seg.Array, seg.Offset, seg.Count))
{
_sendTokenManager.Set(tArgs);
throw new Exception(string.Format("发送缓冲区溢出...buffer block max size:{0}", _sendBufferManager.BlockSize));
}
if (tArgs.RemoteEndPoint != null)
{
isWillEvent &= s.SendToAsync(tArgs);
if (!isWillEvent)
{
ProcessSent(tArgs);
}
}
Thread.Sleep(5);
}
return(isWillEvent);
}
/// <summary>
/// 同步接收数据
/// </summary>
/// <param name="receiveSegment"></param>
/// <param name="receivedAction"></param>
public void ReceiveSync(SegmentOffset receiveSegment, Action <SegmentOffset> receivedAction)
{
if (_channelProviderState != ChannelProviderType.Sync)
{
throw new Exception("需要使用同步连接...ConnectSync");
}
do
{
if (socket.Connected == false)
{
break;
}
var cnt = socket.Receive(receiveSegment.Buffer, receiveSegment.Size, 0);
if (cnt <= 0)
{
break;
}
receivedAction(receiveSegment);
} while (true);
}
public SegmentToken(SocketToken sToken, byte[] buffer, int offset, int size)
{
this.sToken = sToken;
this.Data = new SegmentOffset(buffer, offset, size);
}
public static void GetSegmentOffset(
Runtime rt,
out SegmentOffset segmentOffset)
{
segmentOffset = rt.segmentOffset;
}
public static void SetSegment(Runtime rt, SegmentOffset Segment)
{
rt.segmentOffset.Offset = Segment.Offset;
SetSegment(rt, Segment.Segment);
}
public Runtime(Runtime copy, SegmentOffset segOff) : this(copy)
{
SetSegment(this, segOff);
}
public bool Send(SegmentOffset dataSegment, IPEndPoint remoteEP, bool waiting = true)
{
return(socketSend.Send(dataSegment, remoteEP, waiting));
}
public int Send(SegmentOffset dataSegment)
{
return(TokenSocket.Send(dataSegment.Buffer,
dataSegment.Offset,
dataSegment.Size, 0));
}
public SegmentToken(SocketToken sToken, byte[] buffer)
{
this.sToken = sToken;
this.Data = new SegmentOffset(buffer);
}
public int SendSync(IPEndPoint remoteEP, SegmentOffset dataSegment)
{
return(socketSend.SendSync(dataSegment, remoteEP));
}
/// <summary>
/// 同步发送数据
/// </summary>
/// <param name="dataSegment"></param>
/// <param name="remoteEp"></param>
/// <returns></returns>
public int SendSync(SegmentOffset dataSegment, IPEndPoint remoteEp)
{
return(SocketVersion(remoteEp).SendTo(dataSegment.Buffer, dataSegment.Offset, dataSegment.Size,
SocketFlags.None, remoteEp));
}
public SegmentToken(SocketToken sToken, SegmentOffset data)
{
this.sToken = sToken;
this.Data = data;
}
