/// <summary>
/// 获取或者创建节点
/// </summary>
/// <param name="parser"></param>
private void getOrCreateNode(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if (index >= 0)
{
if (index >= array.Length)
{
array = array.copyNew(Math.Max(index + 1, array.Length << 1), array.Length);
}
if (array[index] == null)
{
nodeType node = nodeConstructor(this, ref parser);
array[index] = node;
parser.IsOperation = true;
if (index >= count)
{
count = index + 1;
}
}
parser.ReturnParameter.ReturnParameterSet(true);
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
/// <summary>
/// 设置数据
/// </summary>
/// <param name="parser"></param>
private void setValue(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if (index >= 0 && parser.LoadValueData() && parser.IsEnd)
{
if (parser.ValueData.Type == ValueData.Data <valueType> .DataType)
{
valueType value = ValueData.Data <valueType> .GetData(ref parser.ValueData);
if (index >= array.Length)
{
array = array.copyNew(Math.Max(index + 1, array.Length << 1), array.Length);
}
array[index] = value;
parser.IsOperation = true;
if (index >= count)
{
count = index + 1;
}
parser.ReturnParameter.ReturnParameterSet(true);
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
/// <summary>
/// 修改数据
/// </summary>
/// <param name="parser"></param>
private unsafe void update(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if ((uint)index < count)
{
byte *read = parser.Read;
if (parser.LoadValueData() && !parser.IsEnd)
{
valueType updateValue = ValueData.Data <valueType> .GetData(ref parser.ValueData);
if (parser.LoadValueData() && parser.ValueData.Type == ValueData.DataType.UInt)
{
valueType[] array = arrays[index >> FragmentArray.ArrayShift];
valueType value = array[index &= FragmentArray.ArraySizeAnd];
uint type = parser.ValueData.Int64.UInt;
OperationUpdater.LogicType logicType = (OperationUpdater.LogicType)(byte)(type >> 16);
if (logicType != OperationUpdater.LogicType.None && parser.LoadValueData() && parser.IsEnd)
{
if (OperationUpdater.Data <valueType> .IsLogicData(logicType, value, ValueData.Data <valueType> .GetData(ref parser.ValueData)))
{
logicType = OperationUpdater.LogicType.None;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.Success;
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, value);
return;
}
}
if (logicType == OperationUpdater.LogicType.None && parser.IsEnd)
{
switch (parser.ReturnParameter.ReturnType = OperationUpdater.Data <valueType> .UpdateData((OperationUpdater.OperationType)(ushort) type, ref value, updateValue))
{
case ReturnType.Success:
array[index] = value;
parser.UpdateOperation(read, value, OperationParameter.OperationType.SetValue);
goto SETDATA;
case ReturnType.Unknown:
parser.ReturnParameter.ReturnType = ReturnType.Success;
SETDATA:
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, value);
return;
}
return;
}
}
}
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if ((uint)index < count)
{
arrays[index >> FragmentArray.ArrayShift][index & FragmentArray.ArraySizeAnd] = default(valueType);
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
LinkNode <valueType> node = getNode(parser.GetValueData(int.MinValue));
if (node != null)
{
node.Remove(this);
--count;
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.LinkIndexOutOfRange;
}
}
/// <summary>
/// 获取并删除数据
/// </summary>
/// <param name="parser"></param>
private void getRemove(ref OperationParameter.NodeParser parser)
{
LinkNode <valueType> node = getNode(parser.GetValueData(int.MinValue));
if (node != null)
{
node.Remove(this);
--count;
parser.IsOperation = true;
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, node.Value);
parser.ReturnParameter.ReturnType = ReturnType.Success;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.LinkIndexOutOfRange;
}
}
/// <summary>
/// 获取下一个节点
/// </summary>
/// <param name="parser"></param>
/// <returns></returns>
private nodeType getNext(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if ((uint)index < count)
{
nodeType node = array[index];
if (node != null)
{
return(node);
}
parser.ReturnParameter.ReturnType = ReturnType.NullArrayNode;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
return(null);
}
/// <summary>
/// 删除节点
/// </summary>
/// <param name="parser"></param>
private void remove(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(-1);
if ((uint)index < count)
{
nodeType node = array[index];
if (node != null)
{
parser.IsOperation = true;
array[index] = null;
node.OnRemoved();
}
parser.ReturnParameter.ReturnParameterSet(true);
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(count); return;
case OperationParameter.OperationType.ContainsKey:
int index = parser.GetValueData(-1);
parser.ReturnParameter.ReturnParameterSet((uint)index < count && array[index] != null);
return;
case OperationParameter.OperationType.CreateShortPath:
nodeType node = getNext(ref parser);
if (node != null)
{
node.CreateShortPath(ref parser);
}
return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(count); return;
case OperationParameter.OperationType.GetValue:
int index = parser.GetValueData(-1);
if ((uint)index < count)
{
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, arrays[index >> FragmentArray.ArrayShift][index & FragmentArray.ArraySizeAnd]);
parser.ReturnParameter.ReturnType = ReturnType.Success;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="parser">参数解析</param>
internal override void QueryEnd(ref OperationParameter.NodeParser parser)
{
switch (parser.OperationType)
{
case OperationParameter.OperationType.GetCount: parser.ReturnParameter.ReturnParameterSet(count); return;
case OperationParameter.OperationType.GetValue:
LinkNode <valueType> node = getNode(parser.GetValueData(int.MinValue));
if (node != null)
{
ValueData.Data <valueType> .SetData(ref parser.ReturnParameter, node.Value);
parser.ReturnParameter.ReturnType = ReturnType.Success;
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.LinkIndexOutOfRange;
}
return;
}
parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError;
}
/// <summary>
/// 后置插入数据
/// </summary>
/// <param name="parser"></param>
private void insertAfter(ref OperationParameter.NodeParser parser)
{
int index = parser.GetValueData(int.MinValue);
LinkNode <valueType> node = getNode(index);
if (node != null)
{
if (parser.LoadValueData() && parser.IsEnd && parser.ValueData.Type == ValueData.Data <valueType> .DataType)
{
LinkNode <valueType> newNode = new LinkNode <valueType>(node, node.Next, ValueData.Data <valueType> .GetData(ref parser.ValueData));
if (node.InsertAfter(newNode))
{
end = newNode;
}
++count;
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
}
else if ((count | (index ^ -1)) == 0)
{
if (parser.LoadValueData() && parser.IsEnd && parser.ValueData.Type == ValueData.Data <valueType> .DataType)
{
setHeadEnd(ref parser, ValueData.Data <valueType> .GetData(ref parser.ValueData));
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.LinkIndexOutOfRange;
}
}
/// <summary>
/// 设置数据
/// </summary>
/// <param name="parser"></param>
private void setValue(ref OperationParameter.NodeParser parser)
{
int indexParameter = parser.GetValueData(-1);
if (indexParameter >= 0 && parser.LoadValueData() && parser.IsEnd)
{
if (parser.ValueData.Type == ValueData.Data <valueType> .DataType)
{
valueType value = ValueData.Data <valueType> .GetData(ref parser.ValueData);
int arrayIndex = indexParameter >> FragmentArray.ArrayShift;
if (arrayIndex >= arrays.Length)
{
valueType[][] newArrays = arrays.copyNew(arrayIndex + 1, arrays.Length);
for (int newIndex = arrays.Length; newIndex != newArrays.Length; newArrays[newIndex++] = new valueType[FragmentArray.ArraySize])
{
;
}
arrays = newArrays;
}
arrays[arrayIndex][indexParameter & FragmentArray.ArraySizeAnd] = value;
if (indexParameter >= count)
{
count = indexParameter + 1;
}
parser.SetOperationReturnParameter();
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ValueDataLoadError;
}
}
else
{
parser.ReturnParameter.ReturnType = ReturnType.ArrayIndexOutOfRange;
}
}
