/// <summary>
/// Return a tree that contains right trapezoid and 2 left trapezoids
/// </summary>
/// <param name="segment"></param>
/// <returns></returns>
public Node To3TrapsRight_2Left(Segment segment)
{
// Vertex node
Node root = new VertexNode(segment.RightVertex);
// Segment node
Node segmentNode = new SegmentNode(segment);
// Trapezoid nodes
Trapezoid higherTrap = new Trapezoid(segment.LeftVertex, segment.RightVertex, Trapezoid.Top, segment);
Trapezoid lowerTrap = new Trapezoid(segment.LeftVertex, segment.RightVertex, segment, Trapezoid.Bottom);
Trapezoid rightTrap = new Trapezoid(segment.RightVertex, Trapezoid.Rightp, Trapezoid.Top, Trapezoid.Bottom);
Node higherTrapNode = new TrapezoidalNode(higherTrap);
Node lowerTrapNode = new TrapezoidalNode(higherTrap);
Node rightTrapNode = new TrapezoidalNode(rightTrap);
higherTrap.SetNeighbor(null, null, rightTrap, rightTrap);
higherTrap.Node = higherTrapNode;
lowerTrap.SetNeighbor(null, null, rightTrap, rightTrap);
lowerTrap.Node = lowerTrapNode;
rightTrap.SetNeighbor(higherTrap, lowerTrap, Trapezoid.HigherRightNeighbor, Trapezoid.LowerRightNeighbor);
rightTrap.Node = rightTrapNode;
segmentNode.SetChildren(ref higherTrapNode, ref lowerTrapNode);
root.SetChildren(ref segmentNode, ref rightTrapNode);
return(root);
}
public void FirstTestName()
{
var route = new RouteNode <Uri>(new StubRoute <Uri>());
var joinNode = new JoinNode <Uri>(_id++, new ConstantNode <Uri>());
joinNode.Add(route);
var alpha = new AlphaNode <Uri>(_id++);
alpha.Add(joinNode);
var equal = new EqualNode <Uri>(() => _id++);
equal.Add("version", alpha);
var segment = new SegmentNode <Uri>(1);
segment.Add(equal);
var engine = new MagnumRoutingEngine <Uri>(x => x);
engine.Match <RootNode <Uri> >().Single().Add(segment);
bool called = false;
var uri = new Uri("http://localhost/version");
engine.Route(uri, x =>
{
called = true;
});
called.ShouldBeTrue();
}
public void RemoveEndCapAtEnd()
{
SegmentNode node = _segmentNodes[_segmentNodes.Count - 1];
node.hasEndCap = false;
RemoveMeshEndCap(node);
}
/// <summary>
/// 检查当前的包的可用总长度
/// </summary>
/// <param name="node">当前数据段节点</param>
/// <returns>返回可用的下一个消息总长度</returns>
private unsafe int CheckBytes(SegmentNode node)
{
int headOffset = 0;
SegmentNode nextNode;
if (node.RemainingSize >= 4)
{
return(BitConverter.ToInt32(node.Args.GetStub().Segment.Segment.Array, node.Args.GetStub().Segment.UsedOffset));
}
byte *head = stackalloc byte[4];
nextNode = node;
while (headOffset < 3)
{
fixed(byte *pData = &nextNode.Args.GetStub().Segment.Segment.Array[nextNode.Args.GetStub().Segment.UsedOffset])
{
for (int i = 0; i < nextNode.RemainingSize && headOffset < 4; i++)
{
head[headOffset++] = *(pData + i);
}
}
nextNode = nextNode.Next;
if (headOffset > 3)
{
break;
}
if (nextNode == null)
{
return(-1);
}
}
return(*(int *)head);
}
public void Remove(SegmentNode <TRequest, TResponse> segmentTree, Endpoint endpoint)
{
var targetNode = FindNodeByRoute(segmentTree, endpoint.Route);
targetNode?.HandleRequestFunctions?.Remove(endpoint.Method);
RemoveUnusedNodes(segmentTree, () => { });
}
public void AddEndCap(int strokePointIndex)
{
SegmentNode node = _segmentNodes[strokePointIndex];
node.hasEndCap = true;
AddMeshEndCap(node);
}
public void FirstTestName()
{
var route = new RouteNode<Uri>(new StubRoute<Uri>());
var joinNode = new JoinNode<Uri>(_id++, new ConstantNode<Uri>());
joinNode.Add(route);
var alpha = new AlphaNode<Uri>(_id++);
alpha.Add(joinNode);
var equal = new EqualNode<Uri>(() => _id++);
equal.Add("version", alpha);
var segment = new SegmentNode<Uri>(1);
segment.Add(equal);
var engine = new MagnumRoutingEngine<Uri>(x => x);
engine.Match<RootNode<Uri>>().Single().Add(segment);
bool called = false;
var uri = new Uri("http://localhost/version");
engine.Route(uri, x =>
{
called = true;
});
called.ShouldBeTrue();
}
/// <summary>
/// 尝试读取一段字节数组类型的数据
/// </summary>
/// <param name="encoding">解析字符串所使用的编码集</param>
/// <param name="length">需要读取的数据长度</param>
/// <param name="data">如果返回True, 则这个字段携带了读取成功的数据</param>
/// <returns>返回一个值，该值标示了当前是否读取成功。如果返回False, 则证明内部还没有足够的可用数据以供读取</returns>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
/// <exception cref="IncorrectCalculationException">内部错误，应该终止业务程序</exception>
public bool TryReadString(Encoding encoding, int length, out string data)
{
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
int expectedDataLength = length;
data = null;
NetworkDataCheckResult chkResult;
if (!InnerCheckEnoughSize(expectedDataLength, out chkResult))
{
return(false);
}
if (chkResult.SegmentCount == 1)
{
SegmentNode node = _curUsedHead;
data = encoding.GetString(node.Args.GetStub().Segment.Segment.Array, (node.Args.GetStub().Segment.UsedOffset + _curUsedCount), expectedDataLength);
_curUsedCount += expectedDataLength;
ReCalculateCurrentUsedSegment();
return(true);
}
byte[] rawData;
if (!TryReadBinaryData(length, out rawData))
{
throw new IncorrectCalculationException("#Incorrectly calculated internal network data offset.");
}
data = encoding.GetString(rawData, 0, rawData.Length);
return(true);
}
/// <summary>
/// Return a tree that contains left trapezoid and 2 right trapezoids
/// </summary>
/// <param name="segment"></param>
/// <returns></returns>
public Node To3TrapsLeft_2Right(Segment segment)
{
// Vertex node
Node root = new VertexNode(segment.LeftVertex);
// Segment node
Node segmentNode = new SegmentNode(segment);
// Trapezoid nodes
Trapezoid leftTrap = new Trapezoid(Trapezoid.Leftp, segment.LeftVertex, Trapezoid.Top, Trapezoid.Bottom);
Trapezoid higherTrap = new Trapezoid(segment.LeftVertex, segment.RightVertex, Trapezoid.Top, segment);
Trapezoid lowerTrap = new Trapezoid(segment.LeftVertex, segment.RightVertex, segment, Trapezoid.Bottom);
Node higherTrapNode = new TrapezoidalNode(higherTrap);
Node lowerTrapNode = new TrapezoidalNode(lowerTrap);
Node leftTrapNode = new TrapezoidalNode(leftTrap);
higherTrap.SetNeighbor(leftTrap, leftTrap, null, null);
higherTrap.Node = higherTrapNode;
lowerTrap.SetNeighbor(leftTrap, leftTrap, null, null);
lowerTrap.Node = lowerTrapNode;
leftTrap.SetNeighbor(Trapezoid.HigherLeftNeighbor, Trapezoid.LowerLeftNeighbor, higherTrap, lowerTrap);
leftTrap.Node = leftTrapNode;
segmentNode.SetChildren(ref higherTrapNode, ref lowerTrapNode);
root.SetChildren(ref leftTrapNode, ref segmentNode);
return(root);
}
/// <summary>
/// 尝试检查当前剩余的可用数据长度是否满足指定数据长度的需求
/// </summary>
/// <param name="length">需要检查的数据长度</param>
/// <param name="result">返回数据检测结果</param>
/// <returns>如果返回False, 则证明内部还没有足够的可用数据以供读取</returns>
private bool InnerCheckEnoughSize(int length, out NetworkDataCheckResult result)
{
result.SegmentCount = 0;
if (_curUsedHead == null)
{
return(false);
}
int avaSize = _curUsedHead.RemainingSize - _curUsedCount;
if (avaSize >= length)
{
result.SegmentCount = 1;
return(true);
}
result.SegmentCount++;
SegmentNode usedNode = _curUsedHead;
SegmentNode nextNode = usedNode.Next;
do
{
if (nextNode == null)
{
return(false);
}
avaSize += nextNode.RemainingSize;
result.SegmentCount++;
if (avaSize >= length)
{
return(true);
}
} while ((nextNode = nextNode.Next) != null);
return(false);
}
private static SegmentNode <TRequest, TResponse>?FindSegmentInNode(SegmentNode <TRequest, TResponse>?node, ISegmentVariant segment)
{
return(segment switch
{
Root _ => node,
Literal literal => FindSegmentInNodeList(node?.LiteralChildren, literal),
Parameter parameter => FindSegmentInNodeList(node?.ParameterChildren, parameter),
_ => throw new InvalidOperationException()
});
private void AddCrossSectionVerts(SegmentNode node)
{
node.hasCrossSectionVerts = true;
node.crossSectionVertsIdx = _meshVerts.Count;
for (int i = 0; i < _crossSectionVerts.Length; i++)
{
_meshVerts.Add(node.GetVertAt(i));
}
}
private static void RegisterRequestHandler(
SegmentNode <TRequest, TResponse> segmentTree,
Endpoint endpoint,
HandleRequest <TRequest, TResponse> handleRequest,
IEnumerable <ISegmentVariant> segments)
{
var targetNode = FindTargetNode(segmentTree, segments);
RegisterRequestHandlerOnNode(endpoint, handleRequest, targetNode);
}
public override bool Equals(object obj)
{
SegmentNode objSegNode = (SegmentNode)obj;
if (!segment.Equals(objSegNode.segment))
{
return(false);
}
return(base.Equals(obj));
}
Match(
SegmentNode <TRequest, TResponse> node,
HttpMethod method,
ICollection <string> segments,
IDictionary <string, string> parameters)
{
var head = segments.First();
var currentParameters = node.Matcher is Parameter {
Key : var key
}
public void Register(
SegmentNode <TRequest, TResponse> segmentTree,
Endpoint endpoint,
HandleRequest <TRequest, TResponse> handleRequest,
ValidateParameterKeys validateParameterKeys)
{
var segments = ParseRoute(endpoint).ToList();
RunParameterKeyValidation(validateParameterKeys, segments);
RegisterRequestHandler(segmentTree, endpoint, handleRequest, segments);
}
private void ConnectCrossSectionVerts(SegmentNode nodeA, SegmentNode nodeB)
{
for (int i = 0; i < _crossSectionVerts.Length; i++)
{
int v_a0 = nodeA.GetCrossSectionVertIdx(i + 0), v_a1 = nodeA.GetCrossSectionVertIdx(i + 1);
int v_b0 = nodeB.GetCrossSectionVertIdx(i + 0), v_b1 = nodeB.GetCrossSectionVertIdx(i + 1);
AddTri(v_a0, v_a1, v_b0);
AddTri(v_a1, v_b1, v_b0);
}
}
private void RefreshMeshVerts(SegmentNode node, bool uploadImmediately = true)
{
for (int i = 0; i < node.CrossSectionVertsCount; i++)
{
_meshVerts[node.crossSectionVertsIdx + i] = node.GetVertAt(i);
}
if (uploadImmediately)
{
UploadMeshData();
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
public void Dispose()
{
//give back all segments.
while (_head != null)
{
//giveup current fixed stub.
_head.Args.Complete();
_head = _head.Next;
}
//release the end of segment ref.
_tail = null;
}
public void Given_an_existing_segment_condition()
{
_engine = new MagnumRoutingEngine<Uri>(x => x);
var segmentNode = new SegmentNode<Uri>(1);
var equals = new EqualNode<Uri>(() => _id++);
equals.Add("version", new AlphaNode<Uri>(_id++));
segmentNode.Add(equals);
_engine.Add(segmentNode);
}
public void AddPoint(StrokePoint strokePoint)
{
SegmentNode node = new SegmentNode(strokePoint, this);
_segmentNodes.Add(node);
if (_segmentNodes.Count > 1)
{
node.prevNode = _segmentNodes[_segmentNodes.Count - 2];
node.prevNode.nextNode = node;
AddMeshSegment(node.prevNode, node);
}
}
public RoutingEngineRoutingRunner()
{
_idGenerator = new SequentialNodeIdGenerator();
_engine = new MagnumRoutingEngine <Uri>(x => x);
_segment = new SegmentNode <Uri>(1);
_engine.Match <RootNode <Uri> >().Single().Add(_segment);
_equal = new EqualNode <Uri>(() => _id++);
_segment.Add(_equal);
}
public RoutingEngineRoutingRunner()
{
_idGenerator = new SequentialNodeIdGenerator();
_engine = new MagnumRoutingEngine<Uri>(x => x);
_segment = new SegmentNode<Uri>(1);
_engine.Match<RootNode<Uri>>().Single().Add(_segment);
_equal = new EqualNode<Uri>(() => _id++);
_segment.Add(_equal);
}
public void Given_an_existing_segment_condition()
{
_engine = new MagnumRoutingEngine <Uri>(x => x);
var segmentNode = new SegmentNode <Uri>(1);
var equals = new EqualNode <Uri>(() => _id++);
equals.Add("version", new AlphaNode <Uri>(_id++));
segmentNode.Add(equals);
_engine.Add(segmentNode);
}
private static void RemoveUnusedNodes(SegmentNode <TRequest, TResponse> node, Action removeFromParent)
{
bool HasParameterChildren() => node.ParameterChildren.Any();
bool HasLiteralChildren() => node.LiteralChildren.Any();
bool HasHandlersRegistered() => node.HandleRequestFunctions.Any();
bool IsNodeUsed() => HasHandlersRegistered() || HasLiteralChildren() || HasParameterChildren();
RemoveUnusedChildNodes(node.ParameterChildren);
RemoveUnusedChildNodes(node.LiteralChildren);
if (!IsNodeUsed())
{
removeFromParent();
}
}
private void AddMeshSegment(SegmentNode node1, SegmentNode node2)
{
if (!node1.hasCrossSectionVerts)
{
AddCrossSectionVerts(node1);
}
if (!node2.hasCrossSectionVerts)
{
AddCrossSectionVerts(node2);
}
ConnectCrossSectionVerts(node1, node2);
UploadMeshData();
}
public TResponse Route(SegmentNode <TRequest, TResponse> segmentTree, Endpoint endpoint, TRequest request)
{
var segments = _pathParser.Parse(endpoint.Route)?.ToList();
if (segments is null)
{
return(_handleFallbackRequest(request));
}
var requestHandlingData = Match(segmentTree, endpoint.Method, segments, new Dictionary <string, string>());
return(requestHandlingData is null
? _handleFallbackRequest(request)
: requestHandlingData(request));
}
/// <summary>
/// Return a tree that contains 2 trapezoids
/// </summary>
/// <param name="segment"></param>
/// <returns></returns>
public Node To2Traps(Segment segment)
{
// Segment node
Node root = new SegmentNode(segment);
// Trapezoid nodes
Trapezoid higherTrap = new Trapezoid(null, null, Trapezoid.Top, segment);
Trapezoid lowerTrap = new Trapezoid(null, null, segment, Trapezoid.Bottom);
Node higherTrapNode = new TrapezoidalNode(higherTrap);
Node lowerTrapNode = new TrapezoidalNode(lowerTrap);
root.SetChildren(ref higherTrapNode, ref lowerTrapNode);
return(root);
}
/// <summary>
/// Return a tree that contains 2 trapezoids
/// </summary>
/// <param name="segment"></param>
/// <returns></returns>
public Node To2Traps(Segment segment)
{
// Segment node
Node root = new SegmentNode(segment);
// Trapezoid nodes
Trapezoid higherTrap = new Trapezoid(null, null, Trapezoid.Top, segment);
Trapezoid lowerTrap = new Trapezoid(null, null, segment, Trapezoid.Bottom);
Node higherTrapNode = new TrapezoidalNode(higherTrap);
Node lowerTrapNode = new TrapezoidalNode(lowerTrap);
root.SetChildren(ref higherTrapNode, ref lowerTrapNode);
return root;
}
/// <summary>
/// 尝试读取一段字节数组类型的数据
/// </summary>
/// <param name="length">需要读取的数据长度</param>
/// <param name="data">如果返回True, 则这个字段携带了读取成功的数据</param>
/// <returns>返回一个值，该值标示了当前是否读取成功。如果返回False, 则证明内部还没有足够的可用数据以供读取</returns>
public bool TryReadBinaryData(int length, out byte[] data)
{
int expectedDataLength = length;
data = null;
NetworkDataCheckResult chkResult;
if (!InnerCheckEnoughSize(expectedDataLength, out chkResult))
{
return(false);
}
if (chkResult.SegmentCount == 1)
{
SegmentNode node = _curUsedHead;
data = new byte[length];
Buffer.BlockCopy(node.Args.GetStub().Segment.Segment.Array, (node.Args.GetStub().Segment.UsedOffset + _curUsedCount), data, 0, length);
_curUsedCount += expectedDataLength;
ReCalculateCurrentUsedSegment();
return(true);
}
/* Specially optimized for value type.
* What we expected is DO NOT to generates a new byte[] for undertaking those of 2 bytes data.
*
* remaining only 1 byte data next available data start here
* ↓ ↓
* ********************z zzzzzzzzzz***********
* Segment(1) Segment(2)
*/
int offset = 0;
int remainingDataLength = expectedDataLength;
data = new byte[length];
for (int i = 0; i < chkResult.SegmentCount; i++)
{
int segmentRemainingSize = _curUsedHead.Args.BytesTransferred - _curUsedCount;
int remainingSize = (segmentRemainingSize > remainingDataLength ? remainingDataLength : segmentRemainingSize);
Buffer.BlockCopy(_curUsedHead.Args.GetStub().Segment.Segment.Array, (_curUsedHead.Args.GetStub().Segment.UsedOffset + _curUsedCount), data, offset, remainingSize);
_curUsedCount += remainingSize;
offset += remainingSize;
remainingDataLength -= remainingSize;
ReCalculateCurrentUsedSegment();
}
return(true);
}
/// <summary>
/// 尝试读取一个字节的数据
/// </summary>
/// <param name="data">如果返回True, 则这个字段携带了读取成功的数据</param>
/// <returns>返回一个值，该值标示了当前是否读取成功。如果返回False, 则证明内部还没有足够的可用数据以供读取</returns>
/// <exception cref="IncorrectCalculationException">内部错误，应该终止业务程序</exception>
public bool TryReadByte(out byte data)
{
data = 0xFF;
NetworkDataCheckResult chkResult;
if (!InnerCheckEnoughSize(1, out chkResult))
{
return(false);
}
if (chkResult.SegmentCount != 1)
{
throw new IncorrectCalculationException("#Incorrectly calculated internal network data offset.");
}
SegmentNode node = _curUsedHead;
data = node.Args.GetStub().Segment.Segment.Array[node.Args.GetStub().Segment.UsedOffset + _curUsedCount++];
ReCalculateCurrentUsedSegment();
return(true);
}
/// <summary>
/// 尝试读取一个Int64类型的数据
/// </summary>
/// <param name="data">如果返回True, 则这个字段携带了读取成功的数据</param>
/// <returns>返回一个值，该值标示了当前是否读取成功。如果返回False, 则证明内部还没有足够的可用数据以供读取</returns>
public unsafe bool TryReadInt64(out long data)
{
const int expectedDataLength = 8;
data = 0xFF;
NetworkDataCheckResult chkResult;
if (!InnerCheckEnoughSize(expectedDataLength, out chkResult))
{
return(false);
}
if (chkResult.SegmentCount == 1)
{
SegmentNode node = _curUsedHead;
fixed(byte *pData = node.Args.GetStub().Segment.Segment.Array)
{
data = *(long *)(pData + node.Args.GetStub().Segment.UsedOffset + _curUsedCount);
_curUsedCount += expectedDataLength;
ReCalculateCurrentUsedSegment();
return(true);
}
}
/* Specially optimized for value type.
* What we expected is DO NOT to generates a new byte[] for undertaking those of 2 bytes data.
*
* remaining only 1 byte data next available data start here
* ↓ ↓
* ********************z zzzzzzz**************
* Segment(1) Segment(2)
*/
byte *tmpData = stackalloc byte[expectedDataLength];
FillCrossSegmentData(tmpData, expectedDataLength);
data = *(long *)tmpData;
return(true);
}
/// <summary>
/// Return a tree that contains 4 trapezoids
/// </summary>
/// <param name="segment"></param>
/// <returns></returns>
public Node To4Traps(Segment segment)
{
// Vertex nodes
Node root = new VertexNode(segment.LeftVertex);
Node rightVertexNode = new VertexNode(segment.RightVertex);
// Segment node
Node segmentNode = new SegmentNode(segment);
// Trapezoid nodes
Trapezoid leftTrap = new Trapezoid(Trapezoid.Leftp, segment.LeftVertex, Trapezoid.Top, Trapezoid.Bottom);
Trapezoid higherCenterTrap = new Trapezoid(segment.LeftVertex, segment.RightVertex, Trapezoid.Top, segment);
Trapezoid lowerCenterTrap = new Trapezoid(segment.LeftVertex, segment.RightVertex, segment, Trapezoid.Bottom);
Trapezoid rightTrap = new Trapezoid(segment.RightVertex, Trapezoid.Rightp, Trapezoid.Top, Trapezoid.Bottom);
Node leftTrapNode = new TrapezoidalNode(leftTrap);
Node higherCenterTrapNode = new TrapezoidalNode(higherCenterTrap);
Node lowerCenterTrapNode = new TrapezoidalNode(lowerCenterTrap);
Node rightTrapNode = new TrapezoidalNode(rightTrap);
leftTrap.SetNeighbor(Trapezoid.HigherLeftNeighbor, Trapezoid.LowerLeftNeighbor, higherCenterTrap, lowerCenterTrap);
leftTrap.Node = leftTrapNode;
higherCenterTrap.SetNeighbor(leftTrap, leftTrap, rightTrap, rightTrap);
higherCenterTrap.Node = higherCenterTrapNode;
lowerCenterTrap.SetNeighbor(leftTrap, leftTrap, rightTrap, rightTrap);
lowerCenterTrap.Node = lowerCenterTrapNode;
rightTrap.SetNeighbor(higherCenterTrap, lowerCenterTrap, Trapezoid.HigherRightNeighbor, Trapezoid.LowerRightNeighbor);
rightTrap.Node = rightTrapNode;
segmentNode.SetChildren(ref higherCenterTrapNode, ref lowerCenterTrapNode);
rightVertexNode.SetChildren(ref segmentNode, ref rightTrapNode);
root.SetChildren(ref leftTrapNode,ref rightVertexNode);
return root;
}
/// <summary>
/// 追加一个新的数据段
/// </summary>
/// <param name="args">数据段接受参数</param>
public void Append(SegmentReceiveEventArgs args)
{
#region Step 1, check-on args.
if (_head == null)
{
_head = _tail = new SegmentNode(args);
}
else
{
_tail.Next = new SegmentNode(args);
_tail = _tail.Next;
}
#endregion
#region Step 2, check bytes enough & pickup data.
int msgSize;
//RESET next node for current expression.
SegmentNode nextNode = _head;
List <T> msgs = new List <T>();
//check whatever bytes can be parse.
while (nextNode != null && (msgSize = CheckBytes(nextNode)) > 0)
{
//direct parse.
if (nextNode.RemainingSize >= msgSize)
{
List <T> list = _protocolStack.Parse <T>(nextNode.Args.GetStub().Segment.Segment.Array, nextNode.Args.GetStub().Segment.UsedOffset, msgSize);
if (list != null)
{
msgs.AddRange(list);
}
nextNode.Args.GetStub().Segment.UsedBytes += msgSize;
//ChannelCounter.Instance.RateOfDirectParse.Increment();
if (nextNode.RemainingSize > 0)
{
continue;
}
//giveup current fixed stub.
nextNode.Args.Complete();
_head = nextNode = nextNode.Next;
if (_head != null)
{
continue;
}
//Tail node must be null, if the head node has no value.
_tail = null;
//publish messages.
if (msgs.Count > 0)
{
ParseSucceedHandler(new LightSingleArgEventArgs <List <T> >(msgs));
}
return;
}
//create sub-list for all ava-data segment path.
int remainingSize = msgSize - nextNode.RemainingSize;
SegmentNode childHead = (SegmentNode)nextNode.Clone();
SegmentNode childTail = (SegmentNode)nextNode.Clone();
SegmentNode tempNode = nextNode;
SegmentNode lastRealNode = null;
SegmentNode cloneLastRealNode = null;
do
{
tempNode = tempNode.Next;
if (tempNode == null)
{
break;
}
remainingSize -= tempNode.RemainingSize;
//clone target node for child-list.
lastRealNode = tempNode;
SegmentNode cloneNode = (SegmentNode)tempNode.Clone();
cloneNode.Next = null;
childTail.Next = cloneNode;
childTail = childTail.Next;
} while (remainingSize > 0);
//cannot get enough length for message really binary data.
if (remainingSize > 0)
{
if (msgs.Count > 0)
{
ParseSucceedHandler(new LightSingleArgEventArgs <List <T> >(msgs));
}
return;
}
//copy data from child-list!
int dataOffset = 0;
byte[] data = new byte[msgSize];
int dataRemainingCount = data.Length;
int usedBytes;
int lastUserBytes = 0;
while (childHead != null && dataRemainingCount > 0)
{
cloneLastRealNode = childHead;
Buffer.BlockCopy(childHead.Args.GetStub().Segment.Segment.Array,
childHead.Args.GetStub().Segment.UsedOffset, data, dataOffset,
(usedBytes = (childHead.RemainingSize > dataRemainingCount
? dataRemainingCount
: childHead.RemainingSize)));
dataOffset += usedBytes;
dataRemainingCount -= usedBytes;
childHead.Args.GetStub().Segment.UsedBytes += usedBytes;
lastUserBytes = childHead.Args.GetStub().Segment.UsedBytes;
if (childHead.RemainingSize <= 0)
{
//giveup current fixed stub.
childHead.Args.Complete();
childHead = childHead.Next;
}
}
if (cloneLastRealNode.RemainingSize - lastUserBytes == 0 && lastRealNode.Next == null)
{
_head = nextNode = null;
}
else if (cloneLastRealNode.RemainingSize - lastUserBytes == 0 && lastRealNode.Next != null)
{
_head = nextNode = lastRealNode.Next;
}
else
{
lastRealNode.Args.GetStub().Segment.UsedBytes = lastUserBytes;
_head = nextNode = lastRealNode;
}
//_head = nextNode = ((cloneLastRealNode.RemainingSize == 0 && lastRealNode.Next == null) ? null : lastRealNode);
List <T> list1 = _protocolStack.Parse <T>(data);
if (list1 != null)
{
msgs.AddRange(list1);
}
}
//publish messages.
if (msgs.Count > 0)
{
ParseSucceedHandler(new LightSingleArgEventArgs <List <T> >(msgs));
}
#endregion
}
public LineNode(SegmentNode node, Location locForward, Location locBackward)
{
_node = node;
_location[Forward] = locForward;
_location[Backward] = locBackward;
}