mirror of
https://github.com/gnosygnu/xowa.git
synced 2026-03-02 03:49:30 +00:00
v2.9.1.1
This commit is contained in:
@@ -37,7 +37,7 @@ public class Err extends RuntimeException {
|
||||
if (msgs_idx == msgs_len) {
|
||||
int new_len = msgs_len * 2;
|
||||
Err_msg[] new_ary = new Err_msg[new_len];
|
||||
Array_.CopyTo(msgs_ary, new_ary, 0);
|
||||
Array_.Copy_to(msgs_ary, new_ary, 0);
|
||||
this.msgs_ary = new_ary;
|
||||
this.msgs_len = new_len;
|
||||
}
|
||||
|
||||
@@ -63,7 +63,7 @@ public class Regx_adp__tst implements TfdsEqListItmStr {
|
||||
Regx_match match_(int bgn) {return match_(bgn, Int_.Min_value);}
|
||||
Regx_match match_(int bgn, int len) {return new Regx_match(true, bgn, bgn + len, Regx_group.Ary_empty);}
|
||||
void tst_Matches(String find, String input, Regx_match... expd) {
|
||||
List_adp expdList = Array_.XtoList(expd);
|
||||
List_adp expdList = Array_.To_list(expd);
|
||||
List_adp actlList = Regx_adp_.Find_all(input, find);
|
||||
Tfds.Eq_list(expdList, actlList, this);
|
||||
}
|
||||
|
||||
@@ -32,8 +32,8 @@ public class Byte_ {
|
||||
catch (Exception e) {Err_.Noop(e); return or;}
|
||||
}
|
||||
public static byte By_int(int v) {return v > 127 ? (byte)(v - 256) : (byte)v;} // PERF?: (byte)(v & 0xff)
|
||||
public static int Xto_int(byte v) {return v < 0 ? (int)v + 256 : v;}
|
||||
public static String Xto_str(byte v) {return new Byte(v).toString();}
|
||||
public static int To_int(byte v) {return v < 0 ? (int)v + 256 : v;}
|
||||
public static String To_str(byte v) {return new Byte(v).toString();}
|
||||
public static boolean In(byte v, byte... ary) {
|
||||
for (byte itm : ary)
|
||||
if (v == itm) return true;
|
||||
|
||||
@@ -31,5 +31,5 @@ public class Byte__tst {
|
||||
tst_XtoInt( 128, 128);
|
||||
tst_XtoInt( 255, 255);
|
||||
tst_XtoInt( 256, 0);
|
||||
} void tst_XtoInt(int v, int expd) {Tfds.Eq(expd, Byte_.Xto_int((byte)v));} // WORKAROUND/JAVA: v is of type int b/c java promotes numbers to ints
|
||||
} void tst_XtoInt(int v, int expd) {Tfds.Eq(expd, Byte_.To_int((byte)v));} // WORKAROUND/JAVA: v is of type int b/c java promotes numbers to ints
|
||||
}
|
||||
|
||||
@@ -22,16 +22,9 @@ public class Array_ {
|
||||
public static Object cast(Object o) {return (Object)o;}
|
||||
public static void Sort(Object[] obj) {List_adp_sorter.new_().Sort(obj, obj.length);}
|
||||
public static void Sort(Object[] obj, gplx.lists.ComparerAble comparer) {List_adp_sorter.new_().Sort(obj, obj.length, true, comparer);}
|
||||
public static List_adp XtoList(Object ary) {
|
||||
int aryLen = Array_.Len(ary);
|
||||
List_adp rv = List_adp_.new_();
|
||||
for (int i = 0; i < aryLen; i++)
|
||||
rv.Add(Array_.Get(ary, i));
|
||||
return rv;
|
||||
}
|
||||
public static Object[] Insert(Object[] cur, Object[] add, int addPos) {
|
||||
int curLen = cur.length, addLen = add.length;
|
||||
Object[] rv = (Object[])Array_.Create(Array_.ComponentType(cur), curLen + addLen);
|
||||
Object[] rv = (Object[])Array_.Create(Array_.Component_type(cur), curLen + addLen);
|
||||
for (int i = 0; i < addPos; i++) // copy old up to addPos
|
||||
rv[i] = cur[i];
|
||||
for (int i = 0; i < addLen; i++) // insert add
|
||||
@@ -40,9 +33,9 @@ public class Array_ {
|
||||
rv[i + addLen] = cur[i];
|
||||
return rv;
|
||||
}
|
||||
public static Object[] ReplaceInsert(Object[] cur, Object[] add, int curReplacePos, int addInsertPos) {
|
||||
public static Object[] Replace_insert(Object[] cur, Object[] add, int curReplacePos, int addInsertPos) {
|
||||
int curLen = cur.length, addLen = add.length; int newLen = addLen - addInsertPos;
|
||||
Object[] rv = (Object[])Array_.Create(Array_.ComponentType(cur), curLen + newLen);
|
||||
Object[] rv = (Object[])Array_.Create(Array_.Component_type(cur), curLen + newLen);
|
||||
for (int i = 0; i < curReplacePos; i++) // copy old up to curInsertPos; EX: curReplacePos=5, addInsertPos=2; copy up to element 3; 4, 5 are dropped
|
||||
rv[i] = cur[i];
|
||||
for (int i = 0; i < addLen; i++) // insert add
|
||||
@@ -53,48 +46,72 @@ public class Array_ {
|
||||
}
|
||||
public static Object Resize_add_one(Object src, int src_len, Object new_obj) {
|
||||
Object rv = Resize(src, src_len + 1);
|
||||
Set(rv, src_len, new_obj);
|
||||
Set_at(rv, src_len, new_obj);
|
||||
return rv;
|
||||
}
|
||||
public static Object Resize(Object src, int trg_len) {
|
||||
Object trg = Create(ComponentType(src), trg_len);
|
||||
Object trg = Create(Component_type(src), trg_len);
|
||||
int src_len = Array.getLength(src);
|
||||
int copy_len = src_len > trg_len ? trg_len : src_len; // trg_len can either expand or shrink
|
||||
CopyTo(src, 0, trg, 0, copy_len);
|
||||
Copy_to(src, 0, trg, 0, copy_len);
|
||||
return trg;
|
||||
}
|
||||
public static List_adp To_list(Object ary) {
|
||||
int aryLen = Array_.Len(ary);
|
||||
List_adp rv = List_adp_.new_();
|
||||
for (int i = 0; i < aryLen; i++)
|
||||
rv.Add(Array_.Get_at(ary, i));
|
||||
return rv;
|
||||
}
|
||||
public static String To_str_nested_obj(Object o) {
|
||||
Bry_bfr bfr = Bry_bfr.new_();
|
||||
To_str_nested_ary(bfr, (Object)o, 0);
|
||||
return bfr.Xto_str_and_clear();
|
||||
}
|
||||
private static void To_str_nested_ary(Bry_bfr bfr, Object ary, int indent) {
|
||||
int len = Len(ary);
|
||||
for (int i = 0; i < len; i++) {
|
||||
Object itm = Get_at(ary, i);
|
||||
if (itm != null && Type_adp_.Is_array(itm.getClass()))
|
||||
To_str_nested_ary(bfr, (Object)itm, indent + 1);
|
||||
else {
|
||||
if (indent > 0) bfr.Add_byte_repeat(Byte_ascii.Space, indent * 2);
|
||||
bfr.Add_str_u8(Object_.Xto_str_strict_or_null_mark(itm)).Add_byte_nl();
|
||||
}
|
||||
}
|
||||
}
|
||||
public static String To_str_obj(Object o) {return To_str((Object)o);}
|
||||
public static String To_str(Object ary) {
|
||||
String_bldr sb = String_bldr_.new_();
|
||||
int ary_len = Len(ary);
|
||||
for (int i = 0; i < ary_len; i++)
|
||||
sb.Add_obj(Get(ary, i)).Add_char_nl();
|
||||
sb.Add_obj(Get_at(ary, i)).Add_char_nl();
|
||||
return sb.To_str();
|
||||
}
|
||||
public static int Len(Object ary) {return Array.getLength(ary);}
|
||||
public static final int LenAry(Object[] ary) {return ary == null ? 0 : ary.length;}
|
||||
public static Object Get_at(Object ary, int i) {return Array.get(ary, i); }
|
||||
public static final int Len_obj(Object[] ary) {return ary == null ? 0 : ary.length;}
|
||||
public static Object Get_at(Object ary, int i) {return Array.get(ary, i);}
|
||||
public static void Set_at(Object ary, int i, Object o) {Array.set(ary, i, o);}
|
||||
public static Object Create(Class<?> t, int count) {return Array.newInstance(t, count);}
|
||||
public static Object Get(Object ary, int i) {return Array.get(ary, i);}
|
||||
public static void Set(Object ary, int i, Object o) {Array.set(ary, i, o);}
|
||||
public static Object Expand(Object src, Object trg, int src_len) {
|
||||
try {System.arraycopy(src, 0, trg, 0, src_len);}
|
||||
catch (Exception e) {throw Err_.new_exc(e, "core", "Array_.Expand failed", "src_len", src_len);}
|
||||
return trg;
|
||||
}
|
||||
public static void Copy(Object src, Object trg) {System.arraycopy(src, 0, trg, 0, Len(src));}
|
||||
public static void CopyTo(Object src, Object trg, int trgPos) {System.arraycopy(src, 0, trg, trgPos, Len(src));}
|
||||
public static void CopyTo(Object src, int srcBgn, Object trg, int trgBgn, int srcLen) {System.arraycopy(src, srcBgn, trg, trgBgn, srcLen);}
|
||||
public static Class<?> ComponentType(Object ary) {
|
||||
public static void Copy_to(Object src, Object trg, int trgPos) {System.arraycopy(src, 0, trg, trgPos, Len(src));}
|
||||
public static void Copy_to(Object src, int srcBgn, Object trg, int trgBgn, int srcLen) {System.arraycopy(src, srcBgn, trg, trgBgn, srcLen);}
|
||||
private static Class<?> Component_type(Object ary) {
|
||||
if (ary == null) throw Err_.new_null();
|
||||
return ary.getClass().getComponentType();
|
||||
}
|
||||
public static Object Resize_add(Object src, Object add) {
|
||||
int srcLen = Len(src);
|
||||
int trgLen = srcLen + Len(add);
|
||||
Object trg = Create(ComponentType(src), trgLen);
|
||||
Object trg = Create(Component_type(src), trgLen);
|
||||
Copy(src, trg);
|
||||
for (int i = srcLen; i < trgLen; i++)
|
||||
Set(trg, i, Get(add, i - srcLen));
|
||||
Set_at(trg, i, Get_at(add, i - srcLen));
|
||||
return trg;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,7 +35,7 @@ public class Array__tst {
|
||||
tst_ReplaceInsert(ary_obj(0, 1, 2, 4, 5) , ary_obj(1, 2, 3), 1, 2, ary_obj(0, 1, 2, 3, 4, 5));
|
||||
tst_ReplaceInsert(ary_obj(0, 1, 2, 3, 4, 5) , ary_obj(1, 2, 3), 1, 3, ary_obj(0, 1, 2, 3, 4, 5));
|
||||
tst_ReplaceInsert(ary_obj(0, 1, 9, 4, 5) , ary_obj(2, 3) , 2, 1, ary_obj(0, 1, 2, 3, 4, 5));
|
||||
} void tst_ReplaceInsert(Object[] cur, Object[] add, int curReplacePos, int addInsertPos, Object[] expd) {Tfds.Eq_ary(expd, Array_.ReplaceInsert(cur, add, curReplacePos, addInsertPos));}
|
||||
} void tst_ReplaceInsert(Object[] cur, Object[] add, int curReplacePos, int addInsertPos, Object[] expd) {Tfds.Eq_ary(expd, Array_.Replace_insert(cur, add, curReplacePos, addInsertPos));}
|
||||
Object[] ary_obj(Object... ary) {return ary;}
|
||||
int[] ary_(int... ary) {return ary;}
|
||||
}
|
||||
|
||||
@@ -371,7 +371,7 @@ public class String_ implements GfoInvkAble {
|
||||
public static String[] Split_lang(String s, char c) {return s.split(Character.toString(c));}
|
||||
|
||||
static String Format_do(String s, Object[] ary) {
|
||||
int aryLength = Array_.LenAry(ary); if (aryLength == 0) return s; // nothing to format
|
||||
int aryLength = Array_.Len_obj(ary); if (aryLength == 0) return s; // nothing to format
|
||||
String_bldr sb = String_bldr_.new_();
|
||||
char bracketBgn = '{', bracketEnd = '}';
|
||||
String aryVal = null; char c, next;
|
||||
|
||||
@@ -606,7 +606,7 @@ public class Bry_ {
|
||||
else return new byte[] {b3};
|
||||
}
|
||||
public static boolean To_bool_by_int(byte[] ary) {
|
||||
int rv = To_int_or(ary, null, 0, ary.length, Int_.Min_value);
|
||||
int rv = To_int_or(ary, 0, ary.length, Int_.Min_value, Bool_.Y, null);
|
||||
switch (rv) {
|
||||
case 0: return false;
|
||||
case 1: return true;
|
||||
@@ -615,15 +615,15 @@ public class Bry_ {
|
||||
}
|
||||
public static byte To_int_as_byte(byte[] ary, int bgn, int end, byte or) {return (byte)To_int_or(ary, bgn, end, or);}
|
||||
public static int To_int(byte[] ary) {
|
||||
int rv = To_int_or(ary, null, 0, ary.length, Int_.Min_value);
|
||||
int rv = To_int_or(ary, 0, ary.length, Int_.Min_value, Bool_.Y, null);
|
||||
if (rv == Int_.Min_value) throw Err_.new_wo_type("could not parse to int", "val", String_.new_u8(ary));
|
||||
return rv;
|
||||
}
|
||||
public static int To_int_or_neg1(byte[] ary) {return To_int_or(ary, null, 0, ary.length, -1);}
|
||||
public static int To_int_or(byte[] ary, int or) {return To_int_or(ary, null, 0, ary.length, or);}
|
||||
public static int To_int_or(byte[] ary, int bgn, int end, int or) {return To_int_or(ary, null, bgn, end, or);}
|
||||
public static int To_int_or(byte[] ary, byte[] ignore_ary, int or) {return To_int_or(ary, ignore_ary, 0, ary.length, or);}
|
||||
public static int To_int_or(byte[] ary, byte[] ignore_ary, int bgn, int end, int or) {
|
||||
public static int To_int_or_neg1(byte[] ary) {return To_int_or(ary, 0 , ary.length, -1, Bool_.Y, null);}
|
||||
public static int To_int_or(byte[] ary, int or) {return To_int_or(ary, 0 , ary.length, or, Bool_.Y, null);}
|
||||
public static int To_int_or(byte[] ary, int bgn, int end, int or) {return To_int_or(ary, bgn , end , or, Bool_.Y, null);}
|
||||
public static int To_int_or__strict(byte[] ary, int or) {return To_int_or(ary, 0 , ary.length, or, Bool_.N, null);}
|
||||
private static int To_int_or(byte[] ary, int bgn, int end, int or, boolean sign_is_valid, byte[] ignore_ary) {
|
||||
if ( ary == null
|
||||
|| end == bgn // null-len
|
||||
) return or;
|
||||
@@ -637,44 +637,9 @@ public class Bry_ {
|
||||
multiple *= 10;
|
||||
break;
|
||||
case Byte_ascii.Dash:
|
||||
return i == bgn ? rv * -1 : or;
|
||||
return i == bgn && sign_is_valid ? rv * -1 : or;
|
||||
case Byte_ascii.Plus:
|
||||
return i == bgn ? rv : or;
|
||||
default:
|
||||
boolean invalid = true;
|
||||
if (ignore_ary != null) {
|
||||
int ignore_ary_len = ignore_ary.length;
|
||||
for (int j = 0; j < ignore_ary_len; j++) {
|
||||
if (b == ignore_ary[j]) {
|
||||
invalid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (invalid) return or;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
public static long To_long_or(byte[] ary, long or) {return To_long_or(ary, null, 0, ary.length, or);}
|
||||
public static long To_long_or(byte[] ary, byte[] ignore_ary, int bgn, int end, long or) {
|
||||
if ( ary == null
|
||||
|| end == bgn // null-len
|
||||
) return or;
|
||||
long rv = 0, multiple = 1;
|
||||
for (int i = end - 1; i >= bgn; i--) { // -1 b/c end will always be next char; EX: {{{1}}}; bgn = 3, end = 4
|
||||
byte b = ary[i];
|
||||
switch (b) {
|
||||
case Byte_ascii.Num_0: case Byte_ascii.Num_1: case Byte_ascii.Num_2: case Byte_ascii.Num_3: case Byte_ascii.Num_4:
|
||||
case Byte_ascii.Num_5: case Byte_ascii.Num_6: case Byte_ascii.Num_7: case Byte_ascii.Num_8: case Byte_ascii.Num_9:
|
||||
rv += multiple * (b - Byte_ascii.Num_0);
|
||||
multiple *= 10;
|
||||
break;
|
||||
case Byte_ascii.Dash:
|
||||
return i == bgn ? rv * -1 : or;
|
||||
case Byte_ascii.Plus:
|
||||
return i == bgn ? rv : or;
|
||||
return i == bgn && sign_is_valid ? rv : or;
|
||||
default:
|
||||
boolean invalid = true;
|
||||
if (ignore_ary != null) {
|
||||
@@ -741,6 +706,41 @@ public class Bry_ {
|
||||
}
|
||||
return To_int_or(ary, bgn, end_num, or);
|
||||
}
|
||||
public static long To_long_or(byte[] ary, long or) {return To_long_or(ary, null, 0, ary.length, or);}
|
||||
public static long To_long_or(byte[] ary, byte[] ignore_ary, int bgn, int end, long or) {
|
||||
if ( ary == null
|
||||
|| end == bgn // null-len
|
||||
) return or;
|
||||
long rv = 0, multiple = 1;
|
||||
for (int i = end - 1; i >= bgn; i--) { // -1 b/c end will always be next char; EX: {{{1}}}; bgn = 3, end = 4
|
||||
byte b = ary[i];
|
||||
switch (b) {
|
||||
case Byte_ascii.Num_0: case Byte_ascii.Num_1: case Byte_ascii.Num_2: case Byte_ascii.Num_3: case Byte_ascii.Num_4:
|
||||
case Byte_ascii.Num_5: case Byte_ascii.Num_6: case Byte_ascii.Num_7: case Byte_ascii.Num_8: case Byte_ascii.Num_9:
|
||||
rv += multiple * (b - Byte_ascii.Num_0);
|
||||
multiple *= 10;
|
||||
break;
|
||||
case Byte_ascii.Dash:
|
||||
return i == bgn ? rv * -1 : or;
|
||||
case Byte_ascii.Plus:
|
||||
return i == bgn ? rv : or;
|
||||
default:
|
||||
boolean invalid = true;
|
||||
if (ignore_ary != null) {
|
||||
int ignore_ary_len = ignore_ary.length;
|
||||
for (int j = 0; j < ignore_ary_len; j++) {
|
||||
if (b == ignore_ary[j]) {
|
||||
invalid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (invalid) return or;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
public static double To_double(byte[] ary, int bgn, int end) {return Double_.parse(String_.new_u8(ary, bgn, end));}
|
||||
public static double To_double_or(byte[] bry, double or) {return Double_.parse_or(String_.new_u8(bry, 0, bry.length), or);}
|
||||
public static double To_double_or(byte[] ary, int bgn, int end, double or) {return Double_.parse_or(String_.new_u8(ary, bgn, end), or);}
|
||||
|
||||
@@ -83,7 +83,7 @@ public class Bry_bfr {
|
||||
int val_len = val.length;
|
||||
if (bfr_len + val_len > bfr_max) Resize((bfr_max + val_len) * 2);
|
||||
Bry_.Copy_by_pos(val, 0, val_len, bfr, bfr_len);
|
||||
// Array_.CopyTo(val, 0, bfr, bfr_len, val_len);
|
||||
// Array_.Copy_to(val, 0, bfr, bfr_len, val_len);
|
||||
bfr_len += val_len;
|
||||
return this;
|
||||
}
|
||||
@@ -92,7 +92,7 @@ public class Bry_bfr {
|
||||
if (len < 0) throw Err_.new_wo_type("negative len", "bgn", bgn, "end", end, "excerpt", String_.new_u8_by_len(val, bgn, bgn + 16)); // NOTE: check for invalid end < bgn, else difficult to debug errors later; DATE:2014-05-11
|
||||
if (bfr_len + len > bfr_max) Resize((bfr_max + len) * 2);
|
||||
Bry_.Copy_by_pos(val, bgn, end, bfr, bfr_len);
|
||||
// Array_.CopyTo(val, bgn, bfr, bfr_len, len);
|
||||
// Array_.Copy_to(val, bgn, bfr, bfr_len, len);
|
||||
bfr_len += len;
|
||||
return this;
|
||||
}
|
||||
@@ -100,7 +100,7 @@ public class Bry_bfr {
|
||||
int len = src.bfr_len;
|
||||
if (bfr_len + len > bfr_max) Resize((bfr_max + len) * 2);
|
||||
Bry_.Copy_by_pos(src.bfr, 0, len, bfr, bfr_len);
|
||||
// Array_.CopyTo(src.bfr, 0, bfr, bfr_len, len);
|
||||
// Array_.Copy_to(src.bfr, 0, bfr, bfr_len, len);
|
||||
bfr_len += len;
|
||||
return this;
|
||||
}
|
||||
@@ -145,7 +145,7 @@ public class Bry_bfr {
|
||||
}
|
||||
src_len = src_end - src_bgn;
|
||||
Bry_.Copy_by_pos(src.bfr, src_bgn, src_end, bfr, bfr_len);
|
||||
// Array_.CopyTo(src.bfr, src_bgn, bfr, bfr_len, src_len);
|
||||
// Array_.Copy_to(src.bfr, src_bgn, bfr, bfr_len, src_len);
|
||||
bfr_len += src_len;
|
||||
src.Clear();
|
||||
return this;
|
||||
|
||||
@@ -125,11 +125,11 @@ class Bry_bfr_mkr_mgr {
|
||||
private void Expand() {
|
||||
int new_max = ary_max == 0 ? 2 : ary_max * 2;
|
||||
Bry_bfr[] new_ary = new Bry_bfr[new_max];
|
||||
Array_.CopyTo(ary, 0, new_ary, 0, ary_max);
|
||||
Array_.Copy_to(ary, 0, new_ary, 0, ary_max);
|
||||
ary = new_ary;
|
||||
ary_max = new_max;
|
||||
int[] new_free = new int[ary_max];
|
||||
Array_.CopyTo(free, 0, new_free, 0, free_len);
|
||||
Array_.Copy_to(free, 0, new_free, 0, free_len);
|
||||
free = new_free;
|
||||
}
|
||||
// public void Rls(Bry_bfr v) {
|
||||
|
||||
@@ -58,7 +58,7 @@ public class List_adp_ {
|
||||
int ary_len = Array_.Len(ary);
|
||||
List_adp rv = size_(ary_len);
|
||||
for (int i = 0; i < ary_len; i++)
|
||||
rv.Add(Array_.Get(ary, i));
|
||||
rv.Add(Array_.Get_at(ary, i));
|
||||
return rv;
|
||||
}
|
||||
public static final int Capacity_initial = 8;
|
||||
|
||||
@@ -23,7 +23,7 @@ public abstract class List_adp_base implements List_adp, GfoInvkAble {
|
||||
public Object To_ary(Class<?> memberType) {
|
||||
Object rv = Array_.Create(memberType, count);
|
||||
for (int i = 0; i < count; i++)
|
||||
Array_.Set(rv, i, list[i]);
|
||||
Array_.Set_at(rv, i, list[i]);
|
||||
return rv;
|
||||
}
|
||||
public Object[] To_obj_ary() {
|
||||
@@ -45,7 +45,7 @@ public abstract class List_adp_base implements List_adp, GfoInvkAble {
|
||||
return list[index];
|
||||
}
|
||||
protected void Add_base(Object o) {
|
||||
if (count == Array_.LenAry(list)) Resize_expand();
|
||||
if (count == Array_.Len_obj(list)) Resize_expand();
|
||||
list[count] = o;
|
||||
count++;
|
||||
}
|
||||
@@ -64,9 +64,9 @@ public abstract class List_adp_base implements List_adp, GfoInvkAble {
|
||||
int newLen = count - delLen;
|
||||
Object[] newList = new Object[newLen];
|
||||
if (delBgn != 0) // copy elements < delBgn; skip if delBgn == 0
|
||||
Array_.CopyTo(list, 0, newList, 0, delBgn);
|
||||
Array_.Copy_to(list, 0, newList, 0, delBgn);
|
||||
if (delEnd != count -1 ) // copy elements > delEnd; skip if delEnd == lastIdx
|
||||
Array_.CopyTo(list, delEnd + 1, newList, delBgn, newLen - delBgn);
|
||||
Array_.Copy_to(list, delEnd + 1, newList, delBgn, newLen - delBgn);
|
||||
list = newList;
|
||||
count = list.length;
|
||||
}
|
||||
@@ -93,7 +93,7 @@ public abstract class List_adp_base implements List_adp, GfoInvkAble {
|
||||
list[trg] = o;
|
||||
}
|
||||
protected void AddAt_base(int pos, Object o) {
|
||||
if (count + 1 >= Array_.LenAry(list)) Resize_expand();
|
||||
if (count + 1 >= Array_.Len_obj(list)) Resize_expand();
|
||||
for (int i = count; i > pos; i--)
|
||||
list[i] = list[i - 1];
|
||||
list[pos] = o;
|
||||
@@ -156,7 +156,7 @@ public abstract class List_adp_base implements List_adp, GfoInvkAble {
|
||||
list[i] = (i == count - 1) ? null : list[i + 1];
|
||||
}
|
||||
}
|
||||
@gplx.Internal protected int Capacity() {return Array_.LenAry(list);}
|
||||
@gplx.Internal protected int Capacity() {return Array_.Len_obj(list);}
|
||||
public Object Invk(GfsCtx ctx, int ikey, String k, GfoMsg m) {
|
||||
if (ctx.Match(k, Invk_len)) return count;
|
||||
else if (ctx.Match(k, Invk_get_at)) return Get_at(m.ReadInt("v"));
|
||||
|
||||
@@ -88,8 +88,8 @@ public class HashAlgo_tth192 implements HashAlgo {
|
||||
if (branchRv == null || branchRv.length != blockA.length + blockB.length + 1)
|
||||
branchRv = new byte[blockA.length + blockB.length + 1];
|
||||
branchRv[0] = 0x01; // branch hash mark.
|
||||
Array_.CopyTo(blockA, branchRv, 1);
|
||||
Array_.CopyTo(blockB, branchRv, blockA.length + 1);
|
||||
Array_.Copy_to(blockA, branchRv, 1);
|
||||
Array_.Copy_to(blockB, branchRv, blockA.length + 1);
|
||||
return CalcHash(branchRv);
|
||||
}
|
||||
byte[] CalcHash_leaf(byte[] raw, int i) {
|
||||
@@ -109,7 +109,7 @@ public class HashAlgo_tth192 implements HashAlgo {
|
||||
}
|
||||
|
||||
rv[0] = 0x00; // leaf hash mark.
|
||||
Array_.CopyTo(raw, rv, 1);
|
||||
Array_.Copy_to(raw, rv, 1);
|
||||
return CalcHash(rv);
|
||||
}
|
||||
byte[] CalcHash(byte[] raw) {
|
||||
|
||||
@@ -84,17 +84,17 @@ public class XmlFileSplitter {
|
||||
}
|
||||
public byte[] SplitHdr(byte[] src, int findPos) {
|
||||
hdr = new byte[findPos];
|
||||
Array_.CopyTo(src, 0, hdr, 0, findPos);
|
||||
Array_.Copy_to(src, 0, hdr, 0, findPos);
|
||||
byte[] rv = new byte[src.length - findPos];
|
||||
Array_.CopyTo(src, findPos, rv, 0, rv.length);
|
||||
Array_.Copy_to(src, findPos, rv, 0, rv.length);
|
||||
return rv;
|
||||
}
|
||||
public byte[][] SplitRest(byte[] src, int findPos) {
|
||||
byte[][] rv = new byte[2][];
|
||||
rv[0] = new byte[findPos];
|
||||
Array_.CopyTo(src, 0, rv[0], 0, findPos);
|
||||
Array_.Copy_to(src, 0, rv[0], 0, findPos);
|
||||
rv[1] = new byte[src.length - findPos];
|
||||
Array_.CopyTo(src, findPos, rv[1], 0, rv[1].length);
|
||||
Array_.Copy_to(src, findPos, rv[1], 0, rv[1].length);
|
||||
return rv;
|
||||
}
|
||||
public int FindMatchPos(byte[] src, byte[][] wordAry) {return FindMatchPos(src, wordAry, true);}
|
||||
|
||||
Reference in New Issue
Block a user