public int Compare(NativeJaggedArraySlice <WordBlock> left,
NativeJaggedArraySlice <WordBlock> right)
{
int length = math.min(left.Length, right.Length);
for (int i = 0; i < length; i++)
{
var word_left = left[i];
var word_right = right[i];
if (word_left.type == WordType.Digit)
{
if (word_left.num < word_right.num)
{
return(-1);
}
if (word_left.num > word_right.num)
{
return(1);
}
}
}
if (left.Length > right.Length)
{
return(-1);
}
if (left.Length < right.Length)
{
return(1);
}
return(0);
}
private static bool CheckFormat(NativeList <WordBlock> reference, NativeJaggedArraySlice <WordBlock> target)
{
if (reference.Length != target.Length)
{
return(false);
}
for (int i = 0; i < reference.Length; i++)
{
var word_src = reference[i];
var word_tgt = target[i];
if (word_src.type != word_tgt.type)
{
return(false);
}
if (word_src.type == WordType.None)
{
return(false);
}
if (word_src.type == WordType.String)
{
if (word_src.word != word_tgt.word)
{
return(false);
}
}
}
return(true);
}
public NativeJaggedArraySlice(NativeJaggedArraySlice <T> slice)
{
_ptr = slice._ptr;
_len = slice._len;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
_gen_ptr = slice._gen_ptr;
_gen_entity = slice._gen_entity;
#endif
}
public static unsafe int IndexOf <T>(this NativeJaggedArraySlice <T> slice, T key, int start = 0)
where T : unmanaged, IEquatable <T>
{
slice.CheckReallocate();
slice.CheckElemIndex(start);
int _len = slice._len;
T * _ptr = slice._ptr;
for (int i = start; i < _len; i++)
{
if (_ptr[i].Equals(key))
{
return(i);
}
}
return(-1);
}
public int Compare(NativeJaggedArraySlice <WordBlock> left,
NativeJaggedArraySlice <WordBlock> right)
{
if (left.Length < 1 && right.Length < 1)
{
return(0);
}
if (left.Length < 1)
{
return(-1);
}
if (right.Length < 1)
{
return(1);
}
if (left[0].type != right[0].type)
{
if (left[0].type == WordType.Digit)
{
return(-1);
}
if (right[0].type == WordType.Digit)
{
return(1);
}
return(0);
}
int length = math.min(left.Length, right.Length);
for (int i = 0; i < length; i++)
{
var word_left = left[i];
var word_right = right[i];
if (word_left.type == WordType.Digit)
{
if (word_left.num < word_right.num)
{
return(-1);
}
if (word_left.num > word_right.num)
{
return(1);
}
}
else if (word_left.type == WordType.String)
{
int word_len = math.min(word_left.word.Length, word_right.word.Length);
for (int j = 0; j < word_len; j++)
{
Char16 c_left = word_left.word[j];
Char16 c_right = word_right.word[j];
if (c_left < c_right)
{
return(-1);
}
if (c_left > c_right)
{
return(1);
}
}
if (word_left.word.Length < word_right.word.Length)
{
return(-1);
}
if (word_left.word.Length > word_right.word.Length)
{
return(1);
}
}
}
if (left.Length < right.Length)
{
return(-1);
}
if (left.Length > right.Length)
{
return(1);
}
return(0);
}
public DecodedPath(NativeJaggedArraySlice <WordBlock> path, int index)
{
this.path = path;
this.index = index;
}
public ReadOnlyNativeJaggedArraySlice(T *ptr, int Length)
{
_slice = new NativeJaggedArraySlice <T>(ptr, Length);
}
public ReadOnlyNativeJaggedArraySlice(NativeJaggedArraySlice <T> slice)
{
_slice = slice;
}
public ReadOnlyNativeJaggedArraySlice(T *ptr, int Length, long *gen_ptr, long gen_entity)
{
_slice = new NativeJaggedArraySlice <T>(ptr, Length, gen_ptr, gen_entity);
}
public unsafe bool Equals(NativeJaggedArraySlice <Char16> slice)
{
return(_entity.Equals(slice));
}
public ReadOnlyStringEntity(NativeJaggedArraySlice <Char16> slice)
{
_entity = new StringEntity(slice);
}
public bool Equals(NativeJaggedArraySlice <Char16> slice)
{
this.CheckReallocate();
return(slice.Equals(_ptr, _len));
}
/// <summary>
/// specialize for NativeJaggedArraySlice<T>
/// </summary>
/// <param name="slice"></param>
public unsafe void Add(NativeJaggedArraySlice <T> slice)
{
this.Add((T *)slice.GetUnsafePtr(), slice.Length);
}
