mirror of
https://github.com/gnosygnu/xowa.git
synced 2025-05-30 14:04:56 +00:00
v2.5.4.1
This commit is contained in:
gnosygnu
parent
6eec99a713
commit
51e6188c1e
@ -19,6 +19,6 @@ package gplx.core.criterias; import gplx.*; import gplx.core.*;
|
||||
public interface Criteria extends XtoStrAble {
|
||||
byte Tid();
|
||||
boolean Matches(Object obj);
|
||||
void Val_from_args(HashAdp args);
|
||||
void Val_from_args(Hash_adp args);
|
||||
void Val_as_obj_(Object obj);
|
||||
}
|
||||
|
||||
@ -20,7 +20,7 @@ public class Criteria_between implements Criteria {
|
||||
public Criteria_between(boolean negate, Comparable lhs, Comparable rhs) {this.negate = negate; this.lhs = lhs; this.rhs = rhs;}
|
||||
public byte Tid() {return Criteria_.Tid_between;}
|
||||
public boolean Negated() {return negate;} private final boolean negate;
|
||||
public void Val_from_args(HashAdp args) {throw Err_.not_implemented_();}
|
||||
public void Val_from_args(Hash_adp args) {throw Err_.not_implemented_();}
|
||||
public void Val_as_obj_(Object v) {
|
||||
Object[] ary = (Object[])v;
|
||||
lhs = (Comparable)ary[0];
|
||||
|
||||
@ -20,7 +20,7 @@ public abstract class Criteria_bool_base implements Criteria {
|
||||
@gplx.Internal protected void Ctor(String op_literal, Criteria lhs, Criteria rhs) {this.op_literal = op_literal; this.lhs = lhs; this.rhs = rhs;}
|
||||
public abstract byte Tid();
|
||||
public abstract boolean Matches(Object curVal);
|
||||
public void Val_from_args(HashAdp args) {lhs.Val_from_args(args); rhs.Val_from_args(args);}
|
||||
public void Val_from_args(Hash_adp args) {lhs.Val_from_args(args); rhs.Val_from_args(args);}
|
||||
public void Val_as_obj_(Object v) {throw Err_.not_implemented_();}
|
||||
public String XtoStr() {return String_.Concat(lhs.XtoStr(), " ", this.op_literal, " ", rhs.XtoStr());}
|
||||
public String Op_literal() {return op_literal;} private String op_literal;
|
||||
@ -42,7 +42,7 @@ class Criteria_const implements Criteria {
|
||||
public Criteria_const(boolean val) {this.val = val;}
|
||||
public byte Tid() {return Criteria_.Tid_const;}
|
||||
public boolean Matches(Object comp) {return val;} private final boolean val;
|
||||
public void Val_from_args(HashAdp args) {;}
|
||||
public void Val_from_args(Hash_adp args) {;}
|
||||
public void Val_as_obj_(Object v) {throw Err_.not_implemented_();}
|
||||
public String XtoStr() {return String_.Concat(" IS ", Bool_.Xto_str_lower(val));}
|
||||
}
|
||||
@ -51,7 +51,7 @@ class Criteria_not implements Criteria {
|
||||
public Criteria_not(Criteria v) {this.criteria = v;}
|
||||
public byte Tid() {return Criteria_.Tid_not;}
|
||||
public boolean Matches(Object obj) {return !criteria.Matches(obj);}
|
||||
public void Val_from_args(HashAdp args) {criteria.Val_from_args(args);}
|
||||
public void Val_from_args(Hash_adp args) {criteria.Val_from_args(args);}
|
||||
public void Val_as_obj_(Object v) {criteria.Val_as_obj_(v);}
|
||||
public String XtoStr() {return String_.Concat_any(" NOT ", criteria.XtoStr());}
|
||||
}
|
||||
|
||||
@ -21,7 +21,7 @@ public class Criteria_comp implements Criteria {
|
||||
@gplx.Internal protected Criteria_comp(int comp_mode, Comparable val) {this.comp_mode = comp_mode; this.val = val;}
|
||||
public byte Tid() {return Criteria_.Tid_comp;}
|
||||
public Comparable Val() {return val;} private Comparable val;
|
||||
public void Val_from_args(HashAdp args) {throw Err_.not_implemented_();}
|
||||
public void Val_from_args(Hash_adp args) {throw Err_.not_implemented_();}
|
||||
public void Val_as_obj_(Object v) {val = (Comparable)v;}
|
||||
public boolean Matches(Object compObj) {
|
||||
Comparable comp = CompareAble_.as_(compObj);
|
||||
|
||||
@ -22,7 +22,7 @@ public class Criteria_eq implements Criteria {
|
||||
public boolean Negated() {return negated;} private final boolean negated;
|
||||
public Object Val() {return val;} private Object val;
|
||||
public void Val_as_obj_(Object v) {this.val = v;}
|
||||
public void Val_from_args(HashAdp args) {throw Err_.not_implemented_();}
|
||||
public void Val_from_args(Hash_adp args) {throw Err_.not_implemented_();}
|
||||
public boolean Matches(Object comp) {
|
||||
Class<?> val_type = ClassAdp_.ClassOf_obj(val);
|
||||
if (!ClassAdp_.Eq_typeSafe(comp, val_type)) throw Err_.type_mismatch_(val_type, comp);
|
||||
|
||||
@ -22,8 +22,8 @@ public class Criteria_fld implements Criteria {
|
||||
public String Key() {return key;} private final String key;
|
||||
public Criteria Crt() {return crt;} private final Criteria crt;
|
||||
public void Val_as_obj_(Object v) {throw Err_.not_implemented_();}
|
||||
public void Val_from_args(HashAdp args) {
|
||||
ListAdp list = (ListAdp)args.Fetch(key); if (list == null) throw Err_.new_("criteria.fld key not found; key={0}", key);
|
||||
public void Val_from_args(Hash_adp args) {
|
||||
List_adp list = (List_adp)args.Get_by(key); if (list == null) throw Err_.new_("criteria.fld key not found; key={0}", key);
|
||||
Object o = Fill_val(key, crt.Tid(), list);
|
||||
crt.Val_as_obj_(o);
|
||||
}
|
||||
@ -37,7 +37,7 @@ public class Criteria_fld implements Criteria {
|
||||
public static final String Key_null = null;
|
||||
public static Criteria_fld as_(Object obj) {return obj instanceof Criteria_fld ? (Criteria_fld)obj : null;}
|
||||
public static Criteria_fld new_(String key, Criteria crt) {return new Criteria_fld(key, crt);}
|
||||
public static Object Fill_val(String key, byte tid, ListAdp list) {
|
||||
public static Object Fill_val(String key, byte tid, List_adp list) {
|
||||
int len = list.Count();
|
||||
switch (tid) {
|
||||
case Criteria_.Tid_eq:
|
||||
@ -45,13 +45,13 @@ public class Criteria_fld implements Criteria {
|
||||
case Criteria_.Tid_like:
|
||||
case Criteria_.Tid_iomatch:
|
||||
if (len != 1) throw Err_.new_("list.len should be 1; key={0} tid={1} len={2}", key, tid, len);
|
||||
return list.FetchAt(0);
|
||||
return list.Get_at(0);
|
||||
case Criteria_.Tid_between:
|
||||
if (len != 2) throw Err_.new_("list.len should be 2; key={0} tid={1} len={2}", key, tid, len);
|
||||
return new Object[] {list.FetchAt(0), list.FetchAt(1)};
|
||||
return new Object[] {list.Get_at(0), list.Get_at(1)};
|
||||
case Criteria_.Tid_in:
|
||||
if (len == 0) throw Err_.new_("list.len should be > 0; key={0} tid={1} len={2}", key, tid, len);
|
||||
return list.Xto_obj_ary();
|
||||
return list.To_obj_ary();
|
||||
case Criteria_.Tid_const:
|
||||
case Criteria_.Tid_not:
|
||||
case Criteria_.Tid_and:
|
||||
|
||||
@ -27,7 +27,7 @@ public class Criteria_in implements Criteria {
|
||||
ary_type = ary_len == 0 ? Object.class : ClassAdp_.ClassOf_obj(ary[0]);
|
||||
}
|
||||
public void Val_as_obj_(Object v) {Val_as_obj_ary_((Object[])v);}
|
||||
public void Val_from_args(HashAdp args) {throw Err_.not_implemented_();}
|
||||
public void Val_from_args(Hash_adp args) {throw Err_.not_implemented_();}
|
||||
public boolean Matches(Object comp) {
|
||||
if (ary_len == 0) return false; // empty array never matches
|
||||
if (!ClassAdp_.Eq_typeSafe(comp, ary_type)) throw Err_.type_mismatch_(ary_type, comp);
|
||||
|
||||
@ -21,7 +21,7 @@ public class Criteria_ioMatch implements Criteria { // EX: url IOMATCH '*.xml|*.
|
||||
public Criteria_ioMatch(boolean match, RegxPatn_cls_ioMatch pattern) {this.match = match; this.pattern = pattern;}
|
||||
public byte Tid() {return Criteria_.Tid_iomatch;}
|
||||
public boolean Negated() {return !match;} private final boolean match;
|
||||
public void Val_from_args(HashAdp args) {throw Err_.not_implemented_();}
|
||||
public void Val_from_args(Hash_adp args) {throw Err_.not_implemented_();}
|
||||
public void Val_as_obj_(Object v) {this.pattern = (RegxPatn_cls_ioMatch)v;}
|
||||
public RegxPatn_cls_ioMatch Pattern() {return pattern;} private RegxPatn_cls_ioMatch pattern;
|
||||
public boolean Matches(Object compObj) {
|
||||
|
||||
@ -24,7 +24,7 @@ public class Criteria_like implements Criteria {
|
||||
public byte Tid() {return Criteria_.Tid_like;}
|
||||
public boolean Negated() {return negated;} private final boolean negated;
|
||||
public RegxPatn_cls_like Pattern() {return pattern;} private RegxPatn_cls_like pattern;
|
||||
public void Val_from_args(HashAdp args) {throw Err_.not_implemented_();}
|
||||
public void Val_from_args(Hash_adp args) {throw Err_.not_implemented_();}
|
||||
public void Val_as_obj_(Object v) {this.pattern = (RegxPatn_cls_like)v;}
|
||||
public boolean Matches(Object compObj) {
|
||||
String comp = String_.as_(compObj); if (comp == null) throw Err_.type_mismatch_(String.class, compObj);
|
||||
|
||||
@ -92,7 +92,7 @@ class String_bldr_thread_single extends String_bldr_base {
|
||||
@Override public String XtoStr() {return sb.toString();}
|
||||
@Override public int Count() {return sb.length();}
|
||||
@Override public String_bldr Add_at(int idx, String s) {sb.insert(idx, s); return this;}
|
||||
@Override public String_bldr Add(byte[] v) {sb.append(String_.new_utf8_(v)); return this;}
|
||||
@Override public String_bldr Add(byte[] v) {sb.append(String_.new_u8(v)); return this;}
|
||||
@Override public String_bldr Add(String s) {sb.append(s); return this;}
|
||||
@Override public String_bldr Add(char c) {sb.append(c); return this;}
|
||||
@Override public String_bldr Add(int i) {sb.append(i); return this;}
|
||||
@ -105,7 +105,7 @@ class String_bldr_thread_multiple extends String_bldr_base {
|
||||
@Override public String XtoStr() {return sb.toString();}
|
||||
@Override public int Count() {return sb.length();}
|
||||
@Override public String_bldr Add_at(int idx, String s) {sb.insert(idx, s); return this;}
|
||||
@Override public String_bldr Add(byte[] v) {sb.append(String_.new_utf8_(v)); return this;}
|
||||
@Override public String_bldr Add(byte[] v) {sb.append(String_.new_u8(v)); return this;}
|
||||
@Override public String_bldr Add(String s) {sb.append(s); return this;}
|
||||
@Override public String_bldr Add(char c) {sb.append(c); return this;}
|
||||
@Override public String_bldr Add(int i) {sb.append(i); return this;}
|
||||
|
||||
@ -20,10 +20,10 @@ public class Err extends RuntimeException {
|
||||
@Override public String getMessage() {return Message_gplx();}
|
||||
public String Key() {return key;} public Err Key_(String v) {key = v; return this;} private String key = "";
|
||||
public String Hdr() {return hdr;} public Err Hdr_(String v) {hdr = v; return this;} private String hdr = "";
|
||||
public ListAdp Args() {return args;} ListAdp args = ListAdp_.new_();
|
||||
public List_adp Args() {return args;} List_adp args = List_adp_.new_();
|
||||
public Err Add(String k, Object o) {args.Add(KeyVal_.new_(k, o)); return this;}
|
||||
@gplx.Internal protected ErrProcData Proc() {return proc;} ErrProcData proc = ErrProcData.Null;
|
||||
public OrderedHash CallStack() {return callStack;} OrderedHash callStack = OrderedHash_.new_();
|
||||
public Ordered_hash CallStack() {return callStack;} Ordered_hash callStack = Ordered_hash_.new_();
|
||||
public int CallLevel() {return callLevel;} public Err CallLevel_(int val) {callLevel = val; return this;} public Err CallLevel_1_() {return CallLevel_(1);} int callLevel;
|
||||
public Err Inner() {return inner;} Err inner;
|
||||
@gplx.Internal protected static Err hdr_(String hdr) {
|
||||
@ -35,7 +35,7 @@ public class Err extends RuntimeException {
|
||||
Err rv = hdr_(hdr + ":" + Err_.Message_lang(thrown)); // add a better error description; DATE:2014-08-15
|
||||
rv.inner = convert_(thrown);
|
||||
for (int i = 0; i < rv.inner.callStack.Count(); i++) {
|
||||
ErrProcData itm = (ErrProcData)rv.inner.callStack.FetchAt(i);
|
||||
ErrProcData itm = (ErrProcData)rv.inner.callStack.Get_at(i);
|
||||
rv.callStack.Add(itm.Raw(), itm);
|
||||
}
|
||||
return rv;
|
||||
|
||||
@ -56,7 +56,7 @@ public class ErrMsgWtr {
|
||||
sb.Add("\t").Add(err.Proc().SignatureRaw()).Add_char_crlf();
|
||||
// WriteKeyValAry(sb, err.ProcArgs());
|
||||
}
|
||||
void WriteKeyValAry(String_bldr sb, ListAdp ary) {
|
||||
void WriteKeyValAry(String_bldr sb, List_adp ary) {
|
||||
// calc keyMax for valIndentLen
|
||||
int keyMax = 0;
|
||||
for (Object o : ary) {
|
||||
@ -78,10 +78,10 @@ public class ErrMsgWtr {
|
||||
Err first = errAry[0];
|
||||
boolean onlyOne = len == 1;
|
||||
sb.Add_str_w_crlf(String_.Repeat("-", 80));
|
||||
ListAdp tmp = ListAdp_.new_();
|
||||
OrderedHash callStack = first.CallStack(); int callStackCount = callStack.Count();
|
||||
List_adp tmp = List_adp_.new_();
|
||||
Ordered_hash callStack = first.CallStack(); int callStackCount = callStack.Count();
|
||||
for (int i = 0; i < callStackCount ; i++) {
|
||||
ErrProcData proc = (ErrProcData)callStack.FetchAt(i);
|
||||
ErrProcData proc = (ErrProcData)callStack.Get_at(i);
|
||||
// get procIndex
|
||||
int idx = -1;
|
||||
for (int j = 0; j < len; j++) {
|
||||
@ -100,13 +100,13 @@ public class ErrMsgWtr {
|
||||
sb.Add_str_w_crlf((String)o);
|
||||
}
|
||||
static Err[] InnerAsAry(Err err) {
|
||||
ListAdp errAry = ListAdp_.new_();
|
||||
List_adp errAry = List_adp_.new_();
|
||||
Err cur = Err_.as_(err);
|
||||
while (cur != null) {
|
||||
errAry.Add(cur);
|
||||
cur = cur.Inner();
|
||||
}
|
||||
return (Err[])errAry.Xto_ary(Err.class);
|
||||
return (Err[])errAry.To_ary(Err.class);
|
||||
}
|
||||
public static final ErrMsgWtr _ = new ErrMsgWtr(); ErrMsgWtr() {}
|
||||
}
|
||||
|
||||
@ -37,7 +37,7 @@ class ErrProcData {
|
||||
*/
|
||||
if (stackTrace == null) return new ErrProcData[0];
|
||||
String[] lines = String_.SplitLines_any(stackTrace);
|
||||
ListAdp list = ListAdp_.new_();
|
||||
List_adp list = List_adp_.new_();
|
||||
int len = Array_.Len(lines);
|
||||
for (int i = 0; i < len; i++) {
|
||||
ErrProcData md = ErrProcData.parse_(lines[i]);
|
||||
@ -45,7 +45,7 @@ class ErrProcData {
|
||||
if (String_.HasAtBgn(md.signatureRaw, "gplx.Err_") || String_.HasAtBgn(md.signatureRaw, "gplx.Err.")) continue; // java includes entire stackTrace from point of creation; only care about point of throw
|
||||
list.Add(md);
|
||||
}
|
||||
return (ErrProcData[])list.Xto_ary(ErrProcData.class);
|
||||
return (ErrProcData[])list.To_ary(ErrProcData.class);
|
||||
}
|
||||
public static ErrProcData parse_(String raw) {
|
||||
ErrProcData rv = new ErrProcData().Raw_(raw);
|
||||
|
||||
@ -21,9 +21,9 @@ public class Err_mgr {
|
||||
public Err not_implemented_() {return Err_.new_(Msg_not_implemented.Gen_str_none());}
|
||||
public Err unhandled_(Object obj) {return Err_.new_(Msg_unhandled.Gen_str_one(obj));}
|
||||
public Err cast_(Exception e, Class<?> obj_class, Object obj) {return Err_.new_(Msg_cast.Gen_str_many(ClassAdp_.NameOf_type(obj_class), Object_.Xto_str_strict_or_null_mark(obj)));}
|
||||
public Err parse_(Class<?> type , byte[] raw) {return Err_.new_(Msg_parse.Gen_str_many(ClassAdp_.NameOf_type(type), String_.new_utf8_len_safe_(raw, 0, 255)));}
|
||||
public Err parse_obj_(Object o , byte[] raw) {return Err_.new_(Msg_parse.Gen_str_many(ClassAdp_.NameOf_obj(o), String_.new_utf8_len_safe_(raw, 0, 255)));}
|
||||
public Err parse_(String type_name, byte[] raw) {return Err_.new_(Msg_parse.Gen_str_many(type_name, String_.new_utf8_len_safe_(raw, 0, 255)));}
|
||||
public Err parse_(Class<?> type , byte[] raw) {return Err_.new_(Msg_parse.Gen_str_many(ClassAdp_.NameOf_type(type), String_.new_u8_by_len(raw, 0, 255)));}
|
||||
public Err parse_obj_(Object o , byte[] raw) {return Err_.new_(Msg_parse.Gen_str_many(ClassAdp_.NameOf_obj(o), String_.new_u8_by_len(raw, 0, 255)));}
|
||||
public Err parse_(String type_name, byte[] raw) {return Err_.new_(Msg_parse.Gen_str_many(type_name, String_.new_u8_by_len(raw, 0, 255)));}
|
||||
public Err parse_(String type_name, String raw) {return Err_.new_(Msg_parse.Gen_str_many(type_name, String_.MidByLenSafe(raw, 0, 255)));}
|
||||
public Err fmt_auto_(String grp, String key, Object... vals) {return fmt_(grp, key, Bry_fmtr.New_fmt_str(key, vals), vals);}
|
||||
public Err fmt_(String grp, String key, String fmt, Object... vals) {
|
||||
|
||||
@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
public class Gfo_msg_grp implements Gfo_msg_obj {
|
||||
public Gfo_msg_grp(Gfo_msg_grp owner, int uid, byte[] key) {
|
||||
this.owner = owner; this.uid = uid; this.key = key; this.key_str = String_.new_ascii_(key);
|
||||
this.owner = owner; this.uid = uid; this.key = key; this.key_str = String_.new_a7(key);
|
||||
if (owner != null) {
|
||||
owner.subs.Add(this);
|
||||
path = Gfo_msg_grp_.Path(owner.path, key);
|
||||
@ -32,15 +32,15 @@ public class Gfo_msg_grp implements Gfo_msg_obj {
|
||||
public byte[] Key() {return key;} private byte[] key;
|
||||
public String Key_str() {return key_str;} private String key_str;
|
||||
public byte[] Path() {return path;} private byte[] path;
|
||||
public String Path_str() {return String_.new_ascii_(path);}
|
||||
public String Path_str() {return String_.new_a7(path);}
|
||||
public Gfo_msg_obj Subs_get_by_key(String sub_key) {
|
||||
int subs_len = subs.Count();
|
||||
for (int i = 0; i < subs_len; i++) {
|
||||
Gfo_msg_obj sub = (Gfo_msg_obj)subs.FetchAt(i);
|
||||
Gfo_msg_obj sub = (Gfo_msg_obj)subs.Get_at(i);
|
||||
if (String_.Eq(sub_key, sub.Key_str())) return sub;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
public void Subs_add(Gfo_msg_itm item) {subs.Add(item);}
|
||||
ListAdp subs = ListAdp_.new_();
|
||||
List_adp subs = List_adp_.new_();
|
||||
}
|
||||
|
||||
@ -17,10 +17,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
public class Gfo_msg_grp_ {
|
||||
public static final Gfo_msg_grp Root_gplx = new Gfo_msg_grp(null, Gfo_msg_grp_.Uid_next(), Bry_.new_ascii_("gplx"));
|
||||
public static final Gfo_msg_grp Root_gplx = new Gfo_msg_grp(null, Gfo_msg_grp_.Uid_next(), Bry_.new_a7("gplx"));
|
||||
public static final Gfo_msg_grp Root = new Gfo_msg_grp(null, Gfo_msg_grp_.Uid_next(), Bry_.Empty);
|
||||
public static Gfo_msg_grp prj_(String key) {return new Gfo_msg_grp(Root , Gfo_msg_grp_.Uid_next(), Bry_.new_ascii_(key));}
|
||||
public static Gfo_msg_grp new_(Gfo_msg_grp owner, String key) {return new Gfo_msg_grp(owner , Gfo_msg_grp_.Uid_next(), Bry_.new_ascii_(key));}
|
||||
public static Gfo_msg_grp prj_(String key) {return new Gfo_msg_grp(Root , Gfo_msg_grp_.Uid_next(), Bry_.new_a7(key));}
|
||||
public static Gfo_msg_grp new_(Gfo_msg_grp owner, String key) {return new Gfo_msg_grp(owner , Gfo_msg_grp_.Uid_next(), Bry_.new_a7(key));}
|
||||
public static int Uid_next() {return uid_next++;} static int uid_next = 0;
|
||||
public static byte[] Path(byte[] owner_path, byte[] key) {
|
||||
if (owner_path != Bry_.Empty) tmp_bfr.Add(owner_path).Add_byte(Byte_ascii.Dot); // only add "." if owner_path is available; prevents creating ".gplx"
|
||||
|
||||
@ -19,14 +19,14 @@ package gplx;
|
||||
public class Gfo_msg_itm implements Gfo_msg_obj {
|
||||
public Gfo_msg_itm(Gfo_msg_grp owner, int uid, byte cmd, byte[] key_bry, byte[] fmt, boolean add_to_owner) {
|
||||
this.owner = owner; this.uid = uid; this.cmd = cmd; this.key_bry = key_bry; this.fmt = fmt;
|
||||
this.key_str = String_.new_ascii_(key_bry);
|
||||
this.key_str = String_.new_a7(key_bry);
|
||||
this.path_bry = Gfo_msg_grp_.Path(owner.Path(), key_bry);
|
||||
if (add_to_owner) owner.Subs_add(this);
|
||||
}
|
||||
public Gfo_msg_grp Owner() {return owner;} Gfo_msg_grp owner;
|
||||
public int Uid() {return uid;} int uid;
|
||||
public byte[] Path_bry() {return path_bry;} private byte[] path_bry;
|
||||
public String Path_str() {return String_.new_utf8_(path_bry);}
|
||||
public String Path_str() {return String_.new_u8(path_bry);}
|
||||
public byte[] Key_bry() {return key_bry;} private byte[] key_bry;
|
||||
public String Key_str() {return key_str;} private String key_str;
|
||||
public Gfo_msg_obj Subs_get_by_key(String sub_key) {return null;}
|
||||
@ -41,7 +41,7 @@ public class Gfo_msg_itm implements Gfo_msg_obj {
|
||||
return tmp_bfr.Xto_str_and_clear();
|
||||
}
|
||||
else
|
||||
return String_.new_utf8_(fmt);
|
||||
return String_.new_u8(fmt);
|
||||
}
|
||||
public String Gen_str_one(Object val) {
|
||||
if (fmtr == null) fmtr = Bry_fmtr.new_bry_(fmt).Compile();
|
||||
@ -50,7 +50,7 @@ public class Gfo_msg_itm implements Gfo_msg_obj {
|
||||
return tmp_bfr.Xto_str_and_clear();
|
||||
}
|
||||
else
|
||||
return String_.new_utf8_(fmt);
|
||||
return String_.new_u8(fmt);
|
||||
}
|
||||
public String Gen_str_none() {return key_str;}
|
||||
static Bry_bfr tmp_bfr = Bry_bfr.reset_(255);
|
||||
|
||||
@ -18,10 +18,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
public class Gfo_msg_itm_ {
|
||||
public static final byte Cmd_null = 0, Cmd_log = 1, Cmd_note = 2, Cmd_warn = 3, Cmd_stop = 4, Cmd_fail = 5;
|
||||
public static final byte[][] CmdBry = new byte[][] {Bry_.new_ascii_("null"), Bry_.new_ascii_("log"), Bry_.new_ascii_("note"), Bry_.new_ascii_("warn"), Bry_.new_ascii_("stop"), Bry_.new_ascii_("fail")};
|
||||
public static final byte[][] CmdBry = new byte[][] {Bry_.new_a7("null"), Bry_.new_a7("log"), Bry_.new_a7("note"), Bry_.new_a7("warn"), Bry_.new_a7("stop"), Bry_.new_a7("fail")};
|
||||
public static Gfo_msg_itm new_note_(Gfo_msg_grp owner, String key) {return new_(owner, Cmd_note, key, key);}
|
||||
public static Gfo_msg_itm new_fail_(Gfo_msg_grp owner, String key, String fmt) {return new_(owner, Cmd_warn, key, fmt);}
|
||||
public static Gfo_msg_itm new_warn_(Gfo_msg_grp owner, String key) {return new_(owner, Cmd_warn, key, key);}
|
||||
public static Gfo_msg_itm new_warn_(Gfo_msg_grp owner, String key, String fmt) {return new_(owner, Cmd_warn, key, fmt);}
|
||||
public static Gfo_msg_itm new_(Gfo_msg_grp owner, byte cmd, String key, String fmt) {return new Gfo_msg_itm(owner, Gfo_msg_grp_.Uid_next(), cmd, Bry_.new_ascii_(key), Bry_.new_ascii_(fmt), false);}
|
||||
public static Gfo_msg_itm new_(Gfo_msg_grp owner, byte cmd, String key, String fmt) {return new Gfo_msg_itm(owner, Gfo_msg_grp_.Uid_next(), cmd, Bry_.new_a7(key), Bry_.new_a7(fmt), false);}
|
||||
}
|
||||
|
||||
@ -42,7 +42,7 @@ public class Gfo_msg_root {
|
||||
public Gfo_msg_data Data_new_note_many(String owner_key, String key, String fmt, Object... vals) {return Data_new_many(Gfo_msg_itm_.Cmd_note, Bry_.Empty, -1, -1, owner_key, key, fmt, vals);}
|
||||
public Gfo_msg_data Data_new_many(byte cmd, String owner_key, String key, String fmt, Object[] vals) {return Data_new_many(cmd, Bry_.Empty, -1, -1, owner_key, key, fmt, vals);}
|
||||
public Gfo_msg_data Data_new_many(byte cmd, byte[] src, int bgn, int end, String owner_key, String key, String fmt, Object[] vals) {
|
||||
Object owner_obj = owners.Fetch(owner_key);
|
||||
Object owner_obj = owners.Get_by(owner_key);
|
||||
Gfo_msg_grp owner = null;
|
||||
if (owner_obj == null) {
|
||||
owner = New_list_by_key(owner_key);
|
||||
@ -52,7 +52,7 @@ public class Gfo_msg_root {
|
||||
owner = (Gfo_msg_grp)owner_obj;
|
||||
Gfo_msg_itm itm = (Gfo_msg_itm)owner.Subs_get_by_key(key);
|
||||
if (itm == null)
|
||||
itm = new Gfo_msg_itm(owner, uid_item_next++, cmd, Bry_.new_utf8_(key), fmt == null ? Bry_.Empty : Bry_.new_ascii_(fmt), false);
|
||||
itm = new Gfo_msg_itm(owner, uid_item_next++, cmd, Bry_.new_u8(key), fmt == null ? Bry_.Empty : Bry_.new_a7(fmt), false);
|
||||
return Data_new_many(itm, src, bgn, end, vals);
|
||||
}
|
||||
public Gfo_msg_data Data_new_many(Gfo_msg_itm itm, byte[] src, int bgn, int end, Object... vals) {return Data_get().Ctor_src_many(itm, src, bgn, end, vals);}
|
||||
@ -67,13 +67,13 @@ public class Gfo_msg_root {
|
||||
String seg = segs[i];
|
||||
Gfo_msg_grp sub_list = (Gfo_msg_grp)cur_list.Subs_get_by_key(seg);
|
||||
if (sub_list == null)
|
||||
sub_list = new Gfo_msg_grp(cur_list, uid_list_next++, Bry_.new_ascii_(key));
|
||||
sub_list = new Gfo_msg_grp(cur_list, uid_list_next++, Bry_.new_a7(key));
|
||||
cur_list = sub_list;
|
||||
}
|
||||
return cur_list;
|
||||
}
|
||||
Gfo_msg_grp root;
|
||||
OrderedHash owners = OrderedHash_.new_();
|
||||
Ordered_hash owners = Ordered_hash_.new_();
|
||||
int uid_list_next = 0;
|
||||
int uid_item_next = 0;
|
||||
public static final Gfo_msg_root _ = new Gfo_msg_root("gplx");
|
||||
|
||||
@ -19,11 +19,11 @@ package gplx;
|
||||
import java.lang.reflect.Array;
|
||||
import gplx.core.strings.*;
|
||||
public class Array_ {
|
||||
public static void Sort(Object[] obj) {ListAdp_Sorter.new_().Sort(obj, obj.length);}
|
||||
public static void Sort(Object[] obj, gplx.lists.ComparerAble comparer) {ListAdp_Sorter.new_().Sort(obj, obj.length, true, comparer);}
|
||||
public static ListAdp XtoList(Object ary) {
|
||||
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);
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
List_adp rv = List_adp_.new_();
|
||||
for (int i = 0; i < aryLen; i++)
|
||||
rv.Add(Array_.Get(ary, i));
|
||||
return rv;
|
||||
@ -71,7 +71,7 @@ public class Array_ {
|
||||
}
|
||||
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 FetchAt(Object ary, int i) {return Array.get(ary, i); }
|
||||
public static Object Get_at(Object ary, int i) {return Array.get(ary, i); }
|
||||
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);}
|
||||
|
||||
@ -25,7 +25,7 @@ public class Bool_ implements GfoInvkAble {
|
||||
public static final String N_str = "n" , Y_str = "y";
|
||||
public static final byte[] Y_bry = new byte[] {Byte_ascii.Ltr_y}, N_bry = new byte[] {Byte_ascii.Ltr_n};
|
||||
public static final String True_str = "true", False_str = "false";
|
||||
public static final byte[] True_bry = Bry_.new_ascii_(True_str), False_bry = Bry_.new_ascii_(False_str);
|
||||
public static final byte[] True_bry = Bry_.new_a7(True_str), False_bry = Bry_.new_a7(False_str);
|
||||
public static boolean cast_(Object obj) {try {return (Boolean)obj;} catch (Exception e) {throw Err_.type_mismatch_exc_(e, boolean.class, obj);}}
|
||||
public static boolean cast_or_(Object obj, boolean v) {try {return (Boolean)obj;} catch (Exception e) {Err_.Noop(e); return v;}}
|
||||
public static boolean By_int(int v) {return v != 0;}
|
||||
|
||||
@ -32,7 +32,7 @@ public class Bry_ {
|
||||
rv[i] = (byte)ary[i];
|
||||
return rv;
|
||||
}
|
||||
public static byte[] new_ascii_(String str) {
|
||||
public static byte[] new_a7(String str) {
|
||||
try {
|
||||
if (str == null) return null;
|
||||
int str_len = str.length();
|
||||
@ -47,12 +47,18 @@ public class Bry_ {
|
||||
}
|
||||
catch (Exception e) {throw Err_.err_(e, "invalid ASCII sequence; str={0}", str);}
|
||||
}
|
||||
public static byte[] new_ascii_safe_null_(String s) {return s == null ? null : new_ascii_(s);}
|
||||
public static byte[] new_ascii_lang(String s) {
|
||||
try {return s.getBytes("ASCII");}
|
||||
catch (Exception e) {throw Err_.err_(e, "unsupported encoding");}
|
||||
public static byte[] new_u8_safe(String str) {return str == null ? null : new_u8(str);}
|
||||
public static byte[] new_u8(String str) {
|
||||
try {
|
||||
int str_len = str.length();
|
||||
int bry_len = new_u8_by_len(str, str_len);
|
||||
byte[] rv = new byte[bry_len];
|
||||
new_u8_write(str, str_len, rv, 0);
|
||||
return rv;
|
||||
}
|
||||
catch (Exception e) {throw Err_.err_(e, "invalid UTF-8 sequence; s={0}", str);}
|
||||
}
|
||||
public static int new_utf8_len(String s, int s_len) {
|
||||
public static int new_u8_by_len(String s, int s_len) {
|
||||
int rv = 0;
|
||||
for (int i = 0; i < s_len; ++i) {
|
||||
char c = s.charAt(i);
|
||||
@ -67,7 +73,7 @@ public class Bry_ {
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
public static void new_utf8_write(String str, int str_len, byte[] bry, int bry_pos) {
|
||||
public static void new_u8_write(String str, int str_len, byte[] bry, int bry_pos) {
|
||||
for (int i = 0; i < str_len; ++i) {
|
||||
char c = str.charAt(i);
|
||||
if ( c < 128) {
|
||||
@ -95,21 +101,6 @@ public class Bry_ {
|
||||
}
|
||||
}
|
||||
}
|
||||
public static byte[] new_utf8__null(String str) {return str == null ? null : new_utf8_(str);}
|
||||
public static byte[] new_utf8_(String str) {
|
||||
try {
|
||||
int str_len = str.length();
|
||||
int bry_len = new_utf8_len(str, str_len);
|
||||
byte[] rv = new byte[bry_len];
|
||||
new_utf8_write(str, str_len, rv, 0);
|
||||
return rv;
|
||||
}
|
||||
catch (Exception e) {throw Err_.err_(e, "invalid UTF-8 sequence; s={0}", str);}
|
||||
}
|
||||
public static byte[] new_utf8_lang(String s) {
|
||||
try {return s.getBytes("UTF-8");}
|
||||
catch (Exception e) {throw Err_.err_(e, "unsupported encoding");}
|
||||
}
|
||||
public static byte[] Coalesce(byte[] orig, byte[] val_if_not_blank) {return Bry_.Len_eq_0(val_if_not_blank) ? orig : val_if_not_blank;}
|
||||
public static byte Get_at_end_or_fail(byte[] bry) {
|
||||
if (bry == null) throw Err_.new_("bry is null");
|
||||
@ -141,7 +132,7 @@ public class Bry_ {
|
||||
byte[][] rv = new byte[ary_len][];
|
||||
for (int i = 0; i < ary_len; i++) {
|
||||
String itm = ary[i];
|
||||
rv[i] = itm == null ? null : Bry_.new_utf8_(itm);
|
||||
rv[i] = itm == null ? null : Bry_.new_u8(itm);
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
@ -151,7 +142,7 @@ public class Bry_ {
|
||||
byte[][] rv = new byte[ary_len][];
|
||||
for (int i = 0; i < ary_len; i++) {
|
||||
Object itm = ary[i];
|
||||
rv[i] = itm == null ? null : Bry_.new_utf8_(Object_.Xto_str_strict_or_empty(itm));
|
||||
rv[i] = itm == null ? null : Bry_.new_u8(Object_.Xto_str_strict_or_empty(itm));
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
@ -190,7 +181,7 @@ public class Bry_ {
|
||||
int strAryLen = strAry.length;
|
||||
byte[][] rv = new byte[strAryLen][];
|
||||
for (int i = 0; i < strAryLen; i++)
|
||||
rv[i] = Bry_.new_utf8_(strAry[i]);
|
||||
rv[i] = Bry_.new_u8(strAry[i]);
|
||||
return rv;
|
||||
}
|
||||
public static byte[] Xto_str_lower(byte[] src, int bgn, int end) {
|
||||
@ -329,7 +320,7 @@ public class Bry_ {
|
||||
public static String MidByLenToStr(byte[] src, int bgn, int len) {
|
||||
int end = bgn + len; end = Int_.BoundEnd(end, src.length);
|
||||
byte[] ary = Bry_.Mid(src, bgn, end);
|
||||
return String_.new_utf8_(ary);
|
||||
return String_.new_u8(ary);
|
||||
}
|
||||
public static byte[] Mid_safe(byte[] src, int bgn, int end) {
|
||||
try {return Mid(src, bgn, end);}
|
||||
@ -355,7 +346,7 @@ public class Bry_ {
|
||||
return rv;
|
||||
} catch (Exception e) {
|
||||
Err err = Err_.new_("").Add("bgn", bgn).Add("end", end);
|
||||
if (src != null) err.Add("src", String_.new_utf8_len_safe_(src, bgn, 32));
|
||||
if (src != null) err.Add("src", String_.new_u8_by_len(src, bgn, 32));
|
||||
if (src == null) err.Hdr_("src is null");
|
||||
else if (bgn < 0 || bgn > src.length) err.Hdr_("invalid bgn");
|
||||
else if (end < 0 || end > src.length) err.Hdr_("invalid end");
|
||||
@ -620,7 +611,7 @@ public class Bry_ {
|
||||
public static int Xto_int(byte[] ary) {return Xto_int_or(ary, null, 0, ary.length, -1);}
|
||||
public static int Xto_int_or_fail(byte[] ary) {
|
||||
int rv = Xto_int_or(ary, null, 0, ary.length, Int_.MinValue);
|
||||
if (rv == Int_.MinValue) throw Err_.new_fmt_("could not parse to int; val={0}", String_.new_utf8_(ary));
|
||||
if (rv == Int_.MinValue) throw Err_.new_fmt_("could not parse to int; val={0}", String_.new_u8(ary));
|
||||
return rv;
|
||||
}
|
||||
public static boolean Xto_bool_by_int_or_fail(byte[] ary) {
|
||||
@ -628,7 +619,7 @@ public class Bry_ {
|
||||
switch (rv) {
|
||||
case 0: return false;
|
||||
case 1: return true;
|
||||
default: throw Err_.new_fmt_("could not parse to boolean int; val={0}", String_.new_utf8_(ary));
|
||||
default: throw Err_.new_fmt_("could not parse to boolean int; val={0}", String_.new_u8(ary));
|
||||
}
|
||||
}
|
||||
public static int Xto_int_or(byte[] ary, int or) {return Xto_int_or(ary, null, 0, ary.length, or);}
|
||||
@ -717,12 +708,12 @@ public class Bry_ {
|
||||
}
|
||||
return Xto_int_or(ary, bgn, end_num, or);
|
||||
}
|
||||
public static float XtoFloatByPos(byte[] ary, int bgn, int end) {return Float_.parse_(String_.new_utf8_(ary, bgn, end));}
|
||||
public static double Xto_double(byte[] bry) {return Double_.parse_(String_.new_utf8_(bry, 0, bry.length));}
|
||||
public static double Xto_double_or(byte[] bry, double or) {return Double_.parse_or(String_.new_utf8_(bry, 0, bry.length), or);}
|
||||
public static double XtoDoubleByPosOr(byte[] ary, int bgn, int end, double or) {return Double_.parse_or(String_.new_utf8_(ary, bgn, end), or);}
|
||||
public static double XtoDoubleByPos(byte[] ary, int bgn, int end) {return Double_.parse_(String_.new_utf8_(ary, bgn, end));}
|
||||
public static DecimalAdp XtoDecimalByPos(byte[] ary, int bgn, int end) {return DecimalAdp_.parse_(String_.new_utf8_(ary, bgn, end));}
|
||||
public static float XtoFloatByPos(byte[] ary, int bgn, int end) {return Float_.parse_(String_.new_u8(ary, bgn, end));}
|
||||
public static double Xto_double(byte[] bry) {return Double_.parse_(String_.new_u8(bry, 0, bry.length));}
|
||||
public static double Xto_double_or(byte[] bry, double or) {return Double_.parse_or(String_.new_u8(bry, 0, bry.length), or);}
|
||||
public static double XtoDoubleByPosOr(byte[] ary, int bgn, int end, double or) {return Double_.parse_or(String_.new_u8(ary, bgn, end), or);}
|
||||
public static double XtoDoubleByPos(byte[] ary, int bgn, int end) {return Double_.parse_(String_.new_u8(ary, bgn, end));}
|
||||
public static DecimalAdp XtoDecimalByPos(byte[] ary, int bgn, int end) {return DecimalAdp_.parse_(String_.new_u8(ary, bgn, end));}
|
||||
public static final byte Dlm_fld = (byte)'|', Dlm_row = (byte)'\n', Dlm_quote = (byte)'"', Dlm_null = 0, Ascii_zero = 48;
|
||||
public static final String Fmt_csvDte = "yyyyMMdd HHmmss.fff";
|
||||
public static DateAdp ReadCsvDte(byte[] ary, Int_obj_ref posRef, byte lkp) {// ASSUME: fmt = yyyyMMdd HHmmss.fff
|
||||
@ -745,11 +736,11 @@ public class Bry_ {
|
||||
f += (ary[bgn + 16] - Ascii_zero) * 100;
|
||||
f += (ary[bgn + 17] - Ascii_zero) * 10;
|
||||
f += (ary[bgn + 18] - Ascii_zero);
|
||||
if (ary[bgn + 19] != lkp) throw Err_.new_("csv date is invalid").Add("txt", String_.new_utf8_len_safe_(ary, bgn, 20));
|
||||
if (ary[bgn + 19] != lkp) throw Err_.new_("csv date is invalid").Add("txt", String_.new_u8_by_len(ary, bgn, 20));
|
||||
posRef.Val_add(19 + 1); // +1=lkp.len
|
||||
return DateAdp_.new_(y, M, d, H, m, s, f);
|
||||
}
|
||||
public static String ReadCsvStr(byte[] ary, Int_obj_ref posRef, byte lkp) {return String_.new_utf8_(ReadCsvBry(ary, posRef, lkp, true));}
|
||||
public static String ReadCsvStr(byte[] ary, Int_obj_ref posRef, byte lkp) {return String_.new_u8(ReadCsvBry(ary, posRef, lkp, true));}
|
||||
public static byte[] ReadCsvBry(byte[] ary, Int_obj_ref posRef, byte lkp) {return ReadCsvBry(ary, posRef, lkp, true);}
|
||||
public static byte[] ReadCsvBry(byte[] ary, Int_obj_ref posRef, byte lkp, boolean make) {
|
||||
int bgn = posRef.Val(), aryLen = ary.length;
|
||||
@ -758,10 +749,10 @@ public class Bry_ {
|
||||
int pos = bgn + 1; // +1 to skip quote
|
||||
if (make) bb = Bry_bfr.new_(16);
|
||||
while (true) {
|
||||
if (pos == aryLen) throw Err_.new_("endOfAry reached, but no quote found").Add("txt", String_.new_utf8_len_safe_(ary, bgn, pos));
|
||||
if (pos == aryLen) throw Err_.new_("endOfAry reached, but no quote found").Add("txt", String_.new_u8_by_len(ary, bgn, pos));
|
||||
byte b = ary[pos];
|
||||
if (b == Dlm_quote) {
|
||||
if (pos == aryLen - 1) throw Err_.new_("endOfAry reached, quote found but lkp not").Add("txt", String_.new_utf8_len_safe_(ary, bgn, pos));
|
||||
if (pos == aryLen - 1) throw Err_.new_("endOfAry reached, quote found but lkp not").Add("txt", String_.new_u8_by_len(ary, bgn, pos));
|
||||
byte next = ary[pos + 1];
|
||||
if (next == Dlm_quote) { // byte followed by quote
|
||||
if (make) bb.Add_byte(b);
|
||||
@ -771,7 +762,7 @@ public class Bry_ {
|
||||
posRef.Val_(pos + 2); // 1=endQuote;1=lkp;
|
||||
return make ? bb.Xto_bry() : Bry_.Empty;
|
||||
}
|
||||
else throw Err_.new_("quote found, but not doubled").Add("txt", String_.new_utf8_len_safe_(ary, bgn, pos + 1));
|
||||
else throw Err_.new_("quote found, but not doubled").Add("txt", String_.new_u8_by_len(ary, bgn, pos + 1));
|
||||
}
|
||||
else {
|
||||
if (make) bb.Add_byte(b);
|
||||
@ -786,7 +777,7 @@ public class Bry_ {
|
||||
return make ? Bry_.Mid(ary, bgn, i) : Bry_.Empty;
|
||||
}
|
||||
}
|
||||
throw Err_.new_("lkp failed").Add("lkp", (char)lkp).Add("txt", String_.new_utf8_len_safe_(ary, bgn, aryLen));
|
||||
throw Err_.new_("lkp failed").Add("lkp", (char)lkp).Add("txt", String_.new_u8_by_len(ary, bgn, aryLen));
|
||||
}
|
||||
}
|
||||
public static int ReadCsvInt(byte[] ary, Int_obj_ref posRef, byte lkp) {
|
||||
@ -846,7 +837,7 @@ public class Bry_ {
|
||||
public static byte[][] Split(byte[] src, byte dlm, boolean trim) {
|
||||
if (Bry_.Len_eq_0(src)) return Bry_.Ary_empty;
|
||||
int src_len = src.length, src_pos = 0, fld_bgn = 0;
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
List_adp rv = List_adp_.new_();
|
||||
while (true) {
|
||||
boolean last = src_pos == src_len;
|
||||
byte b = last ? dlm : src[src_pos];
|
||||
@ -862,7 +853,7 @@ public class Bry_ {
|
||||
if (last) break;
|
||||
++src_pos;
|
||||
}
|
||||
return (byte[][])rv.Xto_ary(byte[].class);
|
||||
return (byte[][])rv.To_ary(byte[].class);
|
||||
}
|
||||
public static byte[] Replace_create(byte[] src, byte find, byte replace) {
|
||||
byte[] rv = Bry_.Copy(src);
|
||||
@ -950,7 +941,7 @@ public class Bry_ {
|
||||
public static byte[][] Split(byte[] src, byte[] dlm) {
|
||||
if (Bry_.Len_eq_0(src)) return Bry_.Ary_empty;
|
||||
int cur_pos = 0, src_len = src.length, dlm_len = dlm.length;
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
List_adp rv = List_adp_.new_();
|
||||
while (true) {
|
||||
int find_pos = Bry_finder.Find_fwd(src, dlm, cur_pos);
|
||||
if (find_pos == Bry_.NotFound) {
|
||||
@ -961,12 +952,12 @@ public class Bry_ {
|
||||
if (find_pos == src_len) break;
|
||||
cur_pos = find_pos + dlm_len;
|
||||
}
|
||||
return (byte[][])rv.Xto_ary(byte[].class);
|
||||
return (byte[][])rv.To_ary(byte[].class);
|
||||
}
|
||||
public static byte[][] Split_lines(byte[] src) {
|
||||
if (Bry_.Len_eq_0(src)) return Bry_.Ary_empty;
|
||||
int src_len = src.length, src_pos = 0, fld_bgn = 0;
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
List_adp rv = List_adp_.new_();
|
||||
while (true) {
|
||||
boolean last = src_pos == src_len;
|
||||
byte b = last ? Byte_ascii.NewLine : src[src_pos];
|
||||
@ -987,7 +978,7 @@ public class Bry_ {
|
||||
if (last) break;
|
||||
src_pos = nxt_bgn;
|
||||
}
|
||||
return (byte[][])rv.Xto_ary(byte[].class);
|
||||
return (byte[][])rv.To_ary(byte[].class);
|
||||
}
|
||||
public static byte[] Increment_last(byte[] ary) {return Increment_last(ary, ary.length - 1);}
|
||||
public static byte[] Increment_last(byte[] ary, int end_idx) {
|
||||
|
||||
@ -23,14 +23,14 @@ public class Bry__tst {
|
||||
tst_MidByPos("abcba", 0, 1, "a");
|
||||
tst_MidByPos("abcba", 0, 2, "ab");
|
||||
tst_MidByPos("abcba", 1, 4, "bcb");
|
||||
} void tst_MidByPos(String src, int bgn, int end, String expd) {Tfds.Eq(expd, String_.new_utf8_(Bry_.Mid(Bry_.new_utf8_(src), bgn, end)));}
|
||||
} void tst_MidByPos(String src, int bgn, int end, String expd) {Tfds.Eq(expd, String_.new_u8(Bry_.Mid(Bry_.new_u8(src), bgn, end)));}
|
||||
@Test public void Replace_one() {
|
||||
tst_ReplaceOne("a" , "b" , "c" , "a");
|
||||
tst_ReplaceOne("b" , "b" , "c" , "c");
|
||||
tst_ReplaceOne("bb" , "b" , "c" , "cb");
|
||||
tst_ReplaceOne("abcd" , "bc" , "" , "ad");
|
||||
tst_ReplaceOne("abcd" , "b" , "ee" , "aeecd");
|
||||
} void tst_ReplaceOne(String src, String find, String repl, String expd) {Tfds.Eq(expd, String_.new_utf8_(Bry_.Replace_one(Bry_.new_utf8_(src), Bry_.new_utf8_(find), Bry_.new_utf8_(repl))));}
|
||||
} void tst_ReplaceOne(String src, String find, String repl, String expd) {Tfds.Eq(expd, String_.new_u8(Bry_.Replace_one(Bry_.new_u8(src), Bry_.new_u8(find), Bry_.new_u8(repl))));}
|
||||
@Test public void XtoStrBytesByInt() {
|
||||
tst_XtoStrBytesByInt(0, 0);
|
||||
tst_XtoStrBytesByInt(9, 9);
|
||||
@ -56,14 +56,14 @@ public class Bry__tst {
|
||||
tst_HasAtEnd("abc", "bd", false); // n
|
||||
tst_HasAtEnd("a", "ab", false); // exceeds_len
|
||||
}
|
||||
void tst_HasAtEnd(String src, String find, int bgn, int end, boolean expd) {Tfds.Eq(expd, Bry_.HasAtEnd(Bry_.new_utf8_(src), Bry_.new_utf8_(find), bgn, end));}
|
||||
void tst_HasAtEnd(String src, String find, boolean expd) {Tfds.Eq(expd, Bry_.HasAtEnd(Bry_.new_utf8_(src), Bry_.new_utf8_(find)));}
|
||||
void tst_HasAtEnd(String src, String find, int bgn, int end, boolean expd) {Tfds.Eq(expd, Bry_.HasAtEnd(Bry_.new_u8(src), Bry_.new_u8(find), bgn, end));}
|
||||
void tst_HasAtEnd(String src, String find, boolean expd) {Tfds.Eq(expd, Bry_.HasAtEnd(Bry_.new_u8(src), Bry_.new_u8(find)));}
|
||||
@Test public void HasAtBgn() {
|
||||
tst_HasAtBgn("y_basic" , "a|bcd|e", "b" , 2, 5, true);
|
||||
tst_HasAtBgn("y_many" , "a|bcd|e", "bcd" , 2, 5, true);
|
||||
tst_HasAtBgn("n_long" , "a|bcd|e", "bcde" , 2, 5, false);
|
||||
tst_HasAtBgn("n_pos" , "a|bcd|e", "|bc" , 2, 5, false);
|
||||
} void tst_HasAtBgn(String tst, String src, String find, int bgn, int end, boolean expd) {Tfds.Eq(expd, Bry_.HasAtBgn(Bry_.new_utf8_(src), Bry_.new_utf8_(find), bgn, end), tst);}
|
||||
} void tst_HasAtBgn(String tst, String src, String find, int bgn, int end, boolean expd) {Tfds.Eq(expd, Bry_.HasAtBgn(Bry_.new_u8(src), Bry_.new_u8(find), bgn, end), tst);}
|
||||
@Test public void Match() {
|
||||
tst_Match("abc", 0, "abc", true);
|
||||
tst_Match("abc", 2, "c", true);
|
||||
@ -74,7 +74,7 @@ public class Bry__tst {
|
||||
tst_Match("" , 0, "a", false);
|
||||
tst_Match("" , 0, "", true);
|
||||
tst_Match("ab", 0, "a", false); // FIX: "ab" should not match "a" b/c .length is different
|
||||
} void tst_Match(String src, int srcPos, String find, boolean expd) {Tfds.Eq(expd, Bry_.Match(Bry_.new_utf8_(src), srcPos, Bry_.new_utf8_(find)));}
|
||||
} void tst_Match(String src, int srcPos, String find, boolean expd) {Tfds.Eq(expd, Bry_.Match(Bry_.new_u8(src), srcPos, Bry_.new_u8(find)));}
|
||||
@Test public void ReadCsvStr() {
|
||||
tst_ReadCsvStr("a|" , "a");
|
||||
tst_ReadCsvStr("|a|", 1 , "a");
|
||||
@ -109,14 +109,14 @@ public class Bry__tst {
|
||||
tst_XtoInt("", -1);
|
||||
}
|
||||
void tst_XtoInt(String val, int expd) {tst_XtoInt(val, -1, expd);}
|
||||
void tst_XtoInt(String val, int or, int expd) {Tfds.Eq(expd, Bry_.Xto_int_or(Bry_.new_utf8_(val), or));}
|
||||
void tst_XtoInt(String val, int or, int expd) {Tfds.Eq(expd, Bry_.Xto_int_or(Bry_.new_u8(val), or));}
|
||||
void tst_XtoIntBy4Bytes(int expd, byte... ary) {Tfds.Eq(expd, Bry_.XtoIntBy4Bytes(ary), "XtoInt"); Tfds.Eq_ary(ary, Bry_.XbyInt(expd), "XbyInt");}
|
||||
void tst_ReadCsvStr(String raw, String expd) {tst_ReadCsvStr(raw, Int_obj_ref.zero_() , expd);}
|
||||
void tst_ReadCsvStr(String raw, int bgn, String expd) {tst_ReadCsvStr(raw, Int_obj_ref.new_(bgn), expd);}
|
||||
void tst_ReadCsvStr(String raw, Int_obj_ref bgnRef, String expd) {
|
||||
int bgn = bgnRef.Val();
|
||||
boolean rawHasQuotes = String_.CharAt(raw, bgn) == '\'';
|
||||
String actl = String_.Replace(Bry_.ReadCsvStr(Bry_.new_utf8_(String_.Replace(raw, "'", "\"")), bgnRef, (byte)'|'), "\"", "'");
|
||||
String actl = String_.Replace(Bry_.ReadCsvStr(Bry_.new_u8(String_.Replace(raw, "'", "\"")), bgnRef, (byte)'|'), "\"", "'");
|
||||
Tfds.Eq(expd, actl, "rv");
|
||||
if (rawHasQuotes) {
|
||||
int quoteAdj = String_.Count(actl, "'");
|
||||
@ -126,21 +126,21 @@ public class Bry__tst {
|
||||
Tfds.Eq(bgn + 1 + String_.Len(actl), bgnRef.Val(), "pos"); // +1=lkp.Len
|
||||
}
|
||||
void tst_ReadCsvStr_err(String raw) {
|
||||
try {Bry_.ReadCsvStr(Bry_.new_utf8_(String_.Replace(raw, "'", "\"")), Int_obj_ref.zero_(), (byte)'|');}
|
||||
try {Bry_.ReadCsvStr(Bry_.new_u8(String_.Replace(raw, "'", "\"")), Int_obj_ref.zero_(), (byte)'|');}
|
||||
catch (Exception e) {Err_.Noop(e); return;}
|
||||
Tfds.Fail_expdError();
|
||||
}
|
||||
@Test public void ReadCsvDte() {
|
||||
tst_ReadCsvDte("20110801 221435.987");
|
||||
} void tst_ReadCsvDte(String raw) {Tfds.Eq_date(DateAdp_.parse_fmt(raw, Bry_.Fmt_csvDte), Bry_.ReadCsvDte(Bry_.new_utf8_(raw + "|"), Int_obj_ref.zero_(), (byte)'|'));}
|
||||
} void tst_ReadCsvDte(String raw) {Tfds.Eq_date(DateAdp_.parse_fmt(raw, Bry_.Fmt_csvDte), Bry_.ReadCsvDte(Bry_.new_u8(raw + "|"), Int_obj_ref.zero_(), (byte)'|'));}
|
||||
@Test public void ReadCsvInt() {
|
||||
tst_ReadCsvInt("1234567890");
|
||||
} void tst_ReadCsvInt(String raw) {Tfds.Eq(Int_.parse_(raw), Bry_.ReadCsvInt(Bry_.new_utf8_(raw + "|"), Int_obj_ref.zero_(), (byte)'|'));}
|
||||
} void tst_ReadCsvInt(String raw) {Tfds.Eq(Int_.parse_(raw), Bry_.ReadCsvInt(Bry_.new_u8(raw + "|"), Int_obj_ref.zero_(), (byte)'|'));}
|
||||
@Test public void Trim() {
|
||||
Trim_tst("a b c", 1, 4, "b");
|
||||
Trim_tst("a c", 1, 3, "");
|
||||
Trim_tst(" ", 0, 2, "");
|
||||
} void Trim_tst(String raw, int bgn, int end, String expd) {Tfds.Eq(expd, String_.new_utf8_(Bry_.Trim(Bry_.new_utf8_(raw), bgn, end)));}
|
||||
} void Trim_tst(String raw, int bgn, int end, String expd) {Tfds.Eq(expd, String_.new_u8(Bry_.Trim(Bry_.new_u8(raw), bgn, end)));}
|
||||
@Test public void Xto_int_lax() {
|
||||
tst_Xto_int_lax("12a", 12);
|
||||
tst_Xto_int_lax("1", 1);
|
||||
@ -148,14 +148,14 @@ public class Bry__tst {
|
||||
tst_Xto_int_lax("a", 0);
|
||||
tst_Xto_int_lax("-1", -1);
|
||||
}
|
||||
private void tst_Xto_int_lax(String val, int expd) {Tfds.Eq(expd, Bry_.Xto_int_or_lax(Bry_.new_utf8_(val), 0, String_.Len(val), 0));}
|
||||
private void tst_Xto_int_lax(String val, int expd) {Tfds.Eq(expd, Bry_.Xto_int_or_lax(Bry_.new_u8(val), 0, String_.Len(val), 0));}
|
||||
@Test public void Xto_int_or_trim() {
|
||||
tst_Xto_int_trim("123 " , 123);
|
||||
tst_Xto_int_trim(" 123" , 123);
|
||||
tst_Xto_int_trim(" 123 " , 123);
|
||||
tst_Xto_int_trim(" 1 3 " , -1);
|
||||
}
|
||||
private void tst_Xto_int_trim(String val, int expd) {Tfds.Eq(expd, Bry_.Xto_int_or_trim(Bry_.new_utf8_(val), 0, String_.Len(val), -1));}
|
||||
private void tst_Xto_int_trim(String val, int expd) {Tfds.Eq(expd, Bry_.Xto_int_or_trim(Bry_.new_u8(val), 0, String_.Len(val), -1));}
|
||||
@Test public void Compare() {
|
||||
tst_Compare("abcde", 0, 1, "abcde", 0, 1, CompareAble_.Same);
|
||||
tst_Compare("abcde", 0, 1, "abcde", 1, 2, CompareAble_.Less);
|
||||
@ -163,7 +163,7 @@ public class Bry__tst {
|
||||
tst_Compare("abcde", 0, 1, "abcde", 0, 2, CompareAble_.Less);
|
||||
tst_Compare("abcde", 0, 2, "abcde", 0, 1, CompareAble_.More);
|
||||
tst_Compare("abcde", 2, 3, "abçde", 2, 3, CompareAble_.Less);
|
||||
} void tst_Compare(String lhs, int lhs_bgn, int lhs_end, String rhs, int rhs_bgn, int rhs_end, int expd) {Tfds.Eq(expd, Bry_.Compare(Bry_.new_utf8_(lhs), lhs_bgn, lhs_end, Bry_.new_utf8_(rhs), rhs_bgn, rhs_end));}
|
||||
} void tst_Compare(String lhs, int lhs_bgn, int lhs_end, String rhs, int rhs_bgn, int rhs_end, int expd) {Tfds.Eq(expd, Bry_.Compare(Bry_.new_u8(lhs), lhs_bgn, lhs_end, Bry_.new_u8(rhs), rhs_bgn, rhs_end));}
|
||||
@Test public void Increment_last() {
|
||||
tst_IncrementLast(ary_(0), ary_(1));
|
||||
tst_IncrementLast(ary_(0, 255), ary_(1, 0));
|
||||
@ -183,14 +183,14 @@ public class Bry__tst {
|
||||
tst_Split("" , Byte_ascii.Pipe);
|
||||
}
|
||||
void tst_Split(String raw_str, byte dlm, String... expd) {
|
||||
byte[][] actl_bry = Bry_.Split(Bry_.new_ascii_(raw_str), dlm);
|
||||
byte[][] actl_bry = Bry_.Split(Bry_.new_a7(raw_str), dlm);
|
||||
Tfds.Eq_ary_str(expd, String_.Ary(actl_bry));
|
||||
}
|
||||
@Test public void Replace_between() {
|
||||
tst_Replace_between("a[0]b" , "[", "]", "0", "a0b");
|
||||
tst_Replace_between("a[0]b[1]c" , "[", "]", "0", "a0b0c");
|
||||
tst_Replace_between("a[0b" , "[", "]", "0", "a[0b");
|
||||
} public void tst_Replace_between(String src, String bgn, String end, String repl, String expd) {Tfds.Eq(expd, String_.new_ascii_(Bry_.Replace_between(Bry_.new_ascii_(src), Bry_.new_ascii_(bgn), Bry_.new_ascii_(end), Bry_.new_ascii_(repl))));}
|
||||
} public void tst_Replace_between(String src, String bgn, String end, String repl, String expd) {Tfds.Eq(expd, String_.new_a7(Bry_.Replace_between(Bry_.new_a7(src), Bry_.new_a7(bgn), Bry_.new_a7(end), Bry_.new_a7(repl))));}
|
||||
@Test public void Replace() {
|
||||
Bry_bfr tmp_bfr = Bry_bfr.new_();
|
||||
tst_Replace(tmp_bfr, "a0b" , "0", "00", "a00b"); // 1 -> 1
|
||||
@ -202,14 +202,14 @@ public class Bry__tst {
|
||||
tst_Replace(tmp_bfr, "a0b0" , "b1", "b2", "a0b0"); // false match; EOS
|
||||
}
|
||||
public void tst_Replace(Bry_bfr tmp_bfr, String src, String bgn, String repl, String expd) {
|
||||
Tfds.Eq(expd, String_.new_ascii_(Bry_.Replace(tmp_bfr, Bry_.new_ascii_(src), Bry_.new_ascii_(bgn), Bry_.new_ascii_(repl))));
|
||||
Tfds.Eq(expd, String_.new_a7(Bry_.Replace(tmp_bfr, Bry_.new_a7(src), Bry_.new_a7(bgn), Bry_.new_a7(repl))));
|
||||
}
|
||||
@Test public void Split_bry() {
|
||||
Split_bry_tst("a|b|c|" , "|" , String_.Ary("a", "b", "c"));
|
||||
Split_bry_tst("a|" , "|" , String_.Ary("a"));
|
||||
}
|
||||
void Split_bry_tst(String src, String dlm, String[] expd) {
|
||||
String[] actl = String_.Ary(Bry_.Split(Bry_.new_ascii_(src), Bry_.new_ascii_(dlm)));
|
||||
String[] actl = String_.Ary(Bry_.Split(Bry_.new_a7(src), Bry_.new_a7(dlm)));
|
||||
Tfds.Eq_ary_str(expd, actl);
|
||||
}
|
||||
@Test public void Split_lines() {
|
||||
@ -219,13 +219,13 @@ public class Bry__tst {
|
||||
Tst_split_lines("a\rb" , "a", "b"); // cr only
|
||||
}
|
||||
void Tst_split_lines(String src, String... expd) {
|
||||
Tfds.Eq_ary(expd, New_ary(Bry_.Split_lines(Bry_.new_ascii_(src))));
|
||||
Tfds.Eq_ary(expd, New_ary(Bry_.Split_lines(Bry_.new_a7(src))));
|
||||
}
|
||||
String[] New_ary(byte[][] lines) {
|
||||
int len = lines.length;
|
||||
String[] rv = new String[len];
|
||||
for (int i = 0; i < len; i++)
|
||||
rv[i] = String_.new_utf8_(lines[i]);
|
||||
rv[i] = String_.new_u8(lines[i]);
|
||||
return rv;
|
||||
}
|
||||
@Test public void Match_bwd_any() {
|
||||
@ -237,7 +237,7 @@ public class Bry__tst {
|
||||
Tst_match_bwd_any("abc", 1, 0, "ab", true);
|
||||
}
|
||||
void Tst_match_bwd_any(String src, int src_end, int src_bgn, String find, boolean expd) {
|
||||
Tfds.Eq(expd, Bry_.Match_bwd_any(Bry_.new_ascii_(src), src_end, src_bgn, Bry_.new_ascii_(find)));
|
||||
Tfds.Eq(expd, Bry_.Match_bwd_any(Bry_.new_a7(src), src_end, src_bgn, Bry_.new_a7(find)));
|
||||
}
|
||||
private Bry__fxt fxt = new Bry__fxt();
|
||||
@Test public void Trim_end() {
|
||||
@ -247,17 +247,17 @@ public class Bry__tst {
|
||||
fxt.Test_trim_end("" , Byte_ascii.Space, ""); // empty
|
||||
}
|
||||
@Test public void new_ascii_() {
|
||||
fxt.Test_new_ascii_("a" , Bry_.ints_(97)); // one
|
||||
fxt.Test_new_ascii_("abc" , Bry_.ints_(97, 98, 99)); // many
|
||||
fxt.Test_new_ascii_("" , Bry_.Empty); // none
|
||||
fxt.Test_new_ascii_("¢€𤭢" , Bry_.ints_(63, 63, 63, 63)); // non-ascii -> ?
|
||||
fxt.Test_new_a7("a" , Bry_.ints_(97)); // one
|
||||
fxt.Test_new_a7("abc" , Bry_.ints_(97, 98, 99)); // many
|
||||
fxt.Test_new_a7("" , Bry_.Empty); // none
|
||||
fxt.Test_new_a7("¢€𤭢" , Bry_.ints_(63, 63, 63, 63)); // non-ascii -> ?
|
||||
}
|
||||
@Test public void new_utf8_() {
|
||||
fxt.Test_new_utf8_("a" , Bry_.ints_(97)); // one
|
||||
fxt.Test_new_utf8_("abc" , Bry_.ints_(97, 98, 99)); // many
|
||||
fxt.Test_new_utf8_("¢" , Bry_.ints_(194, 162)); // bry_len=2; cent
|
||||
fxt.Test_new_utf8_("€" , Bry_.ints_(226, 130, 172)); // bry_len=3; euro
|
||||
fxt.Test_new_utf8_("𤭢" , Bry_.ints_(240, 164, 173, 162)); // bry_len=3; example from en.w:UTF-8
|
||||
@Test public void new_u8() {
|
||||
fxt.Test_new_u8("a" , Bry_.ints_(97)); // one
|
||||
fxt.Test_new_u8("abc" , Bry_.ints_(97, 98, 99)); // many
|
||||
fxt.Test_new_u8("¢" , Bry_.ints_(194, 162)); // bry_len=2; cent
|
||||
fxt.Test_new_u8("€" , Bry_.ints_(226, 130, 172)); // bry_len=3; euro
|
||||
fxt.Test_new_u8("𤭢" , Bry_.ints_(240, 164, 173, 162)); // bry_len=3; example from en.w:UTF-8
|
||||
}
|
||||
@Test public void Add_w_dlm() {
|
||||
fxt.Test_add_w_dlm(Byte_ascii.Pipe, String_.Ary("a", "b", "c") , "a|b|c"); // basic
|
||||
@ -270,11 +270,11 @@ public class Bry__tst {
|
||||
}
|
||||
class Bry__fxt {
|
||||
public void Test_trim_end(String raw, byte trim, String expd) {
|
||||
byte[] raw_bry = Bry_.new_ascii_(raw);
|
||||
Tfds.Eq(expd, String_.new_utf8_(Bry_.Trim_end(raw_bry, trim, raw_bry.length)));
|
||||
byte[] raw_bry = Bry_.new_a7(raw);
|
||||
Tfds.Eq(expd, String_.new_u8(Bry_.Trim_end(raw_bry, trim, raw_bry.length)));
|
||||
}
|
||||
public void Test_new_utf8_(String raw, byte[] expd) {Tfds.Eq_ary(expd, Bry_.new_utf8_(raw));}
|
||||
public void Test_new_ascii_(String raw, byte[] expd) {Tfds.Eq_ary(expd, Bry_.new_ascii_(raw));}
|
||||
public void Test_add_w_dlm(String dlm, String[] itms, String expd) {Tfds.Eq(expd, String_.new_utf8_(Bry_.Add_w_dlm(Bry_.new_utf8_(dlm), Bry_.Ary(itms))));}
|
||||
public void Test_add_w_dlm(byte dlm, String[] itms, String expd) {Tfds.Eq(expd, String_.new_utf8_(Bry_.Add_w_dlm(dlm, Bry_.Ary(itms))));}
|
||||
public void Test_new_u8(String raw, byte[] expd) {Tfds.Eq_ary(expd, Bry_.new_u8(raw));}
|
||||
public void Test_new_a7(String raw, byte[] expd) {Tfds.Eq_ary(expd, Bry_.new_a7(raw));}
|
||||
public void Test_add_w_dlm(String dlm, String[] itms, String expd) {Tfds.Eq(expd, String_.new_u8(Bry_.Add_w_dlm(Bry_.new_u8(dlm), Bry_.Ary(itms))));}
|
||||
public void Test_add_w_dlm(byte dlm, String[] itms, String expd) {Tfds.Eq(expd, String_.new_u8(Bry_.Add_w_dlm(dlm, Bry_.Ary(itms))));}
|
||||
}
|
||||
|
||||
@ -46,7 +46,7 @@ public class Bry_bfr {
|
||||
this.Clear();
|
||||
this.Mkr_rls();
|
||||
}
|
||||
public String To_str_and_rls() {return String_.new_utf8_(To_bry_and_rls());}
|
||||
public String To_str_and_rls() {return String_.new_u8(To_bry_and_rls());}
|
||||
public byte[] To_bry_and_rls() {
|
||||
byte[] rv = null;
|
||||
synchronized (bfr) {
|
||||
@ -89,7 +89,7 @@ public class Bry_bfr {
|
||||
}
|
||||
public Bry_bfr Add_mid(byte[] val, int bgn, int end) {
|
||||
int len = end - bgn;
|
||||
if (len < 0) throw Err_.new_fmt_("negative len; bgn={0} end={1} excerpt={2}", bgn, end, String_.new_utf8_len_safe_(val, bgn, bgn + 16)); // NOTE: check for invalid end < bgn, else difficult to debug errors later; DATE:2014-05-11
|
||||
if (len < 0) throw Err_.new_fmt_("negative len; bgn={0} end={1} excerpt={2}", bgn, end, 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);
|
||||
@ -162,10 +162,10 @@ public class Bry_bfr {
|
||||
public Bry_bfr Add_byte_nl() {return Add_byte(Byte_ascii.NewLine);}
|
||||
public Bry_bfr Add_byte_dot() {return Add_byte(Byte_ascii.Dot);}
|
||||
public Bry_bfr Add_byte(byte val) {
|
||||
int newPos = bfr_len + 1;
|
||||
if (newPos > bfr_max) Resize(bfr_len * 2);
|
||||
int new_pos = bfr_len + 1;
|
||||
if (new_pos > bfr_max) Resize(bfr_len * 2);
|
||||
bfr[bfr_len] = val;
|
||||
bfr_len = newPos;
|
||||
bfr_len = new_pos;
|
||||
return this;
|
||||
}
|
||||
public Bry_bfr Add_byte_repeat(byte b, int len) {
|
||||
@ -180,13 +180,13 @@ public class Bry_bfr {
|
||||
this.Add_byte(b);
|
||||
return this;
|
||||
}
|
||||
public Bry_bfr Add_utf8_int(int val) {
|
||||
public Bry_bfr Add_u8_int(int val) {
|
||||
if (bfr_len + 4 > bfr_max) Resize((bfr_max + 4) * 2);
|
||||
int utf8_len = gplx.intl.Utf16_.Encode_int(val, bfr, bfr_len);
|
||||
bfr_len += utf8_len;
|
||||
return this;
|
||||
}
|
||||
public Bry_bfr Add_bool(boolean v) {return Add(v ? Const_bool_true : Const_bool_false);} public static final byte[] Const_bool_true = Bry_.new_ascii_("true"), Const_bool_false = Bry_.new_ascii_("false");
|
||||
public Bry_bfr Add_bool(boolean v) {return Add(v ? Const_bool_true : Const_bool_false);} public static final byte[] Const_bool_true = Bry_.new_a7("true"), Const_bool_false = Bry_.new_a7("false");
|
||||
public Bry_bfr Add_int_bool(boolean v) {return Add_int_fixed(v ? 1 : 0, 1);}
|
||||
public Bry_bfr Add_int_variable(int val) {
|
||||
int log10 = Int_.Log10(val);
|
||||
@ -256,8 +256,6 @@ public class Bry_bfr {
|
||||
}
|
||||
return this;
|
||||
}
|
||||
public Bry_bfr Add_bry_escape_by_doubling(byte quote_byte, byte[] val) {return Add_bry_escape(quote_byte, quote_byte, val, 0, val.length);}
|
||||
public Bry_bfr Add_bry_escape(byte quote_byte, byte escape_byte, byte[] val, int bgn, int end) {return Add_bry_escape(quote_byte, new byte[] {escape_byte}, val, bgn, end);}
|
||||
public Bry_bfr Add_bry_escape(byte quote_byte, byte[] escape, byte[] val, int bgn, int end) { // used for xml_wtr; DATE:2015-04-09
|
||||
boolean clean = true; // add with chunks of bytes instead of one-by-one
|
||||
for (int i = bgn; i < end; ++i) {
|
||||
@ -267,35 +265,33 @@ public class Bry_bfr {
|
||||
clean = false;
|
||||
this.Add_mid(val, bgn, i);
|
||||
this.Add(escape);
|
||||
this.Add_byte(quote_byte);
|
||||
}
|
||||
else {}
|
||||
}
|
||||
else {
|
||||
if (b == quote_byte)
|
||||
this.Add(escape);
|
||||
this.Add_byte(b);
|
||||
if (b == quote_byte) this.Add(escape);
|
||||
else this.Add_byte(b);
|
||||
}
|
||||
}
|
||||
if (clean)
|
||||
Add(val);
|
||||
return this;
|
||||
}
|
||||
public Bry_bfr Add_str(String v) {return Add_str_utf8(v);}
|
||||
public Bry_bfr Add_str_utf8(String str) {
|
||||
public Bry_bfr Add_str(String v) {return Add_str_u8(v);}
|
||||
public Bry_bfr Add_str_u8(String str) {
|
||||
try {
|
||||
int str_len = str.length();
|
||||
int bry_len = Bry_.new_utf8_len(str, str_len);
|
||||
int bry_len = Bry_.new_u8_by_len(str, str_len);
|
||||
if (bfr_len + bry_len > bfr_max) Resize((bfr_max + bry_len) * 2);
|
||||
Bry_.new_utf8_write(str, str_len, bfr, bfr_len);
|
||||
Bry_.new_u8_write(str, str_len, bfr, bfr_len);
|
||||
bfr_len += bry_len;
|
||||
return this;
|
||||
}
|
||||
catch (Exception e) {throw Err_.err_(e, "invalid UTF-8 sequence; str={0}", str);}
|
||||
}
|
||||
public Bry_bfr Add_str_ascii(String str) {
|
||||
public Bry_bfr Add_str_a7(String str) {
|
||||
try {
|
||||
int bry_len = str.length();
|
||||
int bry_len = str.length();
|
||||
if (bfr_len + bry_len > bfr_max) Resize((bfr_max + bry_len) * 2);
|
||||
for (int i = 0; i < bry_len; ++i) {
|
||||
char c = str.charAt(i);
|
||||
@ -377,7 +373,7 @@ public class Bry_bfr {
|
||||
public Bry_bfr Add_str_pad_space_bgn(String v, int pad_max) {return Add_str_pad_space(v, pad_max, Bool_.N);}
|
||||
public Bry_bfr Add_str_pad_space_end(String v, int pad_max) {return Add_str_pad_space(v, pad_max, Bool_.Y);}
|
||||
Bry_bfr Add_str_pad_space(String v, int pad_max, boolean pad_end) {
|
||||
byte[] v_bry = Bry_.new_utf8_(v);
|
||||
byte[] v_bry = Bry_.new_u8(v);
|
||||
if (pad_end) Add(v_bry);
|
||||
int pad_len = pad_max - v_bry.length;
|
||||
if (pad_len > 0)
|
||||
@ -493,10 +489,10 @@ public class Bry_bfr {
|
||||
if (reset > 0) Reset_if_gt(reset);
|
||||
return rv;
|
||||
}
|
||||
public String Xto_str() {return String_.new_utf8_(Xto_bry());}
|
||||
public String Xto_str_by_pos(int bgn, int end) {return String_.new_utf8_(Xto_bry(), bgn, end);}
|
||||
public String Xto_str_and_clear() {return String_.new_utf8_(Xto_bry_and_clear());}
|
||||
public String Xto_str_and_clear_and_trim() {return String_.new_utf8_(Xto_bry_and_clear_and_trim());}
|
||||
public String Xto_str() {return String_.new_u8(Xto_bry());}
|
||||
public String Xto_str_by_pos(int bgn, int end) {return String_.new_u8(Xto_bry(), bgn, end);}
|
||||
public String Xto_str_and_clear() {return String_.new_u8(Xto_bry_and_clear());}
|
||||
public String Xto_str_and_clear_and_trim() {return String_.new_u8(Xto_bry_and_clear_and_trim());}
|
||||
public int XtoIntAndClear(int or) {int rv = XtoInt(or); this.Clear(); return rv;}
|
||||
public int XtoInt(int or) {
|
||||
switch (bfr_len) {
|
||||
|
||||
@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
import org.junit.*;
|
||||
public class Bry_bfr_tst {
|
||||
Bry_bfr bb = Bry_bfr.new_(16);
|
||||
private Bry_bfr bb = Bry_bfr.new_(16);
|
||||
@Before public void setup() {bb.Clear();} private ByteAryBfr_fxt fxt = new ByteAryBfr_fxt();
|
||||
@Test public void AddByte() {
|
||||
bb = Bry_bfr.new_(2); // NOTE: make sure auto-expands
|
||||
@ -38,8 +38,8 @@ public class Bry_bfr_tst {
|
||||
if (String_.Len(s) == 1)
|
||||
bb.Add_byte((byte)String_.CharAt(s, 0));
|
||||
else
|
||||
bb.Add(Bry_.new_utf8_(s));
|
||||
Tfds.Eq(expdStr, String_.new_utf8_(bb.Xto_bry()));
|
||||
bb.Add(Bry_.new_u8(s));
|
||||
Tfds.Eq(expdStr, String_.new_u8(bb.Xto_bry()));
|
||||
Tfds.Eq(expdLen, bb.Bfr_max());
|
||||
}
|
||||
@Test public void Add_dte() {
|
||||
@ -47,7 +47,7 @@ public class Bry_bfr_tst {
|
||||
}
|
||||
void tst_AddDte(String raw) {
|
||||
bb.Add_dte(DateAdp_.parse_fmt(raw, Bry_.Fmt_csvDte));
|
||||
Tfds.Eq(raw, String_.new_utf8_(bb.Xto_bry()));
|
||||
Tfds.Eq(raw, String_.new_u8(bb.Xto_bry()));
|
||||
}
|
||||
@Test public void Add_int_variable() {
|
||||
Add_int_variable(-1);
|
||||
@ -64,12 +64,12 @@ public class Bry_bfr_tst {
|
||||
}
|
||||
void tst_Add_float(float v) {
|
||||
bb.Add_float(v);
|
||||
Tfds.Eq(v, Float_.parse_(String_.new_utf8_(bb.Xto_bry())));
|
||||
Tfds.Eq(v, Float_.parse_(String_.new_u8(bb.Xto_bry())));
|
||||
}
|
||||
void Add_int_variable(int val) {
|
||||
bb.Clear();
|
||||
bb.Add_int_variable(val);
|
||||
Tfds.Eq(val, Int_.parse_(String_.new_utf8_(bb.Xto_bry())));
|
||||
Tfds.Eq(val, Int_.parse_(String_.new_u8(bb.Xto_bry())));
|
||||
}
|
||||
@Test public void Add_int_fixed_len3() {tst_Add_int_fixed(123, 3, "123");}
|
||||
@Test public void Add_int_fixed_pad_1() {tst_Add_int_fixed(2, 1, "2");}
|
||||
@ -79,7 +79,7 @@ public class Bry_bfr_tst {
|
||||
@Test public void Add_int_fixed_neg_pad1() {tst_Add_int_fixed(-2, 1, "-");}
|
||||
@Test public void Add_int_fixed_chop_1() {tst_Add_int_fixed(123, 1, "3");}
|
||||
@Test public void Add_int_fixed_chop_neg() {tst_Add_int_fixed(-21, 2, "-1");}
|
||||
void tst_Add_int_fixed(int val, int digits, String expd) {Tfds.Eq(expd, String_.new_utf8_(bb.Add_int_fixed(val, digits).Xto_bry()));}
|
||||
void tst_Add_int_fixed(int val, int digits, String expd) {Tfds.Eq(expd, String_.new_u8(bb.Add_int_fixed(val, digits).Xto_bry()));}
|
||||
@Test public void Add_long_fixed_len3() {tst_Add_long_fixed(123, 3, "123");}
|
||||
@Test public void Add_long_fixed_pad_1() {tst_Add_long_fixed(2, 1, "2");}
|
||||
@Test public void Add_long_fixed_pad_2() {tst_Add_long_fixed(2, 2, "02");}
|
||||
@ -89,7 +89,7 @@ public class Bry_bfr_tst {
|
||||
@Test public void Add_long_fixed_chop_1() {tst_Add_long_fixed(123, 1, "3");}
|
||||
@Test public void Add_long_fixed_chop_neg() {tst_Add_long_fixed(-21, 2, "-1");}
|
||||
@Test public void Add_long_fixed_large() {tst_Add_long_fixed(123456789012345L, 15, "123456789012345");}
|
||||
void tst_Add_long_fixed(long val, int digits, String expd) {Tfds.Eq(expd, String_.new_utf8_(bb.Add_long_fixed(val, digits).Xto_bry()));}
|
||||
void tst_Add_long_fixed(long val, int digits, String expd) {Tfds.Eq(expd, String_.new_u8(bb.Add_long_fixed(val, digits).Xto_bry()));}
|
||||
@Test public void AddDte_short() {
|
||||
tst_AddDte_short("2010-08-26T22:38:36Z");
|
||||
}
|
||||
@ -133,7 +133,7 @@ public class Bry_bfr_tst {
|
||||
}
|
||||
void tst_XtoAryAndClearAndTrim(String raw, String expd) {
|
||||
bb.Add_str(raw);
|
||||
Tfds.Eq(expd, String_.new_utf8_(bb.Xto_bry_and_clear_and_trim()));
|
||||
Tfds.Eq(expd, String_.new_u8(bb.Xto_bry_and_clear_and_trim()));
|
||||
}
|
||||
@Test public void XtoInt() {
|
||||
tst_XtoInt("123", 123);
|
||||
@ -216,11 +216,11 @@ class ByteAryBfr_fxt {
|
||||
}
|
||||
public void Test_Add_int_pad_bgn(byte pad_byte, int str_len, int val, String expd) {Tfds.Eq(expd, bfr.Add_int_pad_bgn(pad_byte, str_len, val).Xto_str_and_clear());}
|
||||
public void Test_Add_bry_escape(String val, String expd) {
|
||||
byte[] val_bry = Bry_.new_utf8_(val);
|
||||
Tfds.Eq(expd, bfr.Add_bry_escape(Byte_ascii.Apos, Byte_ascii.Apos, val_bry, 0, val_bry.length).Xto_str_and_clear());
|
||||
byte[] val_bry = Bry_.new_u8(val);
|
||||
Tfds.Eq(expd, bfr.Add_bry_escape(Byte_ascii.Apos, Byte_.Ary(Byte_ascii.Apos, Byte_ascii.Apos), val_bry, 0, val_bry.length).Xto_str_and_clear());
|
||||
}
|
||||
public void Test_Insert_at(String init, int pos, String val, String expd) {Tfds.Eq(expd, bfr.Add_str(init).Insert_at(pos, Bry_.new_utf8_(val)).Xto_str_and_clear());}
|
||||
public void Test_Insert_at(String init, int pos, String val, int val_bgn, int val_end, String expd) {Tfds.Eq(expd, bfr.Add_str(init).Insert_at(pos, Bry_.new_utf8_(val), val_bgn, val_end).Xto_str_and_clear());}
|
||||
public void Test_Insert_at(String init, int pos, String val, String expd) {Tfds.Eq(expd, bfr.Add_str(init).Insert_at(pos, Bry_.new_u8(val)).Xto_str_and_clear());}
|
||||
public void Test_Insert_at(String init, int pos, String val, int val_bgn, int val_end, String expd) {Tfds.Eq(expd, bfr.Add_str(init).Insert_at(pos, Bry_.new_u8(val), val_bgn, val_end).Xto_str_and_clear());}
|
||||
public void Test_Delete_rng(String init, int bgn, int end, String expd) {Tfds.Eq(expd, bfr.Add_str(init).Delete_rng(bgn, end).Xto_str_and_clear());}
|
||||
public void Test_Delete_rng_to_bgn(String init, int pos, String expd) {Tfds.Eq(expd, bfr.Add_str(init).Delete_rng_to_bgn(pos).Xto_str_and_clear());}
|
||||
public void Test_Delete_rng_to_end(String init, int pos, String expd) {Tfds.Eq(expd, bfr.Add_str(init).Delete_rng_to_end(pos).Xto_str_and_clear());}
|
||||
|
||||
@ -62,16 +62,16 @@ public class Bry_finder_tst {
|
||||
}
|
||||
}
|
||||
class Bry_finder_fxt {
|
||||
public void Test_Find_fwd(String src, String lkp, int bgn, int expd) {Tfds.Eq(expd, Bry_finder.Find_fwd(Bry_.new_utf8_(src), Bry_.new_utf8_(lkp), bgn));}
|
||||
public void Test_Find_bwd(String src, String lkp, int bgn, int expd) {Tfds.Eq(expd, Bry_finder.Find_bwd(Bry_.new_utf8_(src), Bry_.new_utf8_(lkp), bgn));}
|
||||
public void Test_Find_bwd_1st_ws_tst(String src, int pos, int expd) {Tfds.Eq(expd, Bry_finder.Find_bwd_last_ws(Bry_.new_ascii_(src), pos));}
|
||||
public void Test_Find_fwd(String src, String lkp, int bgn, int expd) {Tfds.Eq(expd, Bry_finder.Find_fwd(Bry_.new_u8(src), Bry_.new_u8(lkp), bgn));}
|
||||
public void Test_Find_bwd(String src, String lkp, int bgn, int expd) {Tfds.Eq(expd, Bry_finder.Find_bwd(Bry_.new_u8(src), Bry_.new_u8(lkp), bgn));}
|
||||
public void Test_Find_bwd_1st_ws_tst(String src, int pos, int expd) {Tfds.Eq(expd, Bry_finder.Find_bwd_last_ws(Bry_.new_a7(src), pos));}
|
||||
public void Test_Trim_bwd_space_tab(String raw_str, int expd) {
|
||||
byte[] raw_bry = Bry_.new_utf8_(raw_str);
|
||||
byte[] raw_bry = Bry_.new_u8(raw_str);
|
||||
int actl = Bry_finder.Trim_bwd_space_tab(raw_bry, raw_bry.length, 0);
|
||||
Tfds.Eq(expd, actl, raw_str);
|
||||
}
|
||||
public void Test_Trim_fwd_space_tab(String raw_str, int expd) {
|
||||
byte[] raw_bry = Bry_.new_utf8_(raw_str);
|
||||
byte[] raw_bry = Bry_.new_u8(raw_str);
|
||||
int actl = Bry_finder.Trim_fwd_space_tab(raw_bry, 0, raw_bry.length);
|
||||
Tfds.Eq(expd, actl, raw_str);
|
||||
}
|
||||
|
||||
@ -21,16 +21,16 @@ public class Bry_fmtr {
|
||||
public byte[] Fmt() {return fmt;} private byte[] fmt = Bry_.Empty;
|
||||
public boolean Fmt_null() {return fmt.length == 0;}
|
||||
public Bry_fmtr_eval_mgr Eval_mgr() {return eval_mgr;} public Bry_fmtr Eval_mgr_(Bry_fmtr_eval_mgr v) {eval_mgr = v; return this;} Bry_fmtr_eval_mgr eval_mgr = Bry_fmtr_eval_mgr_gfs._;
|
||||
public Bry_fmtr Fmt_(byte[] v) {fmt = v; dirty = true; return this;} public Bry_fmtr Fmt_(String v) {return Fmt_(Bry_.new_utf8_(v));}
|
||||
public Bry_fmtr Fmt_(byte[] v) {fmt = v; dirty = true; return this;} public Bry_fmtr Fmt_(String v) {return Fmt_(Bry_.new_u8(v));}
|
||||
public Bry_fmtr Keys_(String... ary) {
|
||||
if (keys == null) keys = HashAdp_.new_();
|
||||
if (keys == null) keys = Hash_adp_.new_();
|
||||
else keys.Clear();
|
||||
int ary_len = ary.length;
|
||||
for (int i = 0; i < ary_len; i++)
|
||||
keys.Add(Bry_obj_ref.new_(Bry_.new_utf8_(ary[i])), Int_obj_val.new_(i));
|
||||
keys.Add(Bry_obj_ref.new_(Bry_.new_u8(ary[i])), Int_obj_val.new_(i));
|
||||
dirty = true;
|
||||
return this;
|
||||
} HashAdp keys = null;
|
||||
} Hash_adp keys = null;
|
||||
public void Bld_bfr(Bry_bfr bfr, byte[]... args) {
|
||||
if (dirty) Compile();
|
||||
int args_len = args.length;
|
||||
@ -116,7 +116,7 @@ public class Bry_fmtr {
|
||||
}
|
||||
return rv.XtoStr();
|
||||
} private Bry_fmtr_itm[] itms; int itms_len;
|
||||
public byte[] Missing_bgn() {return missing_bgn;} public Bry_fmtr Missing_bgn_(byte[] v) {missing_bgn = v; return this;} private byte[] missing_bgn = missing_bgn_static; static byte[] missing_bgn_static = Bry_.new_utf8_("~{"), missing_end_static = Bry_.new_utf8_("}");
|
||||
public byte[] Missing_bgn() {return missing_bgn;} public Bry_fmtr Missing_bgn_(byte[] v) {missing_bgn = v; return this;} private byte[] missing_bgn = missing_bgn_static; static byte[] missing_bgn_static = Bry_.new_u8("~{"), missing_end_static = Bry_.new_u8("}");
|
||||
public byte[] Missing_end() {return missing_end;} public Bry_fmtr Missing_end_(byte[] v) {missing_end = v; return this;} private byte[] missing_end = missing_end_static;
|
||||
public int Missing_adj() {return missing_adj;} public Bry_fmtr Missing_adj_(int v) {missing_adj = v; return this;} int missing_adj;
|
||||
public boolean Fail_when_invalid_escapes() {return fail_when_invalid_escapes;} public Bry_fmtr Fail_when_invalid_escapes_(boolean v) {fail_when_invalid_escapes = v; return this;} private boolean fail_when_invalid_escapes = true;
|
||||
@ -127,7 +127,7 @@ public class Bry_fmtr {
|
||||
byte[] trg_bry = new byte[fmt_len]; int trg_pos = 0;
|
||||
boolean lkp_is_active = false, lkp_is_numeric = true;
|
||||
byte nxt_byte, tmp_byte;
|
||||
ListAdp list = ListAdp_.new_();
|
||||
List_adp list = List_adp_.new_();
|
||||
fmt_args_exist = false;
|
||||
while (true) {
|
||||
if (fmt_pos > fmt_end) break;
|
||||
@ -138,7 +138,7 @@ public class Bry_fmtr {
|
||||
list.Add(Bry_fmtr_itm.arg_(lkp_bfr.XtoInt(0) - baseInt));
|
||||
else {
|
||||
byte[] key_fmt = lkp_bfr.Xto_bry();
|
||||
Object idx_ref = keys.Fetch(Bry_obj_ref.new_(key_fmt));
|
||||
Object idx_ref = keys.Get_by(Bry_obj_ref.new_(key_fmt));
|
||||
if (idx_ref == null) {
|
||||
int lkp_bfr_len = lkp_bfr.Len();
|
||||
byte[] lkp_bry = lkp_bfr.Bfr();
|
||||
@ -211,15 +211,15 @@ public class Bry_fmtr {
|
||||
}
|
||||
if (lkp_is_active) throw Err_.new_("idx mode not closed");
|
||||
if (trg_pos > 0) {list.Add(Bry_fmtr_itm.dat_(trg_bry, trg_pos)); trg_pos = 0;}
|
||||
itms = (Bry_fmtr_itm[])list.Xto_ary(Bry_fmtr_itm.class);
|
||||
itms = (Bry_fmtr_itm[])list.To_ary(Bry_fmtr_itm.class);
|
||||
itms_len = itms.length;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
int Compile_eval_cmd(byte[] fmt, int fmt_len, int eval_lhs_bgn, ListAdp list) {
|
||||
int eval_lhs_end = Bry_finder.Find_fwd(fmt, char_eval_end, eval_lhs_bgn + Int_.Const_dlm_len, fmt_len); if (eval_lhs_end == Bry_.NotFound) throw Err_mgr._.fmt_(GRP_KEY, "eval_lhs_end_invalid", "could not find eval_lhs_end: ~{0}", String_.new_utf8_(fmt, eval_lhs_bgn, fmt_len));
|
||||
int Compile_eval_cmd(byte[] fmt, int fmt_len, int eval_lhs_bgn, List_adp list) {
|
||||
int eval_lhs_end = Bry_finder.Find_fwd(fmt, char_eval_end, eval_lhs_bgn + Int_.Const_dlm_len, fmt_len); if (eval_lhs_end == Bry_.NotFound) throw Err_mgr._.fmt_(GRP_KEY, "eval_lhs_end_invalid", "could not find eval_lhs_end: ~{0}", String_.new_u8(fmt, eval_lhs_bgn, fmt_len));
|
||||
byte[] eval_dlm = Bry_.Mid(fmt, eval_lhs_bgn , eval_lhs_end + Int_.Const_dlm_len);
|
||||
int eval_rhs_bgn = Bry_finder.Find_fwd(fmt, eval_dlm , eval_lhs_end + Int_.Const_dlm_len, fmt_len); if (eval_rhs_bgn == Bry_.NotFound) throw Err_mgr._.fmt_(GRP_KEY, "eval_rhs_bgn_invalid", "could not find eval_rhs_bgn: ~{0}", String_.new_utf8_(fmt, eval_lhs_end, fmt_len));
|
||||
int eval_rhs_bgn = Bry_finder.Find_fwd(fmt, eval_dlm , eval_lhs_end + Int_.Const_dlm_len, fmt_len); if (eval_rhs_bgn == Bry_.NotFound) throw Err_mgr._.fmt_(GRP_KEY, "eval_rhs_bgn_invalid", "could not find eval_rhs_bgn: ~{0}", String_.new_u8(fmt, eval_lhs_end, fmt_len));
|
||||
byte[] eval_cmd = Bry_.Mid(fmt, eval_lhs_end + Int_.Const_dlm_len, eval_rhs_bgn);
|
||||
byte[] eval_rslt = eval_mgr.Eval(eval_cmd);
|
||||
int eval_rhs_end = eval_rhs_bgn + Int_.Const_dlm_len + eval_dlm.length;
|
||||
|
||||
@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
import gplx.brys.*;
|
||||
public class Bry_fmtr_arg_ {
|
||||
public static Bry_fmtr_arg_bry bry_(String v) {return new Bry_fmtr_arg_bry(Bry_.new_utf8_(v));}
|
||||
public static Bry_fmtr_arg_bry bry_(String v) {return new Bry_fmtr_arg_bry(Bry_.new_u8(v));}
|
||||
public static Bry_fmtr_arg_bry bry_(byte[] v) {return new Bry_fmtr_arg_bry(v);}
|
||||
public static Bry_fmtr_arg_byt byt_(byte v) {return new Bry_fmtr_arg_byt(v);}
|
||||
public static Bry_fmtr_arg_int int_(int v) {return new Bry_fmtr_arg_int(v);}
|
||||
|
||||
@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
public class Bry_fmtr_eval_mgr_ {
|
||||
public static Io_url Eval_url(Bry_fmtr_eval_mgr eval_mgr, byte[] fmt) {
|
||||
if (eval_mgr == null) return Io_url_.new_any_(String_.new_utf8_(fmt));
|
||||
if (eval_mgr == null) return Io_url_.new_any_(String_.new_u8(fmt));
|
||||
Bry_bfr bfr = Bry_bfr.reset_(255);
|
||||
Bry_fmtr fmtr = Bry_fmtr.tmp_();
|
||||
fmtr.Eval_mgr_(eval_mgr).Fmt_(fmt).Bld_bfr_none(bfr);
|
||||
|
||||
@ -19,7 +19,7 @@ package gplx;
|
||||
public class Bry_fmtr_eval_mgr_gfs implements Bry_fmtr_eval_mgr {
|
||||
public boolean Enabled() {return enabled;} public void Enabled_(boolean v) {enabled = v;} private boolean enabled;
|
||||
public byte[] Eval(byte[] cmd) {
|
||||
return enabled ? Bry_.new_utf8_(Object_.Xto_str_strict_or_null_mark(GfsCore._.ExecText(String_.new_utf8_(cmd)))) : null;
|
||||
return enabled ? Bry_.new_u8(Object_.Xto_str_strict_or_null_mark(GfsCore._.ExecText(String_.new_u8(cmd)))) : null;
|
||||
}
|
||||
public static final Bry_fmtr_eval_mgr_gfs _ = new Bry_fmtr_eval_mgr_gfs(); Bry_fmtr_eval_mgr_gfs() {}
|
||||
}
|
||||
|
||||
@ -21,7 +21,7 @@ public class Bry_fmtr_itm {
|
||||
public int ArgIdx;
|
||||
public byte[] Dat;
|
||||
public String DatStr() {
|
||||
if (datStr == null) datStr = String_.new_utf8_(Dat);
|
||||
if (datStr == null) datStr = String_.new_u8(Dat);
|
||||
return datStr;
|
||||
} String datStr;
|
||||
public static Bry_fmtr_itm arg_(int idx) {return new Bry_fmtr_itm(true, idx, Bry_.Empty);}
|
||||
|
||||
@ -40,7 +40,7 @@ public class Bry_fmtr_tst {
|
||||
@Test public void Err_missing_idx() {tst_Format("~{0}", "~{0}");}
|
||||
String[] ary_(String... ary) {return ary;}
|
||||
void tst(String fmt, String[] keys, String[] args, String expd) {
|
||||
Bry_fmtr fmtr = new Bry_fmtr().Fmt_(Bry_.new_utf8_(fmt));
|
||||
Bry_fmtr fmtr = new Bry_fmtr().Fmt_(Bry_.new_u8(fmt));
|
||||
fmtr.Keys_(keys);
|
||||
String actl = fmtr.Bld_str_many(args);
|
||||
Tfds.Eq(expd, actl);
|
||||
@ -73,6 +73,6 @@ class Bry_fmtr_fxt {
|
||||
public void Bld_bfr_many_and_set_fmt(String fmt, Object[] args, String expd) {
|
||||
fmtr.Fmt_(fmt);
|
||||
fmtr.Bld_bfr_many_and_set_fmt(args);
|
||||
Tfds.Eq(expd, String_.new_ascii_(fmtr.Fmt()));
|
||||
Tfds.Eq(expd, String_.new_a7(fmtr.Fmt()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -66,7 +66,7 @@ public class Char_ {
|
||||
return false;
|
||||
}
|
||||
public static String XtoStr(char[] ary, int pos, int length) {return new String(ary, pos, length);}
|
||||
public static byte[] XtoByteAry(int v) {return Bry_.new_utf8_(Char_.XtoStr((char)v));}
|
||||
public static byte[] XtoByteAry(int v) {return Bry_.new_u8(Char_.XtoStr((char)v));}
|
||||
public static char XbyInt(int i) {return (char)i;}
|
||||
public static String XtoStr(int b) {return XtoStr((char)b);}
|
||||
public static String XtoStr(char c) {return String.valueOf(c);}
|
||||
|
||||
@ -25,8 +25,8 @@ public class Double_ {
|
||||
, Inf_pos = Double.POSITIVE_INFINITY
|
||||
;
|
||||
public static final byte[]
|
||||
NaN_bry = Bry_.new_ascii_("NaN")
|
||||
, Inf_pos_bry = Bry_.new_ascii_("INF")
|
||||
NaN_bry = Bry_.new_a7("NaN")
|
||||
, Inf_pos_bry = Bry_.new_a7("INF")
|
||||
;
|
||||
public static boolean IsNaN(double v) {return Double.isNaN(v);}
|
||||
public static double cast_(Object o) {try {return (Double)o;} catch(Exception e) {throw Err_.type_mismatch_exc_(e, double.class, o);}}
|
||||
|
||||
@ -212,7 +212,7 @@ public class Int_ implements GfoInvkAble {
|
||||
return sb.XtoStr();
|
||||
}
|
||||
public static int[] Ary_parse(String raw_str, int reqd_len, int[] or) {
|
||||
byte[] raw_bry = Bry_.new_ascii_(raw_str);
|
||||
byte[] raw_bry = Bry_.new_a7(raw_str);
|
||||
int raw_bry_len = raw_bry.length;
|
||||
int[] rv = new int[reqd_len];
|
||||
int cur_val = 0, cur_mult = 1, cur_idx = reqd_len - 1; boolean signed = false;
|
||||
@ -256,5 +256,5 @@ public class Int_ implements GfoInvkAble {
|
||||
rv[i] = Int_.parse_(ary[i]);
|
||||
return rv;
|
||||
}
|
||||
public static byte[] Xto_bry(int v) {return Bry_.new_ascii_(Xto_str(v));}
|
||||
public static byte[] Xto_bry(int v) {return Bry_.new_a7(Xto_str(v));}
|
||||
}
|
||||
|
||||
@ -98,7 +98,7 @@ public class Int__tst {
|
||||
}
|
||||
@Test public void Xto_int_hex_tst() {
|
||||
Xto_int_hex("007C", 124);
|
||||
} void Xto_int_hex(String raw, int expd) {Tfds.Eq(expd, Int_.Xto_int_hex(Bry_.new_ascii_(raw)));}
|
||||
} void Xto_int_hex(String raw, int expd) {Tfds.Eq(expd, Int_.Xto_int_hex(Bry_.new_a7(raw)));}
|
||||
@Test public void Ary_parse() {
|
||||
Ary_parse__tst("1,2,3" , 3, Int_.Ary_empty, 1, 2, 3);
|
||||
Ary_parse__tst("123,321,213" , 3, Int_.Ary_empty, 123, 321, 213);
|
||||
|
||||
@ -40,7 +40,7 @@ public class Int_ary_ {
|
||||
}
|
||||
int add_len = 1;
|
||||
if (itm_is_rng) {
|
||||
add_len = num - rng_bgn + ListAdp_.Base1;
|
||||
add_len = num - rng_bgn + List_adp_.Base1;
|
||||
if (add_len == 0) return or; // bgn >= end;
|
||||
}
|
||||
if (add_len + rv_idx > rv_len) { // ary out of space; resize
|
||||
|
||||
@ -39,6 +39,6 @@ public class Int_ary__tst {
|
||||
}
|
||||
}
|
||||
class Int_ary__fxt {
|
||||
public void Test_Parse_list_empty(String raw) {Tfds.Eq_ary(Int_.Ary_empty, Int_ary_.Parse_list_or(Bry_.new_ascii_(raw), Int_.Ary_empty));}
|
||||
public void Test_Parse_list_or(String raw, int... expd) {Tfds.Eq_ary(expd, Int_ary_.Parse_list_or(Bry_.new_ascii_(raw), Int_.Ary_empty));}
|
||||
public void Test_Parse_list_empty(String raw) {Tfds.Eq_ary(Int_.Ary_empty, Int_ary_.Parse_list_or(Bry_.new_a7(raw), Int_.Ary_empty));}
|
||||
public void Test_Parse_list_or(String raw, int... expd) {Tfds.Eq_ary(expd, Int_ary_.Parse_list_or(Bry_.new_a7(raw), Int_.Ary_empty));}
|
||||
}
|
||||
|
||||
@ -30,14 +30,14 @@ public class Object_ {
|
||||
private static String ToString_lang(Object v) {
|
||||
Class<?> c = v.getClass();
|
||||
if (ClassAdp_.Eq(c, String_.Cls_ref_type)) return (String)v;
|
||||
else if (ClassAdp_.Eq(c, Bry_.Cls_ref_type)) return String_.new_utf8_((byte[])v);
|
||||
else if (ClassAdp_.Eq(c, Bry_.Cls_ref_type)) return String_.new_u8((byte[])v);
|
||||
else return v.toString();
|
||||
}
|
||||
public static String Xto_str_loose_or(Object v, String or) { // tries to pretty-print doubles; also standardizes true/false; DATE:2014-07-14
|
||||
if (v == null) return null;
|
||||
Class<?> c = ClassAdp_.ClassOf_obj(v);
|
||||
if (ClassAdp_.Eq(c, String_.Cls_ref_type)) return (String)v;
|
||||
else if (ClassAdp_.Eq(c, Bry_.Cls_ref_type)) return String_.new_utf8_((byte[])v);
|
||||
else if (ClassAdp_.Eq(c, Bry_.Cls_ref_type)) return String_.new_u8((byte[])v);
|
||||
else if (ClassAdp_.Eq(c, Bool_.Cls_ref_type)) return Bool_.cast_(v) ? Bool_.True_str : Bool_.False_str; // always return "true" / "false"
|
||||
else if (ClassAdp_.Eq(c, Double_.Cls_ref_type)) return Double_.Xto_str_loose(Double_.cast_(v));
|
||||
else return v.toString();
|
||||
|
||||
@ -25,8 +25,8 @@ public class String_ implements GfoInvkAble {
|
||||
public static final String Null = null, Empty = "", Null_mark = "<<NULL>>", Tab = "\t", Lf = "\n", CrLf = "\r\n";
|
||||
public static String cast_(Object v) {return (String)v;}
|
||||
public static String as_(Object obj) {return obj instanceof String ? (String)obj : null;}
|
||||
public static String new_ascii_(byte[] v) {return v == null ? null : new_ascii_(v, 0, v.length);}
|
||||
public static String new_ascii_(byte[] v, int bgn, int end) {
|
||||
public static String new_a7(byte[] v) {return v == null ? null : new_a7(v, 0, v.length);}
|
||||
public static String new_a7(byte[] v, int bgn, int end) {
|
||||
try {
|
||||
return v == null
|
||||
? null
|
||||
@ -34,9 +34,8 @@ public class String_ implements GfoInvkAble {
|
||||
}
|
||||
catch (Exception e) {throw Err_.err_(e, "unsupported encoding");}
|
||||
}
|
||||
public static String new_utf8_(byte[] v) {return v == null ? null : new_utf8_(v, 0, v.length);}
|
||||
public static String new_utf8_mid_safe_(byte[] v, int bgn, int end) {return v == null ? null : new_utf8_(v, bgn, end);}
|
||||
public static String new_utf8_(byte[] v, int bgn, int end) {
|
||||
public static String new_u8(byte[] v) {return v == null ? null : new_u8(v, 0, v.length);}
|
||||
public static String new_u8(byte[] v, int bgn, int end) {
|
||||
try {
|
||||
return v == null
|
||||
? null
|
||||
@ -44,10 +43,10 @@ public class String_ implements GfoInvkAble {
|
||||
}
|
||||
catch (Exception e) {throw Err_.err_(e, "unsupported encoding");}
|
||||
}
|
||||
public static String new_utf8_len_safe_(byte[] v, int bgn, int len) {
|
||||
public static String new_u8_by_len(byte[] v, int bgn, int len) {
|
||||
int v_len = v.length;
|
||||
if (bgn + len > v_len) len = v_len - bgn;
|
||||
return new_utf8_(v, bgn, bgn + len);
|
||||
return new_u8(v, bgn, bgn + len);
|
||||
}
|
||||
public static String[] Ary_add(String[]... arys) {
|
||||
if (arys == null) return String_.Ary_empty;
|
||||
@ -330,14 +329,14 @@ public class String_ implements GfoInvkAble {
|
||||
|
||||
public static String[] Ary(String... ary) {return ary;}
|
||||
public static String[] Ary_wo_null(String... ary) {
|
||||
ListAdp list = ListAdp_.new_();
|
||||
List_adp list = List_adp_.new_();
|
||||
int len = ary.length;
|
||||
for (int i = 0; i < len; ++i) {
|
||||
String itm = ary[i];
|
||||
if (itm == null) continue;
|
||||
list.Add(itm);
|
||||
}
|
||||
return list.XtoStrAry();
|
||||
return list.To_str_ary();
|
||||
}
|
||||
public static String AryXtoStr(String... ary) {
|
||||
String_bldr sb = String_bldr_.new_();
|
||||
@ -348,7 +347,7 @@ public class String_ implements GfoInvkAble {
|
||||
public static final String[] Ary_empty = new String[0];
|
||||
public static String[] Split(String raw, char dlm) {return Split(raw, dlm, false);}
|
||||
public static String[] Split(String raw, char dlm, boolean addEmptyIfDlmIsLast) {
|
||||
ListAdp list = ListAdp_.new_(); String_bldr sb = String_bldr_.new_();
|
||||
List_adp list = List_adp_.new_(); String_bldr sb = String_bldr_.new_();
|
||||
int rawLen = String_.Len(raw); char c = '\0';
|
||||
for (int i = 0; i < rawLen; i++) {
|
||||
c = String_.CharAt(raw, i);
|
||||
@ -361,7 +360,7 @@ public class String_ implements GfoInvkAble {
|
||||
}
|
||||
if (sb.Count() > 0)
|
||||
list.Add(sb.Xto_str_and_clear());
|
||||
return list.XtoStrAry();
|
||||
return list.To_str_ary();
|
||||
}
|
||||
public static String[] Split(String s, String separator) {return Split_do(s, separator, false);}
|
||||
public static String[] SplitLines_crlf(String s) {return Split(s, Op_sys.Wnt.Nl_str());}
|
||||
@ -423,7 +422,7 @@ public class String_ implements GfoInvkAble {
|
||||
if (String_.Eq(s, "") // "".Split('a') return array with one member: ""
|
||||
|| String_.Eq(spr, "")) // "a".Split('\0') returns array with one member: "a"
|
||||
return new String[] {s};
|
||||
ListAdp list = ListAdp_.new_(); String_bldr sb = String_bldr_.new_();
|
||||
List_adp list = List_adp_.new_(); String_bldr sb = String_bldr_.new_();
|
||||
int i = 0, sprPos = 0; boolean sprMatched = false; char spr0 = CharAt(spr, 0);
|
||||
int textLength = Len(s); int sprLength = Len(spr);
|
||||
while (true) {
|
||||
@ -456,7 +455,7 @@ public class String_ implements GfoInvkAble {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return (String[])list.Xto_ary(String.class);
|
||||
return (String[])list.To_ary(String.class);
|
||||
}
|
||||
static String Mid_lang(String s, int bgn, int len) {return s.substring(bgn, bgn + len);}
|
||||
public Object Invk(GfsCtx ctx, int ikey, String k, GfoMsg m) {
|
||||
@ -496,23 +495,23 @@ public class String_ implements GfoInvkAble {
|
||||
int ary_len = ary.length;
|
||||
String[] rv = new String[ary_len];
|
||||
for (int i = 0; i < ary_len; i++)
|
||||
rv[i] = String_.new_utf8_(ary[i]);
|
||||
rv[i] = String_.new_u8(ary[i]);
|
||||
return rv;
|
||||
}
|
||||
public static String [] Ary_filter(String[] src, String[] filter) {
|
||||
HashAdp hash = HashAdp_.new_();
|
||||
Hash_adp hash = Hash_adp_.new_();
|
||||
int len = filter.length;
|
||||
for (int i = 0; i < len; i++) {
|
||||
String itm = filter[i];
|
||||
hash.AddReplace(itm, itm);
|
||||
hash.Add_if_dupe_use_nth(itm, itm);
|
||||
}
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
List_adp rv = List_adp_.new_();
|
||||
len = src.length;
|
||||
for (int i = 0; i < len; i++) {
|
||||
String itm = src[i];
|
||||
if (hash.Has(itm)) rv.Add(itm);
|
||||
}
|
||||
return rv.XtoStrAry();
|
||||
return rv.To_str_ary();
|
||||
}
|
||||
public static String[] Ary_flatten(String[][] src_ary) {
|
||||
int trg_len = 0;
|
||||
|
||||
@ -22,10 +22,10 @@ public class Bry_fmtr_arg_time implements Bry_fmtr_arg {
|
||||
}
|
||||
public long Seconds() {return seconds;} public Bry_fmtr_arg_time Seconds_(long v) {seconds = v; return this;} long seconds;
|
||||
byte[][] segs = new byte[][]
|
||||
{ Bry_.new_ascii_("d")
|
||||
, Bry_.new_ascii_("h")
|
||||
, Bry_.new_ascii_("m")
|
||||
, Bry_.new_ascii_("s")
|
||||
{ Bry_.new_a7("d")
|
||||
, Bry_.new_a7("h")
|
||||
, Bry_.new_a7("m")
|
||||
, Bry_.new_a7("s")
|
||||
};
|
||||
int[] units = new int[] {86400, 3600, 60, 1};
|
||||
int units_len;
|
||||
|
||||
@ -19,7 +19,7 @@ package gplx;
|
||||
public class DateAdp_parser {
|
||||
public int[] Parse_iso8651_like(String raw_str) {Parse_iso8651_like(tmp_rv, raw_str); return tmp_rv;} int[] tmp_rv = new int[7];
|
||||
public void Parse_iso8651_like(int[] rv, String raw_str) {
|
||||
byte[] raw_bry = Bry_.new_utf8_(raw_str);
|
||||
byte[] raw_bry = Bry_.new_u8(raw_str);
|
||||
Parse_iso8651_like(rv, raw_bry, 0, raw_bry.length);
|
||||
}
|
||||
public void Parse_iso8651_like(int[] rv, byte[] src, int bgn, int end) {
|
||||
|
||||
@ -27,7 +27,7 @@ public class DateAdp_parser_tst {
|
||||
class DateAdp_parser_fxt {
|
||||
DateAdp_parser parser = DateAdp_parser.new_(); int[] actl = new int[7];
|
||||
public void Test_Parse_iso8651_like(String s, int... expd) {
|
||||
byte[] bry = Bry_.new_ascii_(s);
|
||||
byte[] bry = Bry_.new_a7(s);
|
||||
parser.Parse_iso8651_like(actl, bry, 0, bry.length);
|
||||
Tfds.Eq_ary(expd, actl, s);
|
||||
}
|
||||
|
||||
@ -27,7 +27,7 @@ public class EnmMgr {
|
||||
valRegy.Add(val, raw);
|
||||
objRegy.Add(val, o);
|
||||
}
|
||||
public Object Get(int val) {return objRegy.Fetch(val);}
|
||||
public Object Get(int val) {return objRegy.Get_by(val);}
|
||||
public int GetVal(String raw) {
|
||||
String[] ary = String_.Split(raw, bitRngSpr);
|
||||
int rv = 0;
|
||||
@ -38,7 +38,7 @@ public class EnmMgr {
|
||||
if (String_.HasAtBgn(term, "#"))
|
||||
cur = Int_.parse_(String_.Mid(term, 1));
|
||||
else
|
||||
cur = Int_.cast_(rawRegy.Fetch(term));
|
||||
cur = Int_.cast_(rawRegy.Get_by(term));
|
||||
rv |= cur;
|
||||
}
|
||||
return rv;
|
||||
@ -62,11 +62,11 @@ public class EnmMgr {
|
||||
return sb.XtoStr();
|
||||
}
|
||||
void AppendRaw(String_bldr sb, int key) {
|
||||
String raw = (String)valRegy.Fetch(key);
|
||||
String raw = (String)valRegy.Get_by(key);
|
||||
if (sb.Count() > 0) sb.Add(bitRngSpr);
|
||||
if (prefix != null) sb.Add(prefix);
|
||||
sb.Add(raw);
|
||||
}
|
||||
HashAdp rawRegy = HashAdp_.new_(), valRegy = HashAdp_.new_(), objRegy = HashAdp_.new_();
|
||||
Hash_adp rawRegy = Hash_adp_.new_(), valRegy = Hash_adp_.new_(), objRegy = Hash_adp_.new_();
|
||||
public static EnmMgr new_() {return new EnmMgr();} EnmMgr() {}
|
||||
}
|
||||
|
||||
@ -20,9 +20,9 @@ import gplx.core.strings.*; import gplx.ios.*; /*IoUrlInfo*/
|
||||
public class Io_url implements CompareAble, EqAble, ParseAble, GfoInvkAble { //_20101005 URL:doc/Io_url.txt
|
||||
public IoUrlInfo Info() {return info;} IoUrlInfo info;
|
||||
public String Raw() {return raw;} final String raw;
|
||||
public byte[] RawBry() {return Bry_.new_utf8_(raw);}
|
||||
public byte[] RawBry() {return Bry_.new_u8(raw);}
|
||||
// public byte[] Http_file_bry() {
|
||||
// try {return Bry_.new_utf8_(String_.Concat(http_file_str, java.net.URLEncoder.encode(raw, "UTF-8")));}
|
||||
// try {return Bry_.new_u8(String_.Concat(http_file_str, java.net.URLEncoder.encode(raw, "UTF-8")));}
|
||||
// catch (Exception e) {throw Err_.err_(e, "Http_file_bry");}
|
||||
// }
|
||||
public String To_http_file_str() {return Http_file_str + Http_file_str_encoder.Encode_str(raw);}
|
||||
@ -33,7 +33,7 @@ public class Io_url implements CompareAble, EqAble, ParseAble, GfoInvkAble { //_
|
||||
|
||||
public static final String Http_file_str = "file:///";
|
||||
public static final int Http_file_len = String_.Len(Http_file_str);
|
||||
public static final byte[] Http_file_bry = Bry_.new_ascii_(Http_file_str);
|
||||
public static final byte[] Http_file_bry = Bry_.new_a7(Http_file_str);
|
||||
public boolean Type_dir() {return info.IsDir(raw);} public boolean Type_fil() {return !info.IsDir(raw);}
|
||||
public Io_url OwnerDir() {return Io_url_.new_inf_(info.OwnerDir(raw), info);}
|
||||
public Io_url OwnerRoot() {return Io_url_.new_inf_(info.OwnerRoot(raw), info);}
|
||||
@ -61,8 +61,8 @@ public class Io_url implements CompareAble, EqAble, ParseAble, GfoInvkAble { //_
|
||||
? String_.DelBgn(raw, String_.Len(dirRaw))
|
||||
: String_.Empty;
|
||||
}
|
||||
public ListAdp XtoNames() {
|
||||
ListAdp list = ListAdp_.new_();
|
||||
public List_adp XtoNames() {
|
||||
List_adp list = List_adp_.new_();
|
||||
Io_url cur = this;
|
||||
while (!cur.EqNull()) {
|
||||
list.Add(cur.NameAndExt_noDirSpr());
|
||||
@ -73,7 +73,7 @@ public class Io_url implements CompareAble, EqAble, ParseAble, GfoInvkAble { //_
|
||||
}
|
||||
public Io_url GenParallel(Io_url oldRoot, Io_url newRoot) {return newRoot.GenSubFil_ary(GenRelUrl_orEmpty(oldRoot));}
|
||||
public boolean Eq(Object obj) {if (obj == null) return false; return String_.Eq(raw, ((Io_url)obj).raw);}
|
||||
public boolean EqNull() {return this.Eq(Io_url_.Null);}
|
||||
public boolean EqNull() {return this.Eq(Io_url_.Empty);}
|
||||
Io_url GenSub(boolean isFil, String[] ary) {
|
||||
String_bldr sb = String_bldr_.new_().Add(raw);
|
||||
int len = Array_.Len(ary);
|
||||
|
||||
@ -18,16 +18,20 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
import gplx.ios.*; /*IoUrlInfo_*/
|
||||
public class Io_url_ {
|
||||
public static final Io_url Null = new Io_url("", IoUrlInfo_.Nil);
|
||||
public static final Io_url Empty = new Io_url("", IoUrlInfo_.Nil);
|
||||
public static final Io_url NullPtr = null;
|
||||
public static final Io_url Parser = new Io_url("", IoUrlInfo_.Nil);
|
||||
public static Io_url as_(Object obj) {return obj instanceof Io_url ? (Io_url)obj : null;}
|
||||
public static Io_url cast_(Object obj) {try {return (Io_url)obj;} catch(Exception exc) {throw Err_.type_mismatch_exc_(exc, Io_url.class, obj);}}
|
||||
public static Io_url Usr() {
|
||||
if (usr_dir == null) {
|
||||
usr_dir = Op_sys.Cur().Tid_is_lnx()
|
||||
? Io_url_.new_inf_(String_.Format("/home/{0}/", Env_.UserName()), IoUrlInfo_.Lnx)
|
||||
: Io_url_.new_inf_("C:\\", IoUrlInfo_.Wnt);
|
||||
switch (Op_sys.Cur().Tid()) {
|
||||
case Op_sys.Tid_wnt: usr_dir = Io_url_.new_inf_("C:\\", IoUrlInfo_.Wnt); break;
|
||||
case Op_sys.Tid_lnx: usr_dir = Io_url_.new_inf_(String_.Format("/home/{0}/", Env_.UserName()), IoUrlInfo_.Lnx); break;
|
||||
case Op_sys.Tid_osx: usr_dir = Io_url_.new_inf_(String_.Format("/Users/{0}/", Env_.UserName()), IoUrlInfo_.Lnx); break;
|
||||
case Op_sys.Tid_drd: usr_dir = Io_url_.new_inf_(String_.Format("/mnt/{0}/", Env_.UserName()), IoUrlInfo_.Lnx); break;
|
||||
default: throw Err_.unhandled(Op_sys.Cur().Tid());
|
||||
}
|
||||
}
|
||||
return usr_dir;
|
||||
} static Io_url usr_dir;
|
||||
@ -44,12 +48,12 @@ public class Io_url_ {
|
||||
public static Io_url new_fil_(String raw) {return new_any_(raw);}
|
||||
public static Io_url new_dir_(String raw) {return new_any_(raw);} // NOTE: for now, same as new_fil; stack overflow when doing new_dir
|
||||
public static Io_url new_any_(String raw) {return new_inf_(raw, IoUrlInfoRegy._.Match(raw));}
|
||||
public static Io_url new_inf_(String raw, IoUrlInfo info) {return String_.Eq(raw, "") ? Io_url_.Null : new Io_url(raw, info);}
|
||||
public static Io_url new_inf_(String raw, IoUrlInfo info) {return String_.Eq(raw, "") ? Io_url_.Empty : new Io_url(raw, info);}
|
||||
public static Io_url http_any_(String src, boolean wnt) {
|
||||
return new_any_(parse_http_file(src, wnt));
|
||||
}
|
||||
private static String parse_http_file(String v, boolean wnt) {
|
||||
byte[] v_bry = Bry_.new_utf8_(v);
|
||||
byte[] v_bry = Bry_.new_u8(v);
|
||||
int v_len = v_bry.length;
|
||||
if (Bry_.HasAtBgn(v_bry, Io_url.Http_file_bry, 0, v_len)) {
|
||||
byte[] rv = new byte[v_len - Io_url.Http_file_len];
|
||||
@ -58,7 +62,7 @@ public class Io_url_ {
|
||||
if (wnt && b == Byte_ascii.Slash) b = Byte_ascii.Backslash;
|
||||
rv[i] = b;
|
||||
}
|
||||
return String_.new_utf8_(rv);
|
||||
return String_.new_u8(rv);
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
@ -25,7 +25,7 @@ public class KeyVal implements XtoStrAble {
|
||||
public Object Val() {return val;} public KeyVal Val_(Object v) {val = v; return this;} private Object val;
|
||||
public String Val_to_str_or_empty() {return Object_.Xto_str_strict_or_empty(val);}
|
||||
public String Val_to_str_or_null() {return Object_.Xto_str_strict_or_null(val);}
|
||||
public byte[] Val_to_bry() {return Bry_.new_utf8_(Object_.Xto_str_strict_or_null(val));}
|
||||
public byte[] Val_to_bry() {return Bry_.new_u8(Object_.Xto_str_strict_or_null(val));}
|
||||
@Override public String toString() {return XtoStr();}
|
||||
public String XtoStr() {return Key() + "=" + Object_.Xto_str_strict_or_null_mark(val);}
|
||||
}
|
||||
|
||||
@ -17,22 +17,22 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
public class KeyValHash {
|
||||
private OrderedHash hash = OrderedHash_.new_();
|
||||
private Ordered_hash hash = Ordered_hash_.new_();
|
||||
public int Count() {return hash.Count();}
|
||||
public KeyValHash Clear() {hash.Clear(); return this;}
|
||||
public boolean Has(String key) {return hash.Has(key);}
|
||||
public KeyVal FetchAt(int i) {return (KeyVal)hash.FetchAt(i);}
|
||||
public KeyVal Get_at(int i) {return (KeyVal)hash.Get_at(i);}
|
||||
public Object FetchValOr(String key, Object or) {KeyVal rv = FetchOrNull(key); return rv == null ? or : rv.Val();}
|
||||
public Object FetchValOrNull(String key) {return FetchValOr(key, null);}
|
||||
public Object FetchValOrFail(String key) {return KeyVal_.as_(hash.FetchOrFail(key)).Val();}
|
||||
public Object FetchValOrFail(String key) {return KeyVal_.as_(hash.Get_by_or_fail(key)).Val();}
|
||||
public KeyValHash Add(KeyVal kv) {hash.Add(kv.Key(), kv); return this;}
|
||||
public KeyValHash Add(String key, Object val) {hash.Add(key, KeyVal_.new_(key, val)); return this;}
|
||||
public KeyValHash AddReplace(String key, Object val) {hash.AddReplace(key, KeyVal_.new_(key, val)); return this;}
|
||||
public KeyValHash Add_if_dupe_use_nth(String key, Object val) {hash.Add_if_dupe_use_nth(key, KeyVal_.new_(key, val)); return this;}
|
||||
public void Del(String key) {hash.Del(key);}
|
||||
public KeyVal[] Xto_bry() {
|
||||
KeyVal[] rv = new KeyVal[this.Count()];
|
||||
for (int i = 0; i < rv.length; i++)
|
||||
rv[i] = this.FetchAt(i);
|
||||
rv[i] = this.Get_at(i);
|
||||
return rv;
|
||||
}
|
||||
public static KeyValHash new_() {return new KeyValHash();} protected KeyValHash() {}
|
||||
@ -43,7 +43,7 @@ public class KeyValHash {
|
||||
rv.Add(ary[i]);
|
||||
return rv;
|
||||
}
|
||||
public KeyVal FetchOrNull(String key) {return KeyVal_.as_(hash.Fetch(key));}
|
||||
public KeyVal FetchOrNull(String key) {return KeyVal_.as_(hash.Get_by(key));}
|
||||
public static KeyValHash strAry_(String[] ary) {// needed for consoleLine
|
||||
int aryLen = Array_.Len(ary); if (aryLen % 2 != 0) throw Err_.new_("array length must be divisible by 2").Add("aryLen", aryLen).Add("ary", String_.Concat_lines_crlf(ary));
|
||||
KeyValHash rv = new KeyValHash();
|
||||
|
||||
@ -18,15 +18,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
import gplx.core.strings.*;
|
||||
public class KeyValList {//20101217
|
||||
public int Count() {return list.Count();} ListAdp list = ListAdp_.new_();
|
||||
public int Count() {return list.Count();} List_adp list = List_adp_.new_();
|
||||
public void Clear() {list.Clear();}
|
||||
public KeyVal GetAt(int i) {return (KeyVal)list.FetchAt(i);}
|
||||
public KeyVal GetAt(int i) {return (KeyVal)list.Get_at(i);}
|
||||
public KeyValList Add(String key, Object val) {list.Add(KeyVal_.new_(key, val)); return this;}
|
||||
public KeyVal[] Xto_bry() {return (KeyVal[])list.Xto_ary(KeyVal.class);}
|
||||
public KeyVal[] Xto_bry() {return (KeyVal[])list.To_ary(KeyVal.class);}
|
||||
public String XtoStr() {
|
||||
String_bldr sb = String_bldr_.new_();
|
||||
for (int i = 0; i < list.Count(); i++) {
|
||||
KeyVal kv = (KeyVal)list.FetchAt(i);
|
||||
KeyVal kv = (KeyVal)list.Get_at(i);
|
||||
sb.Add_spr_unless_first(kv.Key(), " ", i);
|
||||
sb.Add("=").Add(kv.Val_to_str_or_empty());
|
||||
}
|
||||
|
||||
@ -36,7 +36,7 @@ public class TimeSpanAdp_ {
|
||||
public static TimeSpanAdp from_(long bgn) {return TimeSpanAdp_.fracs_(Env_.TickCount() - bgn);}
|
||||
public static final long parse_null = Long_.MinValue;
|
||||
public static TimeSpanAdp parse_(String raw) {
|
||||
byte[] bry = Bry_.new_utf8_(raw);
|
||||
byte[] bry = Bry_.new_u8(raw);
|
||||
long fracs = parse_to_fracs(bry, 0, bry.length, false);
|
||||
return fracs == parse_null ? null : TimeSpanAdp_.fracs_(fracs);
|
||||
}
|
||||
|
||||
@ -22,6 +22,6 @@ public interface Url_encoder_interface {
|
||||
}
|
||||
class Url_encoder_interface_same implements Url_encoder_interface {
|
||||
public String Encode_str(String v) {return v;}
|
||||
public byte[] Encode_bry(String v) {return Bry_.new_utf8_(v);}
|
||||
public byte[] Encode_bry(String v) {return Bry_.new_u8(v);}
|
||||
public static final Url_encoder_interface_same _ = new Url_encoder_interface_same(); Url_encoder_interface_same() {}
|
||||
}
|
||||
|
||||
@ -1,46 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012 gnosygnu@gmail.com
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.core.primitives.*;
|
||||
public class HashAdp_ {
|
||||
public static HashAdp new_() {return new HashAdp_obj();}
|
||||
public static HashAdp new_bry_() {return new HashAdp_bry();}
|
||||
public static final HashAdp Null = new HashAdp_null();
|
||||
}
|
||||
class HashAdp_obj extends gplx.lists.HashAdp_base implements HashAdp {}//_20110428
|
||||
class HashAdp_null implements HashAdp {
|
||||
public int Count() {return 0;}
|
||||
public boolean Has(Object key) {return false;}
|
||||
public Object Fetch(Object key) {return null;}
|
||||
public Object FetchOrFail(Object key) {throw Err_.missing_key_(Object_.Xto_str_strict_or_null_mark(key));}
|
||||
public Object FetchOrNew(Object key, NewAble proto) {throw Err_.new_("could not add to null hash");}
|
||||
public void Add(Object key, Object val) {}
|
||||
public void AddKeyVal(Object val) {}
|
||||
public void AddReplace(Object key, Object val) {}
|
||||
public boolean Add_if_new(Object key, Object val) {return false;}
|
||||
public void Del(Object key) {}
|
||||
public void Clear() {}
|
||||
public java.util.Iterator iterator() {return gplx.lists.Iterator_null._;}
|
||||
}
|
||||
class HashAdp_bry extends gplx.lists.HashAdp_base implements HashAdp {
|
||||
Bry_obj_ref key_ref = Bry_obj_ref.null_();
|
||||
@Override protected void Add_base(Object key, Object val) {super.Add_base(Bry_obj_ref.new_((byte[])key), val);}
|
||||
@Override protected void Del_base(Object key) {super.Del_base(key_ref.Val_((byte[])key));}
|
||||
@Override protected boolean Has_base(Object key) {return super.Has_base(key_ref.Val_((byte[])key));}
|
||||
@Override protected Object Fetch_base(Object key) {return super.Fetch_base(key_ref.Val_((byte[])key));}
|
||||
}
|
||||
@ -16,16 +16,16 @@ You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
public interface HashAdp extends gplx.lists.EnumerAble {
|
||||
public interface Hash_adp extends gplx.lists.EnumerAble {
|
||||
int Count();
|
||||
boolean Has(Object key);
|
||||
Object Fetch(Object key);
|
||||
Object FetchOrFail(Object key);
|
||||
Object FetchOrNew(Object key, NewAble prototype);
|
||||
Object Get_by(Object key);
|
||||
Object Get_by_or_fail(Object key);
|
||||
Object Get_by_or_new(Object key, NewAble prototype);
|
||||
void Add(Object key, Object val);
|
||||
void AddKeyVal(Object val);
|
||||
void AddReplace(Object key, Object val);
|
||||
boolean Add_if_new(Object key, Object val);
|
||||
void Add_as_key_and_val(Object val);
|
||||
boolean Add_if_dupe_use_1st(Object key, Object val);
|
||||
void Add_if_dupe_use_nth(Object key, Object val);
|
||||
void Del(Object key);
|
||||
void Clear();
|
||||
}
|
||||
38
100_core/src_140_list/gplx/Hash_adp_.java
Normal file
38
100_core/src_140_list/gplx/Hash_adp_.java
Normal file
@ -0,0 +1,38 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012 gnosygnu@gmail.com
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.core.primitives.*;
|
||||
public class Hash_adp_ {
|
||||
public static Hash_adp new_() {return new Hash_adp_obj();}
|
||||
public static final Hash_adp Noop = new Hash_adp_noop();
|
||||
}
|
||||
class Hash_adp_obj extends gplx.lists.Hash_adp_base implements Hash_adp {}//_20110428
|
||||
class Hash_adp_noop implements Hash_adp {
|
||||
public int Count() {return 0;}
|
||||
public boolean Has(Object key) {return false;}
|
||||
public Object Get_by(Object key) {return null;}
|
||||
public Object Get_by_or_fail(Object key) {throw Err_.missing_key_(Object_.Xto_str_strict_or_null_mark(key));}
|
||||
public Object Get_by_or_new(Object key, NewAble proto) {throw Err_.new_("could not add to null hash");}
|
||||
public void Add(Object key, Object val) {}
|
||||
public void Add_as_key_and_val(Object val) {}
|
||||
public void Add_if_dupe_use_nth(Object key, Object val) {}
|
||||
public boolean Add_if_dupe_use_1st(Object key, Object val) {return false;}
|
||||
public void Del(Object key) {}
|
||||
public void Clear() {}
|
||||
public java.util.Iterator iterator() {return gplx.lists.Iterator_null._;}
|
||||
}
|
||||
@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
import gplx.core.primitives.*;
|
||||
import gplx.intl.*;
|
||||
public class Hash_adp_bry extends gplx.lists.HashAdp_base implements HashAdp {
|
||||
public class Hash_adp_bry extends gplx.lists.Hash_adp_base implements Hash_adp {
|
||||
private final Hash_adp_bry_itm_base proto, key_ref;
|
||||
Hash_adp_bry(Hash_adp_bry_itm_base proto) {
|
||||
this.proto = proto;
|
||||
@ -32,14 +32,14 @@ public class Hash_adp_bry extends gplx.lists.HashAdp_base implements HashAdp {
|
||||
public Hash_adp_bry Add_bry_byte(byte[] key, byte val) {this.Add_base(key, Byte_obj_val.new_(val)); return this;}
|
||||
public Hash_adp_bry Add_bry_int(byte[] key, int val) {this.Add_base(key, Int_obj_val.new_(val)); return this;}
|
||||
public Hash_adp_bry Add_bry_bry(byte[] key) {this.Add_base(key, key); return this;}
|
||||
public Hash_adp_bry Add_str_byte(String key, byte val) {this.Add_base(Bry_.new_utf8_(key), Byte_obj_val.new_(val)); return this;}
|
||||
public Hash_adp_bry Add_str_obj(String key, Object val) {this.Add_base(Bry_.new_utf8_(key), val); return this;}
|
||||
public Hash_adp_bry Add_str_byte(String key, byte val) {this.Add_base(Bry_.new_u8(key), Byte_obj_val.new_(val)); return this;}
|
||||
public Hash_adp_bry Add_str_obj(String key, Object val) {this.Add_base(Bry_.new_u8(key), val); return this;}
|
||||
public Hash_adp_bry Add_bry_obj(byte[] key, Object val) {this.Add_base(key, val); return this;}
|
||||
public Hash_adp_bry Add_many_str(String... ary) {
|
||||
int ary_len = ary.length;
|
||||
for (int i = 0; i < ary_len; i++) {
|
||||
String itm = ary[i];
|
||||
byte[] bry = Bry_.new_utf8_(itm);
|
||||
byte[] bry = Bry_.new_u8(itm);
|
||||
Add_bry_bry(bry);
|
||||
}
|
||||
return this;
|
||||
|
||||
@ -50,19 +50,19 @@ class Hash_adp_bry_fxt {
|
||||
public void Clear() {}
|
||||
public Hash_adp_bry_fxt New_cs() {hash = Hash_adp_bry.cs_(); return this;}
|
||||
public Hash_adp_bry_fxt New_ci() {hash = Hash_adp_bry.ci_ascii_(); return this;}
|
||||
public Hash_adp_bry_fxt Add(String key) {byte[] key_bry = Bry_.new_utf8_(key); hash.Add(key_bry, key_bry); return this;}
|
||||
public Hash_adp_bry_fxt Add(String key) {byte[] key_bry = Bry_.new_u8(key); hash.Add(key_bry, key_bry); return this;}
|
||||
public Hash_adp_bry_fxt Count_tst(int expd) {Tfds.Eq(expd, hash.Count()); return this;}
|
||||
public Hash_adp_bry_fxt Get_bry_tst(String key) {return Get_bry_tst(key, key);}
|
||||
public Hash_adp_bry_fxt Get_bry_tst(String key, String expd) {
|
||||
byte[] key_bry = Bry_.new_utf8_(key);
|
||||
byte[] key_bry = Bry_.new_u8(key);
|
||||
byte[] actl_bry = (byte[])hash.Get_by_bry(key_bry);
|
||||
Tfds.Eq(expd, String_.new_utf8_(actl_bry));
|
||||
Tfds.Eq(expd, String_.new_u8(actl_bry));
|
||||
return this;
|
||||
}
|
||||
public Hash_adp_bry_fxt Get_mid_tst(String key, int bgn, int end, String expd) {
|
||||
byte[] key_bry = Bry_.new_utf8_(key);
|
||||
byte[] key_bry = Bry_.new_u8(key);
|
||||
byte[] actl_bry = (byte[])hash.Get_by_mid(key_bry, bgn, end);
|
||||
Tfds.Eq(expd, String_.new_utf8_(actl_bry));
|
||||
Tfds.Eq(expd, String_.new_u8(actl_bry));
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,51 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012 gnosygnu@gmail.com
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.lists.*; /*EnumerAble,ComparerAble*/
|
||||
public interface ListAdp extends EnumerAble {
|
||||
boolean Has_none();
|
||||
int Count();
|
||||
Object FetchAt(int i);
|
||||
Object FetchAtOr(int i, Object or);
|
||||
Object FetchAtLast();
|
||||
Object PopLast();
|
||||
void Add(Object o);
|
||||
void AddAt(int i, Object o);
|
||||
ListAdp AddMany(Object... ary);
|
||||
void Del(Object o);
|
||||
void DelAt(int i);
|
||||
void Del_range(int bgn, int end);
|
||||
void Clear();
|
||||
void Clear_max(int max);
|
||||
boolean RangeCheck(int v);
|
||||
void ResizeBounds(int i);
|
||||
int IndexOf(Object o);
|
||||
int LastIndex();
|
||||
void MoveTo(int src, int trg);
|
||||
void SetAt(int i, Object o);
|
||||
String XtoStr();
|
||||
String[] XtoStrAry();
|
||||
Object Xto_ary(Class<?> memberType);
|
||||
Object Xto_ary_and_clear(Class<?> memberType);
|
||||
Object[] Xto_obj_ary();
|
||||
|
||||
void Reverse();
|
||||
void Sort();
|
||||
void SortBy(ComparerAble comparer);
|
||||
void Shuffle();
|
||||
}
|
||||
@ -1,92 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012 gnosygnu@gmail.com
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.lists.*; /*EnumerAble,ComparerAble*/
|
||||
public class ListAdp_ {
|
||||
public static ListAdp as_(Object obj) {return obj instanceof ListAdp ? (ListAdp)obj : null;}
|
||||
public static ListAdp new_() {return new ListAdp_obj();}
|
||||
public static ListAdp size_(int v) {return new ListAdp_obj(v);}
|
||||
public static ListAdp many_(Object... ary) {return new ListAdp_obj().AddMany(ary);}
|
||||
public static final ListAdp Null = new ListAdp_null();
|
||||
public static void Add_list(ListAdp rv, ListAdp add) {
|
||||
int len = add.Count();
|
||||
for (int i = 0; i < len; ++i)
|
||||
rv.Add(add.FetchAt(i));
|
||||
}
|
||||
public static void DelAt_last(ListAdp list) {list.DelAt(list.Count() - 1);}
|
||||
public static Object Pop(ListAdp list) {
|
||||
int lastIdx = list.Count() - 1;
|
||||
Object rv = list.FetchAt(lastIdx);
|
||||
list.DelAt(lastIdx);
|
||||
return rv;
|
||||
}
|
||||
public static Object Pop_first(ListAdp list) { // NOTE: dirty way of implementing FIFO queue; should not be used with lists with many members
|
||||
Object rv = list.FetchAt(0);
|
||||
list.DelAt(0);
|
||||
return rv;
|
||||
}
|
||||
public static void DisposeAll(ListAdp list) {
|
||||
for (int i = 0; i < list.Count(); i++)
|
||||
((RlsAble)list.FetchAt(i)).Rls();
|
||||
}
|
||||
public static ListAdp new_ary_(Object ary) {
|
||||
int ary_len = Array_.Len(ary);
|
||||
ListAdp rv = size_(ary_len);
|
||||
for (int i = 0; i < ary_len; i++)
|
||||
rv.Add(Array_.Get(ary, i));
|
||||
return rv;
|
||||
}
|
||||
public static final int Capacity_initial = 8;
|
||||
public static final int NotFound = -1, Base1 = 1, LastIdxOffset = 1, CountToPos = 1;
|
||||
}
|
||||
class ListAdp_obj extends ListAdp_base implements ListAdp {
|
||||
public ListAdp_obj() {super();}
|
||||
public ListAdp_obj(int v) {super(v);}
|
||||
}
|
||||
class ListAdp_null implements ListAdp {
|
||||
public boolean Has_none() {return true;}
|
||||
public int Count() {return 0;}
|
||||
public Object FetchAt(int i) {return null;}
|
||||
public Object FetchAtLast() {return null;}
|
||||
public Object FetchAtOr(int i, Object or) {return null;}
|
||||
public Object PopLast() {return null;}
|
||||
public void Add(Object o) {}
|
||||
public void AddAt(int i, Object o) {}
|
||||
public ListAdp AddMany(Object... ary) {return this;}
|
||||
public void Del(Object o) {}
|
||||
public void DelAt(int i) {}
|
||||
public void Del_range(int bgn, int end) {}
|
||||
public void Clear() {}
|
||||
public void Clear_max(int max) {}
|
||||
public int LastIndex() {return -1;}
|
||||
public int IndexOf(Object o) {return ListAdp_.NotFound;}
|
||||
public void MoveTo(int elemPos, int newPos) {}
|
||||
public boolean RangeCheck(int v) {return false;}
|
||||
public void ResizeBounds(int i) {}
|
||||
public Object Xto_ary(Class<?> memberType) {return Object_.Ary_empty;}
|
||||
public Object Xto_ary_and_clear(Class<?> memberType) {return Object_.Ary_empty;}
|
||||
public String XtoStr() {return "< NULL LIST >";}
|
||||
public String[] XtoStrAry() {return new String[0];}
|
||||
public Object[] Xto_obj_ary() {return Object_.Ary_empty;}
|
||||
public java.util.Iterator iterator() {return Iterator_null._;}
|
||||
public void Reverse() {}
|
||||
public void SetAt(int i, Object o) {}
|
||||
public void Sort() {}
|
||||
public void SortBy(ComparerAble comparer) {}
|
||||
public void Shuffle() {}
|
||||
}
|
||||
73
100_core/src_140_list/gplx/List_adp.java
Normal file
73
100_core/src_140_list/gplx/List_adp.java
Normal file
@ -0,0 +1,73 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012 gnosygnu@gmail.com
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.lists.*; /*EnumerAble,ComparerAble*/
|
||||
public interface List_adp extends EnumerAble {
|
||||
int Count();
|
||||
Object Get_at(int i);
|
||||
Object Get_at_last();
|
||||
void Add(Object o);
|
||||
void Add_at(int i, Object o);
|
||||
void Add_many(Object... ary);
|
||||
void Del(Object o);
|
||||
void Del_at(int i);
|
||||
void Del_range(int bgn, int end);
|
||||
void Clear();
|
||||
int Idx_of(Object o);
|
||||
int Idx_last();
|
||||
Object To_ary(Class<?> memberType);
|
||||
Object To_ary_and_clear(Class<?> memberType);
|
||||
String[] To_str_ary();
|
||||
Object[] To_obj_ary();
|
||||
void Resize_bounds(int i);
|
||||
void Move_to(int src, int trg);
|
||||
void Reverse();
|
||||
void Sort();
|
||||
void Sort_by(ComparerAble comparer);
|
||||
void Shuffle();
|
||||
}
|
||||
class List_adp_obj extends List_adp_base implements List_adp {
|
||||
public List_adp_obj() {super();}
|
||||
public List_adp_obj(int v) {super(v);}
|
||||
}
|
||||
class List_adp_noop implements List_adp {
|
||||
public int Count() {return 0;}
|
||||
public Object Get_at(int i) {return null;}
|
||||
public Object Get_at_last() {return null;}
|
||||
public Object PopLast() {return null;}
|
||||
public void Add(Object o) {}
|
||||
public void Add_at(int i, Object o) {}
|
||||
public void Add_many(Object... ary) {}
|
||||
public void Del(Object o) {}
|
||||
public void Del_at(int i) {}
|
||||
public void Del_range(int bgn, int end) {}
|
||||
public void Clear() {}
|
||||
public int Idx_last() {return -1;}
|
||||
public int Idx_of(Object o) {return List_adp_.NotFound;}
|
||||
public void Move_to(int elemPos, int newPos) {}
|
||||
public void Resize_bounds(int i) {}
|
||||
public Object To_ary(Class<?> memberType) {return Object_.Ary_empty;}
|
||||
public Object To_ary_and_clear(Class<?> memberType) {return Object_.Ary_empty;}
|
||||
public String[] To_str_ary() {return new String[0];}
|
||||
public Object[] To_obj_ary() {return Object_.Ary_empty;}
|
||||
public java.util.Iterator iterator() {return Iterator_null._;}
|
||||
public void Reverse() {}
|
||||
public void Sort() {}
|
||||
public void Sort_by(ComparerAble comparer) {}
|
||||
public void Shuffle() {}
|
||||
}
|
||||
66
100_core/src_140_list/gplx/List_adp_.java
Normal file
66
100_core/src_140_list/gplx/List_adp_.java
Normal file
@ -0,0 +1,66 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012 gnosygnu@gmail.com
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.lists.*; /*EnumerAble,ComparerAble*/
|
||||
public class List_adp_ {
|
||||
public static final List_adp Noop = new List_adp_noop();
|
||||
public static List_adp as_(Object obj) {return obj instanceof List_adp ? (List_adp)obj : null;}
|
||||
public static List_adp new_() {return new List_adp_obj();}
|
||||
public static List_adp size_(int v) {return new List_adp_obj(v);}
|
||||
public static List_adp many_(Object... ary) {
|
||||
List_adp rv = new List_adp_obj();
|
||||
rv.Add_many(ary);
|
||||
return rv;
|
||||
}
|
||||
public static void Add_list(List_adp rv, List_adp add) {
|
||||
int len = add.Count();
|
||||
for (int i = 0; i < len; ++i)
|
||||
rv.Add(add.Get_at(i));
|
||||
}
|
||||
public static void DelAt_last(List_adp list) {list.Del_at(list.Count() - 1);}
|
||||
public static Object Pop(List_adp list) {
|
||||
int lastIdx = list.Count() - 1;
|
||||
Object rv = list.Get_at(lastIdx);
|
||||
list.Del_at(lastIdx);
|
||||
return rv;
|
||||
}
|
||||
public static Object Pop_first(List_adp list) { // NOTE: dirty way of implementing FIFO queue; should not be used with lists with many members
|
||||
Object rv = list.Get_at(0);
|
||||
list.Del_at(0);
|
||||
return rv;
|
||||
}
|
||||
public static Object Pop_last(List_adp list) {
|
||||
int last_idx = list.Count() - 1;
|
||||
Object rv = list.Get_at(last_idx);
|
||||
list.Del_at(last_idx);
|
||||
return rv;
|
||||
}
|
||||
public static void DisposeAll(List_adp list) {
|
||||
for (int i = 0; i < list.Count(); i++)
|
||||
((RlsAble)list.Get_at(i)).Rls();
|
||||
}
|
||||
public static List_adp new_ary_(Object ary) {
|
||||
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));
|
||||
return rv;
|
||||
}
|
||||
public static final int Capacity_initial = 8;
|
||||
public static final int NotFound = -1, Base1 = 1, LastIdxOffset = 1, CountToPos = 1;
|
||||
}
|
||||
@ -17,15 +17,16 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.core.strings.*; import gplx.lists.*;
|
||||
public abstract class ListAdp_base implements ListAdp, GfoInvkAble {
|
||||
public Object Xto_ary_and_clear(Class<?> memberType) {Object rv = Xto_ary(memberType); this.Clear(); return rv;}
|
||||
public Object Xto_ary(Class<?> memberType) {
|
||||
public abstract class List_adp_base implements List_adp, GfoInvkAble {
|
||||
private Object[] list; private int count;
|
||||
public Object To_ary_and_clear(Class<?> memberType) {Object rv = To_ary(memberType); this.Clear(); return rv;}
|
||||
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]);
|
||||
return rv;
|
||||
}
|
||||
public Object[] Xto_obj_ary() {
|
||||
public Object[] To_obj_ary() {
|
||||
Object[] rv = new Object[count];
|
||||
for (int i = 0; i < count; ++i)
|
||||
rv[i] = list[i];
|
||||
@ -37,13 +38,10 @@ public abstract class ListAdp_base implements ListAdp, GfoInvkAble {
|
||||
else
|
||||
return new Iterator_objAry(list, count);
|
||||
}
|
||||
public ListAdp AddMany(Object... ary) {for (Object o : ary) Add_base(o); return this;}
|
||||
|
||||
public boolean Has_none() {return count == 0;}
|
||||
public int Idx_last() {return Count() - 1;}
|
||||
public void Add_many(Object... ary) {for (Object o : ary) Add_base(o);}
|
||||
public int Count() {return count;}
|
||||
public int LastIndex() {return count - 1;}
|
||||
protected Object FetchAt_base(int index) {if (index >= count || index < 0) throw Err_.missing_idx_(index, count);
|
||||
public int Idx_last() {return count - 1;}
|
||||
protected Object Get_at_base(int index) {if (index >= count || index < 0) throw Err_.missing_idx_(index, count);
|
||||
return list[index];
|
||||
}
|
||||
protected void Add_base(Object o) {
|
||||
@ -52,8 +50,8 @@ public abstract class ListAdp_base implements ListAdp, GfoInvkAble {
|
||||
count++;
|
||||
}
|
||||
protected int Del_base(Object o) {
|
||||
int index = IndexOf_base(o); if (index == ListAdp_.NotFound) return ListAdp_.NotFound;
|
||||
this.DelAt(index);
|
||||
int index = IndexOf_base(o); if (index == List_adp_.NotFound) return List_adp_.NotFound;
|
||||
this.Del_at(index);
|
||||
return index;
|
||||
}
|
||||
public void Del_range(int delBgn, int delEnd) {
|
||||
@ -72,37 +70,21 @@ public abstract class ListAdp_base implements ListAdp, GfoInvkAble {
|
||||
list = newList;
|
||||
count = list.length;
|
||||
}
|
||||
public Object PopLast() {
|
||||
int lastIdx = count - 1;
|
||||
Object rv = FetchAt(lastIdx);
|
||||
DelAt(lastIdx);
|
||||
return rv;
|
||||
}
|
||||
void BoundsChk(int bgn, int end, int len) {
|
||||
if ( bgn >= 0 && bgn < len
|
||||
&& end >= 0 && end < len
|
||||
&& bgn <= end
|
||||
) return;
|
||||
throw Err_.new_("bounds check failed").Add("bgn", bgn).Add("end", end).Add("len", len);
|
||||
}
|
||||
public boolean RangeCheck(int v) {return v >= 0 && v < count;}
|
||||
protected int IndexOf_base(Object o) {
|
||||
for (int i = 0; i < count; i++)
|
||||
if (Object_.Eq(list[i], o)) return i;
|
||||
return ListAdp_.NotFound;
|
||||
return List_adp_.NotFound;
|
||||
}
|
||||
@gplx.Virtual public void Clear() {
|
||||
for (int i = 0; i < count; i++)
|
||||
list[i] = null;
|
||||
count = 0;
|
||||
// if (Capacity() != ListAdp_.Capacity_initial) list = new Object[ListAdp_.Capacity_initial]; // COMMENT:2012-06-16
|
||||
}
|
||||
public void Clear_max(int max) {this.Clear(); if (Capacity() > max) list = new Object[max];}
|
||||
@gplx.Virtual public void DelAt(int index) {if (index >= count || index < 0) throw Err_.missing_idx_(index, count);
|
||||
@gplx.Virtual public void Del_at(int index) {if (index >= count || index < 0) throw Err_.missing_idx_(index, count);
|
||||
Collapse(index);
|
||||
count--;
|
||||
}
|
||||
public void MoveTo(int src, int trg) {if (src >= count || src < 0) throw Err_.missing_idx_(src, count); if (trg >= count || trg < 0) throw Err_.missing_idx_(trg, count);
|
||||
public void Move_to(int src, int trg) {if (src >= count || src < 0) throw Err_.missing_idx_(src, count); if (trg >= count || trg < 0) throw Err_.missing_idx_(trg, count);
|
||||
if (src == trg) return; // position not changed
|
||||
Object o = list[src];
|
||||
int dif = trg > src ? 1 : -1;
|
||||
@ -117,21 +99,11 @@ public abstract class ListAdp_base implements ListAdp, GfoInvkAble {
|
||||
list[pos] = o;
|
||||
count = count + 1;
|
||||
}
|
||||
public void ResizeBounds(int i) {
|
||||
public void Resize_bounds(int i) {
|
||||
Resize_expand(i);
|
||||
}
|
||||
public String XtoStr() {
|
||||
String_bldr sb = String_bldr_.new_();
|
||||
for (int i = 0; i < count; i++) {
|
||||
if (i != 0) sb.Add_char_crlf();
|
||||
Object val = list[i];
|
||||
sb.Add_obj(Object_.Xto_str_strict_or_empty(val));
|
||||
}
|
||||
return sb.XtoStr();
|
||||
}
|
||||
public void SetAt(int i, Object o) {list[i] = o;}
|
||||
public void Sort() {SortBy(null);}
|
||||
public void SortBy(ComparerAble comparer) {ListAdp_Sorter.new_().Sort(list, count, true, comparer);}
|
||||
public void Sort() {Sort_by(null);}
|
||||
public void Sort_by(ComparerAble comparer) {List_adp_sorter.new_().Sort(list, count, true, comparer);}
|
||||
public void Reverse() {
|
||||
int mid = count / 2; // no need to reverse pivot; ex: for 3 elements, only 1 and 3 need to be exchanged; 2 stays inplace
|
||||
for (int lhs = 0; lhs < mid; lhs++) {
|
||||
@ -150,22 +122,26 @@ public abstract class ListAdp_base implements ListAdp, GfoInvkAble {
|
||||
list[i-1] = tmp;
|
||||
}
|
||||
}
|
||||
public String[] XtoStrAry() {return (String[])Xto_ary(String.class);}
|
||||
public Object FetchAt(int i) {return FetchAt_base(i);}
|
||||
public Object FetchAtLast() {if (count == 0) throw Err_.invalid_op_("cannot call FetchAtLast on empty list"); return FetchAt_base(count - 1);}
|
||||
public Object FetchAtOr(int i, Object or) {return (i >= count) ? or : FetchAt(i);}
|
||||
public String[] To_str_ary() {return (String[])To_ary(String.class);}
|
||||
public Object Get_at(int i) {return Get_at_base(i);}
|
||||
public Object Get_at_last() {if (count == 0) throw Err_.invalid_op_("cannot call Get_at_last on empty list"); return Get_at_base(count - 1);}
|
||||
public void Add(Object item) {Add_base(item);}
|
||||
public void AddAt(int i, Object o) {AddAt_base(i, o);}
|
||||
public void Add_at(int i, Object o) {AddAt_base(i, o);}
|
||||
public void Del(Object item) {Del_base(item);}
|
||||
public int IndexOf(Object o) {return IndexOf_base(o);}
|
||||
|
||||
Object[] list; int count;
|
||||
public ListAdp_base() {
|
||||
list = new Object[ListAdp_.Capacity_initial];
|
||||
public int Idx_of(Object o) {return IndexOf_base(o);}
|
||||
public List_adp_base() {
|
||||
list = new Object[List_adp_.Capacity_initial];
|
||||
}
|
||||
public ListAdp_base(int capacity) {
|
||||
public List_adp_base(int capacity) {
|
||||
list = new Object[capacity];
|
||||
}
|
||||
private void BoundsChk(int bgn, int end, int len) {
|
||||
if ( bgn >= 0 && bgn < len
|
||||
&& end >= 0 && end < len
|
||||
&& bgn <= end
|
||||
) return;
|
||||
throw Err_.new_("bounds check failed").Add("bgn", bgn).Add("end", end).Add("len", len);
|
||||
}
|
||||
void Resize_expand() {Resize_expand(count * 2);}
|
||||
void Resize_expand(int newCount) {
|
||||
Object[] trg = new Object[newCount];
|
||||
@ -183,7 +159,7 @@ public abstract class ListAdp_base implements ListAdp, GfoInvkAble {
|
||||
@gplx.Internal protected int Capacity() {return Array_.LenAry(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 FetchAt(m.ReadInt("v"));
|
||||
else if (ctx.Match(k, Invk_get_at)) return Get_at(m.ReadInt("v"));
|
||||
else return GfoInvkAble_.Rv_unhandled;
|
||||
// return this;
|
||||
} private static final String Invk_len = "len", Invk_get_at = "get_at";
|
||||
@ -17,7 +17,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.lists.*;
|
||||
public class ListAdp_Sorter {
|
||||
public class List_adp_sorter {
|
||||
private ComparerAble comparer = null;
|
||||
public void Sort(Object[] orig, int origLen) {Sort(orig, origLen, true, null);}
|
||||
public void Sort(Object[] orig, int origLen, boolean asc, ComparerAble comparer) {
|
||||
this.comparer = comparer;
|
||||
@ -33,8 +34,7 @@ public class ListAdp_Sorter {
|
||||
Combine(asc, orig, temp, lhs, mid + 1, rhs);
|
||||
}
|
||||
}
|
||||
ComparerAble comparer = null;
|
||||
void Combine(boolean asc, Object[] orig, Object[] temp, int lhsPos, int rhsPos, int rhsEnd) {
|
||||
private void Combine(boolean asc, Object[] orig, Object[] temp, int lhsPos, int rhsPos, int rhsEnd) {
|
||||
int lhsEnd = rhsPos - 1;
|
||||
int tmpPos = lhsPos;
|
||||
int aryLen = rhsEnd - lhsPos + 1;
|
||||
@ -62,7 +62,7 @@ public class ListAdp_Sorter {
|
||||
orig[rhsEnd] = temp[rhsEnd];
|
||||
}
|
||||
|
||||
public static ListAdp_Sorter new_() {return new ListAdp_Sorter();} ListAdp_Sorter() {}
|
||||
public static List_adp_sorter new_() {return new List_adp_sorter();} List_adp_sorter() {}
|
||||
}
|
||||
class Iterator_objAry implements java.util.Iterator {
|
||||
public boolean hasNext() {return ++pos < len;}
|
||||
@ -17,15 +17,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import org.junit.*;
|
||||
public class ListAdp_Sorter_tst {
|
||||
public class List_adp_sorter_tst {
|
||||
@Test public void Basic() {
|
||||
Object[] src = new Object[] {0,8,1,7,2,6,3,5,4};
|
||||
ListAdp_Sorter.new_().Sort(src, src.length);
|
||||
List_adp_sorter.new_().Sort(src, src.length);
|
||||
Tfds.Eq_ary(src, Sequential(0, 8));
|
||||
}
|
||||
@Test public void Basic2() {
|
||||
Object[] src = new Object[] {"0","8","1","7","2","6","3","5","4"};
|
||||
ListAdp_Sorter.new_().Sort(src, src.length);
|
||||
List_adp_sorter.new_().Sort(src, src.length);
|
||||
Tfds.Eq_ary(src, new Object[] {"0","1","2","3","4","5","6","7","8"});
|
||||
}
|
||||
Object[] Sequential(int bgn, int end) {
|
||||
@ -17,11 +17,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import org.junit.*;
|
||||
public class ListAdp_tst {
|
||||
public class List_adp_tst {
|
||||
@Before public void setup() {
|
||||
list = ListAdp_.new_();
|
||||
listBase = (ListAdp_base)list;
|
||||
} ListAdp list; ListAdp_base listBase;
|
||||
list = List_adp_.new_();
|
||||
listBase = (List_adp_base)list;
|
||||
} List_adp list; List_adp_base listBase;
|
||||
@Test public void Add() {
|
||||
Tfds.Eq(0, list.Count());
|
||||
|
||||
@ -29,7 +29,7 @@ public class ListAdp_tst {
|
||||
Tfds.Eq(1, list.Count());
|
||||
}
|
||||
@Test public void Add_changeCapacity() {
|
||||
int capacity = ListAdp_.Capacity_initial;
|
||||
int capacity = List_adp_.Capacity_initial;
|
||||
for (int i = 0; i < capacity; i++)
|
||||
list.Add("0");
|
||||
Tfds.Eq(capacity, list.Count());
|
||||
@ -39,41 +39,41 @@ public class ListAdp_tst {
|
||||
Tfds.Eq(capacity + 1, list.Count());
|
||||
Tfds.Eq(capacity * 2, listBase.Capacity());
|
||||
}
|
||||
@Test public void FetchAt() {
|
||||
@Test public void Get_at() {
|
||||
list.Add("0");
|
||||
|
||||
Tfds.Eq("0", list.FetchAt(0));
|
||||
Tfds.Eq("0", list.Get_at(0));
|
||||
}
|
||||
@Test public void Fetch_many() {
|
||||
list_AddMany("0", "1");
|
||||
|
||||
Tfds.Eq("0", list.FetchAt(0));
|
||||
Tfds.Eq("1", list.FetchAt(1));
|
||||
Tfds.Eq("0", list.Get_at(0));
|
||||
Tfds.Eq("1", list.Get_at(1));
|
||||
}
|
||||
@Test public void FetchAt_fail() {
|
||||
try {list.FetchAt(0);}
|
||||
try {list.Get_at(0);}
|
||||
catch (Exception exc) {Err_.Noop(exc); return;}
|
||||
Tfds.Fail("FetchAt should fail for out of bound index");
|
||||
Tfds.Fail("Get_at should fail for out of bound index");
|
||||
}
|
||||
@Test public void DelAt() {
|
||||
@Test public void Del_at() {
|
||||
list.Add("0");
|
||||
Tfds.Eq(1, list.Count());
|
||||
|
||||
list.DelAt(0);
|
||||
list.Del_at(0);
|
||||
Tfds.Eq(0, list.Count());
|
||||
}
|
||||
@Test public void DelAt_shiftDown() {
|
||||
list_AddMany("0", "1");
|
||||
Tfds.Eq(list.Count(), 2);
|
||||
|
||||
list.DelAt(0);
|
||||
list.Del_at(0);
|
||||
Tfds.Eq(1, list.Count());
|
||||
Tfds.Eq("1", list.FetchAt(0));
|
||||
Tfds.Eq("1", list.Get_at(0));
|
||||
}
|
||||
@Test public void DelAt_fail() {
|
||||
try {list.DelAt(0);}
|
||||
try {list.Del_at(0);}
|
||||
catch (Exception exc) {Err_.Noop(exc); return;}
|
||||
Tfds.Fail("DelAt should fail for out of bound index");
|
||||
Tfds.Fail("Del_at should fail for out of bound index");
|
||||
}
|
||||
@Test public void Del() {
|
||||
list.Add("0");
|
||||
@ -88,7 +88,7 @@ public class ListAdp_tst {
|
||||
|
||||
list.Del("1");
|
||||
Tfds.Eq(1, list.Count());
|
||||
Tfds.Eq("0", list.FetchAt(0));
|
||||
Tfds.Eq("0", list.Get_at(0));
|
||||
}
|
||||
@Test public void Del_matchFirst() {
|
||||
list_AddMany("0", "1", "0");
|
||||
@ -97,13 +97,6 @@ public class ListAdp_tst {
|
||||
list.Del("0");
|
||||
tst_Enumerator("1", "0");
|
||||
}
|
||||
@Test public void Has_none() {
|
||||
Tfds.Eq_true(list.Has_none());
|
||||
list.Add("0");
|
||||
Tfds.Eq_false(list.Has_none());
|
||||
list.DelAt(0);
|
||||
Tfds.Eq_true(list.Has_none());
|
||||
}
|
||||
@Test public void Enumerator() {
|
||||
list_AddMany("0", "1", "2");
|
||||
tst_Enumerator("0", "1", "2");
|
||||
@ -123,7 +116,7 @@ public class ListAdp_tst {
|
||||
}
|
||||
}
|
||||
@Test public void Clear() {
|
||||
int capacity = ListAdp_.Capacity_initial;
|
||||
int capacity = List_adp_.Capacity_initial;
|
||||
for (int i = 0; i < capacity + 1; i++)
|
||||
list.Add("0");
|
||||
Tfds.Eq(capacity * 2, listBase.Capacity());
|
||||
@ -152,22 +145,15 @@ public class ListAdp_tst {
|
||||
@Test public void Sort_empty() {list.Sort();}
|
||||
@Test public void Xto_bry() {
|
||||
list_AddMany("0", "1");
|
||||
String[] ary = (String[])list.Xto_ary(String.class);
|
||||
String[] ary = (String[])list.To_ary(String.class);
|
||||
Tfds.Eq_nullNot(ary);
|
||||
Tfds.Eq(2, Array_.Len(ary));
|
||||
}
|
||||
@Test public void XtoAry_empty() {
|
||||
String[] ary = (String[])list.Xto_ary(String.class);
|
||||
String[] ary = (String[])list.To_ary(String.class);
|
||||
Tfds.Eq_nullNot(ary);
|
||||
Tfds.Eq(0, Array_.Len(ary));
|
||||
}
|
||||
@Test public void XtoStr() {
|
||||
list_AddMany("0", "1", "2");
|
||||
Tfds.Eq("0\r\n1\r\n2", list.XtoStr());
|
||||
}
|
||||
@Test public void XtoStr_empty() {
|
||||
Tfds.Eq("", list.XtoStr());
|
||||
}
|
||||
@Test public void Shuffle() {
|
||||
for (int i = 0; i < 25; i++)
|
||||
list.Add(i);
|
||||
@ -175,7 +161,7 @@ public class ListAdp_tst {
|
||||
list.Shuffle();
|
||||
int hasMovedCount = 0;
|
||||
for (int i = 0; i < list.Count(); i++) {
|
||||
int val = Int_.cast_(list.FetchAt(i));
|
||||
int val = Int_.cast_(list.Get_at(i));
|
||||
if (val != i) hasMovedCount++;
|
||||
}
|
||||
Tfds.Eq_true(hasMovedCount > 0, "all documents have the same index"); // NOTE: may still fail occasionally (1%)
|
||||
@ -186,7 +172,7 @@ public class ListAdp_tst {
|
||||
Tfds.Eq(0, list.Count(), "shuffled list does not have the same contents as original list");
|
||||
}
|
||||
@Test public void Shuffle_empty() {list.Shuffle();}
|
||||
@Test public void MoveTo() {
|
||||
@Test public void Move_to() {
|
||||
run_ClearAndAdd("0", "1", "2").run_MoveTo(0, 1).tst_Order("1", "0", "2");
|
||||
run_ClearAndAdd("0", "1", "2").run_MoveTo(0, 2).tst_Order("1", "2", "0");
|
||||
run_ClearAndAdd("0", "1", "2").run_MoveTo(2, 1).tst_Order("0", "2", "1");
|
||||
@ -202,9 +188,9 @@ public class ListAdp_tst {
|
||||
}
|
||||
void tst_DelRange(int bgn, int end, String... expd) {
|
||||
list.Del_range(bgn, end);
|
||||
Tfds.Eq_ary_str(expd, list.XtoStrAry());
|
||||
Tfds.Eq_ary_str(expd, list.To_str_ary());
|
||||
}
|
||||
ListAdp_tst run_ClearAndAdd(String... ary) {
|
||||
List_adp_tst run_ClearAndAdd(String... ary) {
|
||||
list.Clear();
|
||||
for (int i = 0; i < Array_.Len(ary); i++) {
|
||||
String val = ary[i];
|
||||
@ -212,9 +198,9 @@ public class ListAdp_tst {
|
||||
}
|
||||
return this;
|
||||
}
|
||||
ListAdp_tst run_MoveTo(int elemPos, int newPos) {list.MoveTo(elemPos, newPos); return this;}
|
||||
ListAdp_tst tst_Order(String... expd) {
|
||||
String[] actl = (String[])list.Xto_ary(String.class);
|
||||
List_adp_tst run_MoveTo(int elemPos, int newPos) {list.Move_to(elemPos, newPos); return this;}
|
||||
List_adp_tst tst_Order(String... expd) {
|
||||
String[] actl = (String[])list.To_ary(String.class);
|
||||
Tfds.Eq_ary(expd, actl);
|
||||
return this;
|
||||
}
|
||||
@ -17,17 +17,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.lists.*; /*EnumerAble,ComparerAble*/
|
||||
public interface OrderedHash extends HashAdp {
|
||||
Object FetchAt(int i);
|
||||
Object FetchAtOr(int i, Object or);
|
||||
void AddAt(int i, Object o);
|
||||
int IndexOf(Object item);
|
||||
public interface Ordered_hash extends Hash_adp {
|
||||
Object Get_at(int i);
|
||||
void Add_at(int i, Object o);
|
||||
int Idx_of(Object item);
|
||||
void Sort();
|
||||
void SortBy(ComparerAble comparer);
|
||||
void ResizeBounds(int i);
|
||||
Object Xto_ary(Class<?> t);
|
||||
Object Xto_ary_and_clear(Class<?> t);
|
||||
String XtoStr_ui();
|
||||
void MoveTo(int src, int trg);
|
||||
void Sort_by(ComparerAble comparer);
|
||||
void Resize_bounds(int i);
|
||||
Object To_ary(Class<?> t);
|
||||
Object To_ary_and_clear(Class<?> t);
|
||||
void Move_to(int src, int trg);
|
||||
void Lock();
|
||||
}
|
||||
@ -17,11 +17,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import gplx.core.primitives.*;
|
||||
public class OrderedHash_ {
|
||||
public static OrderedHash new_() {return new OrderedHash_base();}
|
||||
public static OrderedHash new_bry_() {return new OrderedHash_bry();}
|
||||
public class Ordered_hash_ {
|
||||
public static Ordered_hash new_() {return new Ordered_hash_base();}
|
||||
public static Ordered_hash new_bry_() {return new Ordered_hash_bry();}
|
||||
}
|
||||
class OrderedHash_bry extends OrderedHash_base {
|
||||
class Ordered_hash_bry extends Ordered_hash_base {
|
||||
private final Bry_obj_ref tmp_ref = Bry_obj_ref.null_();
|
||||
@Override protected void Add_base(Object key, Object val) {super.Add_base(Bry_obj_ref.new_((byte[])key), val);}
|
||||
@Override protected void Del_base(Object key) {synchronized (tmp_ref) {super.Del_base(tmp_ref.Val_((byte[])key));}}
|
||||
@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx;
|
||||
import gplx.core.strings.*;
|
||||
import gplx.lists.*; /*EnumerAble,ComparerAble*/
|
||||
public class OrderedHash_base extends HashAdp_base implements OrderedHash, GfoInvkAble {
|
||||
public class Ordered_hash_base extends Hash_adp_base implements Ordered_hash, GfoInvkAble {
|
||||
@Override protected void Add_base(Object key, Object val) {
|
||||
super.Add_base(key, val);
|
||||
ordered.Add(val);
|
||||
@ -31,47 +31,46 @@ public class OrderedHash_base extends HashAdp_base implements OrderedHash, GfoIn
|
||||
ordered.Del(val);
|
||||
AssertCounts();
|
||||
}
|
||||
protected Object FetchAt_base(int index) {return ordered.FetchAt(index);}
|
||||
protected int IndexOf_base(Object obj) {return ordered.IndexOf(obj);}
|
||||
protected Object Get_at_base(int index) {return ordered.Get_at(index);}
|
||||
protected int IndexOf_base(Object obj) {return ordered.Idx_of(obj);}
|
||||
@Override public void Clear() {
|
||||
if (locked) Lock_fail();
|
||||
super.Clear();
|
||||
ordered.Clear();
|
||||
}
|
||||
public Object Xto_ary(Class<?> type) {return ordered.Xto_ary(type);}
|
||||
public Object Xto_ary_and_clear(Class<?> t) {
|
||||
Object rv = Xto_ary(t);
|
||||
public Object To_ary(Class<?> type) {return ordered.To_ary(type);}
|
||||
public Object To_ary_and_clear(Class<?> t) {
|
||||
Object rv = To_ary(t);
|
||||
this.Clear();
|
||||
return rv;
|
||||
}
|
||||
@gplx.Virtual public void Sort() {if (locked) Lock_fail(); ordered.Sort();} // NOTE: uses item's .compareTo
|
||||
public void SortBy(ComparerAble comparer) {if (locked) Lock_fail(); ordered.SortBy(comparer);}
|
||||
public void Sort_by(ComparerAble comparer) {if (locked) Lock_fail(); ordered.Sort_by(comparer);}
|
||||
@Override public java.util.Iterator iterator() {return ordered.iterator();}
|
||||
public void AddAt(int i, Object key, Object val) {
|
||||
public void Add_at(int i, Object key, Object val) {
|
||||
if (locked) Lock_fail();
|
||||
super.Add_base(key, val);
|
||||
ordered.AddAt(i, val);
|
||||
ordered.Add_at(i, val);
|
||||
AssertCounts();
|
||||
}
|
||||
void AssertCounts() {
|
||||
if (super.Count() != ordered.Count()) throw Err_.new_("counts do not match").Add("hash", super.Count()).Add("list", ordered.Count());
|
||||
}
|
||||
public void ResizeBounds(int i) {if (locked) Lock_fail(); ordered.ResizeBounds(i);}
|
||||
public void Resize_bounds(int i) {if (locked) Lock_fail(); ordered.Resize_bounds(i);}
|
||||
public void Lock() {locked = true;} private boolean locked = false;
|
||||
void Lock_fail() {throw Err_mgr._.fmt_(GRP_KEY, "locked", "collection is locked");}
|
||||
static final String GRP_KEY = "gplx.lists.ordered_hash";
|
||||
public void AddAt(int i, Object o) {if (locked) Lock_fail(); ordered.AddAt(i, o);}
|
||||
public Object FetchAt(int i) {return FetchAt_base(i);}
|
||||
public Object FetchAtOr(int i, Object or) {return ordered.FetchAtOr(i, or);}
|
||||
public int IndexOf(Object obj) {return this.IndexOf_base(obj);}
|
||||
public void MoveTo(int src, int trg) {if (locked) Lock_fail(); ordered.MoveTo(src, trg);}
|
||||
public String XtoStr_ui() {
|
||||
public void Add_at(int i, Object o) {if (locked) Lock_fail(); ordered.Add_at(i, o);}
|
||||
public Object Get_at(int i) {return Get_at_base(i);}
|
||||
public int Idx_of(Object obj) {return this.IndexOf_base(obj);}
|
||||
public void Move_to(int src, int trg) {if (locked) Lock_fail(); ordered.Move_to(src, trg);}
|
||||
private String To_str_ui() {
|
||||
String_bldr sb = String_bldr_.new_();
|
||||
int count = ordered.Count();
|
||||
int pad = String_.Len(Int_.Xto_str(count));
|
||||
for (int i = 0; i < count; i++) {
|
||||
sb .Add(Int_.Xto_str_pad_bgn_zero(i, pad))
|
||||
.Add(":").Add(ordered.FetchAt(i).toString())
|
||||
.Add(":").Add(ordered.Get_at(i).toString())
|
||||
.Add(Op_sys.Cur().Nl_str());
|
||||
}
|
||||
return sb.XtoStr();
|
||||
@ -84,12 +83,12 @@ public class OrderedHash_base extends HashAdp_base implements OrderedHash, GfoIn
|
||||
}
|
||||
else if (ctx.Match(k, Invk_Print)) {
|
||||
if (ctx.Deny()) return this;
|
||||
return XtoStr_ui();
|
||||
return To_str_ui();
|
||||
}
|
||||
else return GfoInvkAble_.Rv_unhandled;
|
||||
return this;
|
||||
} static final String Invk_SetKeyOnly = "SetKeyOnly", Invk_Print = "Print";
|
||||
final ListAdp ordered = ListAdp_.new_();
|
||||
final List_adp ordered = List_adp_.new_();
|
||||
@Override public int Count() {return ordered.Count();}
|
||||
public OrderedHash_base() {}
|
||||
public Ordered_hash_base() {}
|
||||
}
|
||||
@ -17,23 +17,23 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import org.junit.*;
|
||||
public class OrderedHash_tst {
|
||||
public class Ordered_hash_tst {
|
||||
@Before public void setup() {
|
||||
hash = OrderedHash_.new_();
|
||||
hash = Ordered_hash_.new_();
|
||||
}
|
||||
@Test public void FetchAt() {
|
||||
@Test public void Get_at() {
|
||||
hash.Add("key1", "val1");
|
||||
Tfds.Eq("val1", hash.FetchAt(0));
|
||||
Tfds.Eq("val1", hash.Get_at(0));
|
||||
}
|
||||
@Test public void iterator() {
|
||||
hash.Add("key2", "val2");
|
||||
hash.Add("key1", "val1");
|
||||
|
||||
ListAdp list = ListAdp_.new_();
|
||||
List_adp list = List_adp_.new_();
|
||||
for (Object val : hash)
|
||||
list.Add(val);
|
||||
Tfds.Eq("val2", list.FetchAt(0));
|
||||
Tfds.Eq("val1", list.FetchAt(1));
|
||||
Tfds.Eq("val2", list.Get_at(0));
|
||||
Tfds.Eq("val1", list.Get_at(1));
|
||||
}
|
||||
OrderedHash hash;
|
||||
Ordered_hash hash;
|
||||
}
|
||||
@ -16,11 +16,11 @@ You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx.lists; import gplx.*;
|
||||
public abstract class HashAdp_base implements HashAdp {
|
||||
public abstract class Hash_adp_base implements Hash_adp {
|
||||
public boolean Has(Object key) {return Has_base(key);}
|
||||
public Object Fetch(Object key) {return Fetch_base(key);}
|
||||
public Object FetchOrFail(Object key) {return FetchOrFail_base(key);}
|
||||
public Object FetchOrNew(Object key, NewAble proto) {
|
||||
public Object Get_by(Object key) {return Fetch_base(key);}
|
||||
public Object Get_by_or_fail(Object key) {return FetchOrFail_base(key);}
|
||||
public Object Get_by_or_new(Object key, NewAble proto) {
|
||||
Object rv = Fetch_base(key);
|
||||
if (rv == null) {
|
||||
rv = proto.NewByKey(key);
|
||||
@ -29,12 +29,12 @@ public abstract class HashAdp_base implements HashAdp {
|
||||
return rv;
|
||||
}
|
||||
public void Add(Object key, Object val) {Add_base(key, val);}
|
||||
public void AddKeyVal(Object val) {Add_base(val, val);}
|
||||
public void AddReplace(Object key, Object val) {
|
||||
public void Add_as_key_and_val(Object val) {Add_base(val, val);}
|
||||
public void Add_if_dupe_use_nth(Object key, Object val) {
|
||||
Object existing = Fetch_base(key); if (existing != null) Del(key); // overwrite if exists
|
||||
Add(key, val);
|
||||
}
|
||||
public boolean Add_if_new(Object key, Object val) {
|
||||
public boolean Add_if_dupe_use_1st(Object key, Object val) {
|
||||
if (Has(key)) return false;
|
||||
Add(key, val);
|
||||
return true;
|
||||
@ -16,25 +16,25 @@ You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx.lists; import gplx.*;
|
||||
public class HashAdp_list extends HashAdp_base {
|
||||
@gplx.New public ListAdp Fetch(Object key) {return ListAdp_.as_(Fetch_base(key));}
|
||||
public ListAdp FetchOrNew(Object key) {
|
||||
ListAdp rv = Fetch(key);
|
||||
public class Hash_adp_list extends Hash_adp_base {
|
||||
@gplx.New public List_adp Get_by(Object key) {return List_adp_.as_(Fetch_base(key));}
|
||||
public List_adp Get_by_or_new(Object key) {
|
||||
List_adp rv = Get_by(key);
|
||||
if (rv == null) {
|
||||
rv = ListAdp_.new_();
|
||||
rv = List_adp_.new_();
|
||||
Add_base(key, rv);
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
public void AddInList(Object key, Object val) {
|
||||
ListAdp list = FetchOrNew(key);
|
||||
List_adp list = Get_by_or_new(key);
|
||||
list.Add(val);
|
||||
}
|
||||
public void DelInList(Object key, Object val) {
|
||||
ListAdp list = Fetch(key);
|
||||
List_adp list = Get_by(key);
|
||||
if (list == null) return;
|
||||
list.Del(val);
|
||||
if (list.Count() == 0) Del(key);
|
||||
}
|
||||
public static HashAdp_list new_() {return new HashAdp_list();} HashAdp_list() {}
|
||||
public static Hash_adp_list new_() {return new Hash_adp_list();} Hash_adp_list() {}
|
||||
}
|
||||
@ -22,5 +22,5 @@ public interface StackAdp extends EnumerAble {
|
||||
void Push(Object obj);
|
||||
Object Pop();
|
||||
Object Peek();
|
||||
ListAdp XtoList();
|
||||
List_adp XtoList();
|
||||
}
|
||||
|
||||
@ -23,8 +23,8 @@ class StackAdp_base implements StackAdp {
|
||||
public Object Peek() {return Peek_base();}
|
||||
public Object Pop() {return Pop_base();}
|
||||
public void Push(Object obj) {Push_base(obj);}
|
||||
public ListAdp XtoList() {
|
||||
ListAdp list = ListAdp_.new_();
|
||||
public List_adp XtoList() {
|
||||
List_adp list = List_adp_.new_();
|
||||
for (Object obj : stack)
|
||||
list.Add(obj);
|
||||
// NOTE: dotnet traverses last to first; java: first to last
|
||||
|
||||
@ -25,8 +25,8 @@ public class StackAdp_tst {
|
||||
StackAdp stack = StackAdp_.new_();
|
||||
for (int i : ary)
|
||||
stack.Push(i);
|
||||
ListAdp list = stack.XtoList();
|
||||
int[] actl = (int[])list.Xto_ary(int.class);
|
||||
List_adp list = stack.XtoList();
|
||||
int[] actl = (int[])list.To_ary(int.class);
|
||||
for (int i = 0; i < ary.length; i++)
|
||||
Tfds.Eq(ary[i], actl[i]);
|
||||
}
|
||||
|
||||
@ -50,7 +50,7 @@ public class Utf16_ {
|
||||
}
|
||||
else throw Err_.new_fmt_("invalid utf8 byte: byte={0}", b0);
|
||||
}
|
||||
public static byte[] Encode_hex_to_bry(String raw) {return Encode_hex_to_bry(Bry_.new_ascii_(raw));}
|
||||
public static byte[] Encode_hex_to_bry(String raw) {return Encode_hex_to_bry(Bry_.new_a7(raw));}
|
||||
public static byte[] Encode_hex_to_bry(byte[] raw) {
|
||||
if (raw == null) return null;
|
||||
int int_val = gplx.texts.HexDecUtl.parse_or_(raw, Int_.MinValue);
|
||||
|
||||
@ -24,7 +24,7 @@ public class Utf8__tst {
|
||||
fxt.Test_Get_pos0_of_char_bwd("a", 0); // len=1; short-String
|
||||
fxt.Test_Get_pos0_of_char_bwd("abc¢", 3); // len=2; (note that bry.len = 5)
|
||||
fxt.Test_Get_pos0_of_char_bwd("abc€", 3); // len=3; (note that bry.len = 6)
|
||||
fxt.Test_Get_pos0_of_char_bwd("abc" + String_.new_utf8_(Byte_.Ary_by_ints(240, 164, 173, 162)), 3); // len=4; (note that bry.len = 7)
|
||||
fxt.Test_Get_pos0_of_char_bwd("abc" + String_.new_u8(Byte_.Ary_by_ints(240, 164, 173, 162)), 3); // len=4; (note that bry.len = 7)
|
||||
}
|
||||
@Test public void Increment_char_at_last_pos() {
|
||||
fxt.Test_Increment_char_at_last_pos("a", "b");
|
||||
@ -59,11 +59,11 @@ public class Utf8__tst {
|
||||
}
|
||||
class Utf8__fxt {
|
||||
public void Test_Get_pos0_of_char_bwd(String str, int expd) {
|
||||
byte[] bry = Bry_.new_utf8_(str);
|
||||
byte[] bry = Bry_.new_u8(str);
|
||||
int pos = bry.length - 1; // always start from last char
|
||||
Tfds.Eq(expd, Utf8_.Get_pos0_of_char_bwd(bry, pos));
|
||||
}
|
||||
public void Test_Increment_char_at_last_pos(String str, String expd) {
|
||||
Tfds.Eq(expd, String_.new_utf8_(Utf8_.Increment_char_at_last_pos(Bry_.new_utf8_(str))));
|
||||
Tfds.Eq(expd, String_.new_u8(Utf8_.Increment_char_at_last_pos(Bry_.new_u8(str))));
|
||||
}
|
||||
}
|
||||
|
||||
@ -17,7 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx.texts; import gplx.*;
|
||||
public class Base32Converter {
|
||||
public static String EncodeString(String orig) {return Encode(Bry_.new_utf8_(orig));}
|
||||
public static String EncodeString(String orig) {return Encode(Bry_.new_u8(orig));}
|
||||
public static String Encode(byte[] raw) {
|
||||
int i = 0, index = 0, digit = 0; int currByte, nextByte;
|
||||
int rawLen = Array_.Len(raw);
|
||||
@ -45,7 +45,7 @@ public class Base32Converter {
|
||||
}
|
||||
return new String(ary, 0, aryPos);
|
||||
}
|
||||
public static String DecodeString(String orig) {return String_.new_utf8_(Decode(orig));}
|
||||
public static String DecodeString(String orig) {return String_.new_u8(Decode(orig));}
|
||||
public static byte[] Decode(String raw) {
|
||||
int i, index, lookup, offset; byte digit;
|
||||
int rawLen = String_.Len(raw);
|
||||
|
||||
@ -25,7 +25,7 @@ public class Base64Converter {
|
||||
toInt[ALPHABET[i]]= i;
|
||||
}
|
||||
}
|
||||
public static String EncodeString(String orig) {return Encode(Bry_.new_utf8_(orig));}
|
||||
public static String EncodeString(String orig) {return Encode(Bry_.new_u8(orig));}
|
||||
public static String Encode(byte[] buf){
|
||||
if (toInt == null) Init();
|
||||
int size = buf.length;
|
||||
@ -51,7 +51,7 @@ public class Base64Converter {
|
||||
}
|
||||
return new String(ar);
|
||||
}
|
||||
public static String DecodeString(String orig) {return String_.new_utf8_(Decode(orig));}
|
||||
public static String DecodeString(String orig) {return String_.new_u8(Decode(orig));}
|
||||
public static byte[] Decode(String s){
|
||||
if (toInt == null) Init();
|
||||
int sLen = String_.Len(s);
|
||||
|
||||
@ -28,7 +28,7 @@ public class CharStream {
|
||||
public void MoveNextBy(int offset) {pos += offset;}
|
||||
public void MoveBack() {pos--;}
|
||||
public void MoveBackBy(int offset) {pos -= offset;}
|
||||
public void MoveTo(int val) {pos = val;}
|
||||
public void Move_to(int val) {pos = val;}
|
||||
public boolean Match(String match) {
|
||||
int matchLen = String_.Len(match);
|
||||
for (int i = 0; i < matchLen; i++) {
|
||||
|
||||
@ -42,13 +42,13 @@ public class CharStream_tst {
|
||||
tst_Match(false, "ghi");
|
||||
}
|
||||
@Test public void AtBounds() {
|
||||
stream.MoveTo(-1);
|
||||
stream.Move_to(-1);
|
||||
tst_AtBounds(true, false, false);
|
||||
|
||||
stream.MoveTo(0);
|
||||
stream.Move_to(0);
|
||||
tst_AtBounds(false, true, false);
|
||||
|
||||
stream.MoveTo(stream.Len());
|
||||
stream.Move_to(stream.Len());
|
||||
tst_AtBounds(false, false, true);
|
||||
}
|
||||
void tst_Match(boolean expd, String text) {Tfds.Eq(expd, stream.Match(text));}
|
||||
|
||||
@ -46,15 +46,15 @@ public class HexDecUtl_tst {
|
||||
tst_Write("[00000000]", 1, 9, 255, "[000000FF]");
|
||||
}
|
||||
private void tst_Write(String s, int bgn, int end, int val, String expd) {
|
||||
byte[] bry = Bry_.new_ascii_(s);
|
||||
byte[] bry = Bry_.new_a7(s);
|
||||
HexDecUtl.Write(bry, bgn, end, val);
|
||||
Tfds.Eq(expd, String_.new_ascii_(bry));
|
||||
Tfds.Eq(expd, String_.new_a7(bry));
|
||||
}
|
||||
private void tst_XtoInt(String raw, int expd) {
|
||||
int actl = HexDecUtl.parse_(raw);
|
||||
Tfds.Eq(expd, actl);
|
||||
}
|
||||
private void tst_XtoInt_bry(String raw, int expd) {Tfds.Eq(expd, HexDecUtl.parse_or_(Bry_.new_ascii_(raw), -1));}
|
||||
private void tst_XtoInt_bry(String raw, int expd) {Tfds.Eq(expd, HexDecUtl.parse_or_(Bry_.new_a7(raw), -1));}
|
||||
private void tst_XtoStr(int val, String expd) {tst_XtoStr(val, 0, expd);}
|
||||
private void tst_XtoStr(int val, int pad, String expd) {
|
||||
String actl = HexDecUtl.XtoStr(val, pad);
|
||||
|
||||
@ -45,7 +45,7 @@ public class RegxAdp {
|
||||
public boolean Pattern_is_invalid() {return pattern_is_invalid;} private boolean pattern_is_invalid = false;
|
||||
public RegxMatch[] Match_all(String text, int bgn) {
|
||||
int idx = bgn;
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
List_adp rv = List_adp_.new_();
|
||||
int len = String_.Len(text);
|
||||
while (idx <= len) { // NOTE: must be <= not < else "a?" will return null instead of ""; PAGE:en.d:民; DATE:2015-01-30
|
||||
RegxMatch match = this.Match(text, idx);
|
||||
@ -58,7 +58,7 @@ public class RegxAdp {
|
||||
: find_bgn + find_len // otherwise search after find_end
|
||||
;
|
||||
}
|
||||
return (RegxMatch[])rv.Xto_ary(RegxMatch.class);
|
||||
return (RegxMatch[])rv.To_ary(RegxMatch.class);
|
||||
}
|
||||
@gplx.Internal protected RegxAdp(String regx) {Pattern_(regx);}
|
||||
}
|
||||
|
||||
@ -63,17 +63,17 @@ public class RegxAdp__tst implements TfdsEqListItmStr {
|
||||
RegxMatch match_(int bgn) {return match_(bgn, Int_.MinValue);}
|
||||
RegxMatch match_(int bgn, int len) {return new RegxMatch(true, bgn, bgn + len, RegxGroup.Ary_empty);}
|
||||
void tst_Matches(String find, String input, RegxMatch... expd) {
|
||||
ListAdp expdList = Array_.XtoList(expd);
|
||||
ListAdp actlList = RegxAdp_.Find_args(input, find).Exec_asList();
|
||||
List_adp expdList = Array_.XtoList(expd);
|
||||
List_adp actlList = RegxAdp_.Find_args(input, find).Exec_asList();
|
||||
Tfds.Eq_list(expdList, actlList, this);
|
||||
}
|
||||
void tst_Groups(String text, String regx, String... expd) {
|
||||
RegxAdp regx_mgr = RegxAdp_.new_(regx);
|
||||
RegxMatch[] rslts = regx_mgr.Match_all(text, 0);
|
||||
Tfds.Eq_ary_str(expd, Xto_ary(rslts));
|
||||
Tfds.Eq_ary_str(expd, To_ary(rslts));
|
||||
}
|
||||
String[] Xto_ary(RegxMatch[] ary) {
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
String[] To_ary(RegxMatch[] ary) {
|
||||
List_adp rv = List_adp_.new_();
|
||||
int len = ary.length;
|
||||
for (int i = 0; i < len; i++) {
|
||||
RegxMatch itm = ary[i];
|
||||
@ -82,7 +82,7 @@ public class RegxAdp__tst implements TfdsEqListItmStr {
|
||||
rv.Add(itm.Groups()[j].Val());
|
||||
}
|
||||
}
|
||||
return rv.XtoStrAry();
|
||||
return rv.To_str_ary();
|
||||
}
|
||||
public String XtoStr(Object curObj, Object expdObj) {
|
||||
RegxMatch cur = (RegxMatch)curObj, expd = (RegxMatch)expdObj;
|
||||
|
||||
@ -19,10 +19,10 @@ package gplx.texts; import gplx.*;
|
||||
public class RegxAdp_mpo_find {
|
||||
public String Input() {return input;} public RegxAdp_mpo_find Input_(String val) {input = val; return this;} private String input;
|
||||
public String Find() {return find;} public RegxAdp_mpo_find Find_(String val) {find = val; return this;} private String find;
|
||||
public ListAdp Exec_asList() {
|
||||
public List_adp Exec_asList() {
|
||||
RegxAdp regx = RegxAdp_.new_(find);
|
||||
int idx = 0;
|
||||
ListAdp rv = ListAdp_.new_();
|
||||
List_adp rv = List_adp_.new_();
|
||||
while (true) {
|
||||
RegxMatch match = regx.Match(input, idx);
|
||||
if (match.Rslt_none()) break;
|
||||
|
||||
@ -30,7 +30,7 @@ public class StringTableBldr {
|
||||
return this;
|
||||
}
|
||||
public StringTableCol FetchAtOrNew(int i) {
|
||||
if (i < cols.Count()) return StringTableCol.as_(cols.FetchAt(i));
|
||||
if (i < cols.Count()) return StringTableCol.as_(cols.Get_at(i));
|
||||
StringTableCol col = StringTableCol.new_();
|
||||
col.Halign_(defaultHalign);
|
||||
cols.Add(i, col);
|
||||
@ -39,10 +39,10 @@ public class StringTableBldr {
|
||||
public String XtoStr() {
|
||||
sb.Clear();
|
||||
for (int rowI = 0; rowI < rows.Count(); rowI++) {
|
||||
String[] row = (String[])rows.FetchAt(rowI);
|
||||
String[] row = (String[])rows.Get_at(rowI);
|
||||
for (int colI = 0; colI < row.length; colI++) {
|
||||
if (colI != 0) sb.Add(" ");
|
||||
StringTableCol col = StringTableCol.as_(cols.FetchAt(colI)); if (col == null) throw Err_.missing_idx_(colI, cols.Count());
|
||||
StringTableCol col = StringTableCol.as_(cols.Get_at(colI)); if (col == null) throw Err_.missing_idx_(colI, cols.Count());
|
||||
sb.Add(col.PadCell(row[colI]));
|
||||
}
|
||||
sb.Add(String_.CrLf);
|
||||
@ -51,7 +51,7 @@ public class StringTableBldr {
|
||||
}
|
||||
|
||||
public static StringTableBldr new_() {return new StringTableBldr();} StringTableBldr() {}
|
||||
OrderedHash cols = OrderedHash_.new_();
|
||||
ListAdp rows = ListAdp_.new_();
|
||||
Ordered_hash cols = Ordered_hash_.new_();
|
||||
List_adp rows = List_adp_.new_();
|
||||
String_bldr sb = String_bldr_.new_();
|
||||
}
|
||||
|
||||
@ -40,18 +40,18 @@ public class HashAlgo_ {
|
||||
}
|
||||
class HashAlgo_null implements HashAlgo {
|
||||
public String Key() {return "HashAlgo_null";}
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_ascii_(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_a7(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public String CalcHash(ConsoleDlg dialog, IoStream stream) {return "NullAlgoHash";}
|
||||
}
|
||||
class HashAlgo_md5 implements HashAlgo {
|
||||
public String Key() {return KEY;} public static final String KEY = "md5";
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_ascii_(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_a7(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public String CalcHash(ConsoleDlg dialog, IoStream stream) {return HashAlgoUtl.CalcHashAsString(dialog, stream, "MD5");}
|
||||
public static HashAlgo_md5 new_() {return new HashAlgo_md5();} HashAlgo_md5() {}
|
||||
}
|
||||
class HashAlgo_sha1 implements HashAlgo {
|
||||
public String Key() {return KEY;} public static final String KEY = "sha1";
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_ascii_(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_a7(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public String CalcHash(ConsoleDlg dialog, IoStream stream) {return HashAlgoUtl.CalcHashAsString(dialog, stream, "SHA1");}
|
||||
public static HashAlgo_sha1 new_() {return new HashAlgo_sha1();} HashAlgo_sha1() {}
|
||||
}
|
||||
|
||||
@ -36,7 +36,7 @@ public class HashAlgo_md5_tst {
|
||||
tst_CalcBase16FromString(String_.Repeat("a", 1000000), "7707d6ae4e027c70eea2a935c2296f21");
|
||||
}
|
||||
void tst_CalcBase16FromString(String raw, String expd) {
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Null, raw);
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Empty, raw);
|
||||
String actl = HashAlgo_.Md5.CalcHash(ConsoleDlg_.Null, stream);
|
||||
Tfds.Eq(expd, actl);
|
||||
}
|
||||
|
||||
@ -36,7 +36,7 @@ public class HashAlgo_sha1_tst {
|
||||
tst_CalcBase16FromString(String_.Repeat("a", 1000000), "34aa973cd4c4daa4f61eeb2bdbad27316534016f");
|
||||
}
|
||||
void tst_CalcBase16FromString(String raw, String expd) {
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Null, raw);
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Empty, raw);
|
||||
String actl = HashAlgo_.Sha1.CalcHash(ConsoleDlg_.Null, stream);
|
||||
Tfds.Eq(expd, actl);
|
||||
}
|
||||
|
||||
@ -20,7 +20,7 @@ import gplx.ios.*; /*IoStream*/
|
||||
public class HashAlgo_tth192 implements HashAlgo {
|
||||
public String Key() {return KEY;} public static final String KEY = "tth192";
|
||||
public int BlockSize() {return blockSize;} public void BlockSize_set(int v) {blockSize = v;} int blockSize = 1024;
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_ascii_(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public byte[] Calc_hash_bry(byte[] v) {return Bry_.new_a7(CalcHash(ConsoleDlg_.Null, gplx.ios.IoStream_.ary_(v)));}
|
||||
public String CalcHash(ConsoleDlg dialog, IoStream stream) {
|
||||
int leafCount = (int)(stream.Len() / blockSize);
|
||||
HashDlgWtr dialogWtr = HashDlgWtr_.Current;
|
||||
|
||||
@ -32,7 +32,7 @@ public class HashAlgo_tth192_tst {
|
||||
tst_CalcBase32FromString(String_.Repeat("A", (int)Math_.Pow(2, 27)), "QNIJO36QDIQREUT3HWK4MDVKD2T6OENAEKYADTQ");
|
||||
}
|
||||
void tst_CalcBase32FromString(String raw, String expd) {
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Null, raw);
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Empty, raw);
|
||||
String actl = HashAlgo_.Tth192.CalcHash(ConsoleDlg_.Null, stream);
|
||||
Tfds.Eq(expd, actl);
|
||||
}
|
||||
|
||||
@ -31,9 +31,9 @@ public class HashDlgWtr_tst {
|
||||
void tst_Status(int count, String[] expdWritten) {
|
||||
ConsoleDlg_dev dialog = ConsoleDlg_.Dev();
|
||||
String data = String_.Repeat("A", count);
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Null, data);
|
||||
IoStream stream = IoStream_.mem_txt_(Io_url_.Empty, data);
|
||||
calc.CalcHash(dialog, stream);
|
||||
String[] actlWritten = dialog.Written().XtoStrAry();
|
||||
String[] actlWritten = dialog.Written().To_str_ary();
|
||||
Tfds.Eq_ary(actlWritten, expdWritten);
|
||||
}
|
||||
String[] stringAry_(String... ary) {return ary;}
|
||||
|
||||
@ -19,7 +19,7 @@ package gplx;
|
||||
import gplx.core.primitives.*; import gplx.ios.*; /*IoItmFil, IoItmDir..*/
|
||||
public class Io_mgr { // exists primarily to gather all cmds under gplx namespace; otherwise need to use gplx.ios whenever copying/deleting file
|
||||
public boolean Exists(Io_url url) {return url.Type_dir() ? ExistsDir(url) : ExistsFil(url);}
|
||||
public boolean ExistsFil(Io_url url) {return IoEnginePool._.Fetch(url.Info().EngineKey()).ExistsFil_api(url);}
|
||||
public boolean ExistsFil(Io_url url) {return IoEnginePool._.Get_by(url.Info().EngineKey()).ExistsFil_api(url);}
|
||||
public void ExistsFilOrFail(Io_url url) {if (!ExistsFil(url)) throw Err_.new_("could not find file").Add("url", url);}
|
||||
public void SaveFilStr(String url, String text) {SaveFilStr_args(Io_url_.new_fil_(url), text).Exec();}
|
||||
public void SaveFilStr(Io_url url, String text) {SaveFilStr_args(url, text).Exec();}
|
||||
@ -36,12 +36,12 @@ public class Io_mgr { // exists primarily to gather all cmds under gplx namespac
|
||||
|
||||
public IoStream OpenStreamWrite(Io_url url) {return OpenStreamWrite_args(url).Exec();}
|
||||
public IoEngine_xrg_openWrite OpenStreamWrite_args(Io_url url) {return IoEngine_xrg_openWrite.new_(url);}
|
||||
public IoItmFil QueryFil(Io_url url) {return IoEnginePool._.Fetch(url.Info().EngineKey()).QueryFil(url);}
|
||||
public void UpdateFilAttrib(Io_url url, IoItmAttrib attrib) {IoEnginePool._.Fetch(url.Info().EngineKey()).UpdateFilAttrib(url, attrib);}
|
||||
public void UpdateFilModifiedTime(Io_url url, DateAdp modified) {IoEnginePool._.Fetch(url.Info().EngineKey()).UpdateFilModifiedTime(url, modified);}
|
||||
public IoItmFil QueryFil(Io_url url) {return IoEnginePool._.Get_by(url.Info().EngineKey()).QueryFil(url);}
|
||||
public void UpdateFilAttrib(Io_url url, IoItmAttrib attrib) {IoEnginePool._.Get_by(url.Info().EngineKey()).UpdateFilAttrib(url, attrib);}
|
||||
public void UpdateFilModifiedTime(Io_url url, DateAdp modified) {IoEnginePool._.Get_by(url.Info().EngineKey()).UpdateFilModifiedTime(url, modified);}
|
||||
|
||||
public boolean ExistsDir(Io_url url) {return IoEnginePool._.Fetch(url.Info().EngineKey()).ExistsDir(url);}
|
||||
public void CreateDir(Io_url url) {IoEnginePool._.Fetch(url.Info().EngineKey()).CreateDir(url);}
|
||||
public boolean ExistsDir(Io_url url) {return IoEnginePool._.Get_by(url.Info().EngineKey()).ExistsDir(url);}
|
||||
public void CreateDir(Io_url url) {IoEnginePool._.Get_by(url.Info().EngineKey()).CreateDir(url);}
|
||||
public boolean CreateDirIfAbsent(Io_url url) {
|
||||
boolean exists = ExistsDir(url);
|
||||
if (!exists) {
|
||||
@ -60,6 +60,7 @@ public class Io_mgr { // exists primarily to gather all cmds under gplx namespac
|
||||
public IoEngine_xrg_deleteDir DeleteDir_cmd(Io_url url) {return IoEngine_xrg_deleteDir.new_(url);}
|
||||
public void DeleteDirDeep(Io_url url) {IoEngine_xrg_deleteDir.new_(url).Recur_().Exec();}
|
||||
public void DeleteDirDeep_ary(Io_url... urls) {for (Io_url url : urls) IoEngine_xrg_deleteDir.new_(url).Recur_().Exec();}
|
||||
public int Delete_dir_empty(Io_url url) {return Io_mgr_.Delete_dir_empty(url);}
|
||||
public void MoveDirDeep(Io_url src, Io_url trg) {IoEngine_xrg_xferDir.move_(src, trg).Recur_().Exec();}
|
||||
public IoEngine_xrg_xferDir CopyDir_cmd(Io_url src, Io_url trg) {return IoEngine_xrg_xferDir.copy_(src, trg);}
|
||||
public void CopyDirSubs(Io_url src, Io_url trg) {IoEngine_xrg_xferDir.copy_(src, trg).Exec();}
|
||||
@ -98,7 +99,7 @@ public class Io_mgr { // exists primarily to gather all cmds under gplx namespac
|
||||
catch (Exception e) {throw Err_.new_("failed to load file").Add("url", url.Xto_api()).Add("e", Err_.Message_lang(e));}
|
||||
finally {stream.Rls();}
|
||||
}
|
||||
public byte[] LoadFilBry_loose(Io_url url) {return Bry_.new_utf8_(LoadFilStr_loose(url));}
|
||||
public byte[] LoadFilBry_loose(Io_url url) {return Bry_.new_u8(LoadFilStr_loose(url));}
|
||||
public String LoadFilStr_loose(Io_url url) {
|
||||
String rv = LoadFilStr_args(url).BomUtf8Convert_(Bool_.Y).MissingIgnored_(Bool_.Y).Exec();
|
||||
if (String_.Has(rv, "\r\n"))
|
||||
@ -129,14 +130,33 @@ public class Io_mgr { // exists primarily to gather all cmds under gplx namespac
|
||||
public IoEngine InitEngine_mem() {return IoEngine_.Mem_init_();}
|
||||
public IoEngine InitEngine_mem_(String key) {
|
||||
IoEngine engine = IoEngine_.mem_new_(key);
|
||||
IoEnginePool._.AddReplace(engine);
|
||||
IoEnginePool._.Add_if_dupe_use_nth(engine);
|
||||
IoUrlInfoRegy._.Reg(IoUrlInfo_.mem_(key, key));
|
||||
return engine;
|
||||
}
|
||||
public boolean DownloadFil(String src, Io_url trg) {return IoEngine_xrg_downloadFil.new_(src, trg).Exec();}
|
||||
public IoEngine_xrg_downloadFil DownloadFil_args(String src, Io_url trg) {return IoEngine_xrg_downloadFil.new_(src, trg);}
|
||||
public static final Io_mgr _ = new Io_mgr(); public Io_mgr() {}
|
||||
public static final Io_mgr I = new Io_mgr(); public Io_mgr() {}
|
||||
public static final int Len_kb = 1024, Len_mb = 1048576, Len_gb = 1073741824, Len_gb_2 = 2147483647;
|
||||
public static final long Len_mb_long = Len_mb;
|
||||
public static final long Len_null = -1;
|
||||
}
|
||||
class Io_mgr_ {
|
||||
public static int Delete_dir_empty(Io_url url) {
|
||||
IoItmDir dir = Io_mgr.I.QueryDir_args(url).ExecAsDir();
|
||||
int sub_dirs_len = dir.SubDirs().Count();
|
||||
int deleted_dirs = 0;
|
||||
for (int i = 0; i < sub_dirs_len; ++i) {
|
||||
IoItmDir sub_dir = (IoItmDir)dir.SubDirs().Get_at(i);
|
||||
deleted_dirs += Io_mgr.I.Delete_dir_empty(sub_dir.Url());
|
||||
}
|
||||
if ( dir.SubFils().Count() == 0
|
||||
&& deleted_dirs == sub_dirs_len
|
||||
) {
|
||||
Io_mgr.I.DeleteDirIfEmpty(url);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
100
100_core/src_200_io/gplx/Io_mgr__tst.java
Normal file
100
100_core/src_200_io/gplx/Io_mgr__tst.java
Normal file
@ -0,0 +1,100 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012 gnosygnu@gmail.com
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx;
|
||||
import org.junit.*;
|
||||
public class Io_mgr__tst {
|
||||
@Before public void init() {fxt.Clear();} private final Io_mgr__fxt fxt = new Io_mgr__fxt();
|
||||
@Test public void Dir_delete_empty__basic() {
|
||||
fxt.Exec_itm_create("mem/dir/");
|
||||
fxt.Exec_dir_delete_empty("mem/dir/");
|
||||
fxt.Test_itm_exists_n("mem/dir/");
|
||||
}
|
||||
@Test public void Dir_delete_empty__no_delete() {
|
||||
fxt.Exec_itm_create
|
||||
( "mem/dir/"
|
||||
, "mem/dir/fil.txt"
|
||||
);
|
||||
fxt.Exec_dir_delete_empty("mem/dir/");
|
||||
fxt.Test_itm_exists_y("mem/dir/");
|
||||
}
|
||||
@Test public void Dir_delete_empty__nested_simple() {
|
||||
fxt.Exec_itm_create
|
||||
( "mem/dir/"
|
||||
, "mem/dir/1/"
|
||||
, "mem/dir/1/11/"
|
||||
);
|
||||
fxt.Exec_dir_delete_empty("mem/dir/");
|
||||
fxt.Test_itm_exists_n("mem/dir/");
|
||||
}
|
||||
@Test public void Dir_delete_empty__nested_many() {
|
||||
fxt.Exec_itm_create
|
||||
( "mem/dir/"
|
||||
, "mem/dir/1/"
|
||||
, "mem/dir/1/11/"
|
||||
, "mem/dir/2/22/"
|
||||
, "mem/dir/2/22/222a/"
|
||||
, "mem/dir/2/22/222b/"
|
||||
);
|
||||
fxt.Exec_dir_delete_empty("mem/dir/");
|
||||
fxt.Test_itm_exists_n("mem/dir/");
|
||||
}
|
||||
@Test public void Dir_delete_empty__nested_some() {
|
||||
fxt.Exec_itm_create
|
||||
( "mem/dir/"
|
||||
, "mem/dir/1/"
|
||||
, "mem/dir/1/11/"
|
||||
, "mem/dir/2/22/"
|
||||
, "mem/dir/2/22/a.txt"
|
||||
, "mem/dir/2/22/222a/"
|
||||
, "mem/dir/2/22/222b/"
|
||||
);
|
||||
fxt.Exec_dir_delete_empty("mem/dir/");
|
||||
fxt.Test_itm_exists_n
|
||||
( "mem/dir/1/"
|
||||
, "mem/dir/1/11/"
|
||||
, "mem/dir/2/22/222a/"
|
||||
, "mem/dir/2/22/222b/"
|
||||
);
|
||||
fxt.Test_itm_exists_y
|
||||
( "mem/dir/"
|
||||
, "mem/dir/2/22/"
|
||||
);
|
||||
}
|
||||
}
|
||||
class Io_mgr__fxt {
|
||||
public void Clear() {Io_mgr.I.InitEngine_mem();}
|
||||
public void Exec_itm_create(String... ary) {
|
||||
for (String itm : ary) {
|
||||
Io_url url = Io_url_.new_any_(itm);
|
||||
if (url.Type_dir())
|
||||
Io_mgr.I.CreateDir(url);
|
||||
else
|
||||
Io_mgr.I.SaveFilStr(url, url.NameAndExt());
|
||||
}
|
||||
}
|
||||
public void Exec_dir_delete_empty(String url) {Io_mgr.I.Delete_dir_empty(Io_url_.mem_dir_(url));}
|
||||
public void Test_itm_exists_n(String... ary) {Test_itm_exists(Bool_.N, ary);}
|
||||
public void Test_itm_exists_y(String... ary) {Test_itm_exists(Bool_.Y, ary);}
|
||||
public void Test_itm_exists(boolean expd, String... ary) {
|
||||
for (String itm : ary) {
|
||||
Io_url url = Io_url_.new_any_(itm);
|
||||
boolean actl = url.Type_dir() ? Io_mgr.I.ExistsDir(url) : Io_mgr.I.ExistsFil(url);
|
||||
Tfds.Eq(expd, actl, itm);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -141,7 +141,7 @@ class IoEngineUtl {
|
||||
IoStream srcStream = null;
|
||||
IoStream trgStream = null;
|
||||
try {
|
||||
srcStream = IoEnginePool._.Fetch(src.Info().EngineKey()).OpenStreamRead(src);
|
||||
srcStream = IoEnginePool._.Get_by(src.Info().EngineKey()).OpenStreamRead(src);
|
||||
trgStream = IoEngine_xrg_openWrite.new_(trg).Exec();
|
||||
srcStream.Transfer(trgStream, bufferLength);
|
||||
}
|
||||
|
||||
@ -17,18 +17,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package gplx.ios; import gplx.*;
|
||||
public class IoEnginePool {
|
||||
public void AddReplace(IoEngine engine) {
|
||||
public void Add_if_dupe_use_nth(IoEngine engine) {
|
||||
hash.Del(engine.Key());
|
||||
hash.Add(engine.Key(), engine);
|
||||
}
|
||||
public IoEngine Fetch(String key) {
|
||||
IoEngine rv = (IoEngine)hash.Fetch(key);
|
||||
public IoEngine Get_by(String key) {
|
||||
IoEngine rv = (IoEngine)hash.Get_by(key);
|
||||
return rv == null ? IoEngine_.Mem : rv; // rv == null when url is null or empty; return Mem which should be a noop; DATE:2013-06-04
|
||||
}
|
||||
HashAdp hash = HashAdp_.new_();
|
||||
Hash_adp hash = Hash_adp_.new_();
|
||||
public static final IoEnginePool _ = new IoEnginePool();
|
||||
IoEnginePool() {
|
||||
this.AddReplace(IoEngine_.Sys);
|
||||
this.AddReplace(IoEngine_.Mem);
|
||||
this.Add_if_dupe_use_nth(IoEngine_.Sys);
|
||||
this.Add_if_dupe_use_nth(IoEngine_.Mem);
|
||||
}
|
||||
}
|
||||
@ -22,7 +22,7 @@ public class IoEngine_memory extends IoEngine_base {
|
||||
@Override public void DeleteFil_api(IoEngine_xrg_deleteFil args) {
|
||||
Io_url url = args.Url();
|
||||
IoItmDir dir = FetchDir(url.OwnerDir()); if (dir == null) return; // url doesn't exist; just exit
|
||||
IoItmFil fil = IoItmFil_.as_(dir.SubFils().Fetch(url.NameAndExt()));
|
||||
IoItmFil fil = IoItmFil_.as_(dir.SubFils().Get_by(url.NameAndExt()));
|
||||
if (fil != null && fil.ReadOnly() && args.ReadOnlyFails()) throw IoErr.FileIsReadOnly(url);
|
||||
dir.SubFils().Del(url);
|
||||
}
|
||||
@ -53,7 +53,7 @@ public class IoEngine_memory extends IoEngine_base {
|
||||
Io_url url = args.Url();
|
||||
IoItmDir dir = FetchDir(url.OwnerDir());
|
||||
if (dir != null) {
|
||||
IoItmFil fil = IoItmFil_.as_(dir.SubFils().Fetch(url.NameAndExt()));
|
||||
IoItmFil fil = IoItmFil_.as_(dir.SubFils().Get_by(url.NameAndExt()));
|
||||
if (fil != null && fil.ReadOnly()) throw IoErr.FileIsReadOnly(url);
|
||||
}
|
||||
|
||||
@ -105,7 +105,7 @@ public class IoEngine_memory extends IoEngine_base {
|
||||
dir = IoItmDir_.top_(url);
|
||||
dirs.Add(dir);
|
||||
IoItmDir ownerDir = FetchDir(url.OwnerDir());
|
||||
if (ownerDir == null && !url.OwnerDir().Eq(Io_url_.Null)) { // no owner dir && not "driveDir" -> create
|
||||
if (ownerDir == null && !url.OwnerDir().Eq(Io_url_.Empty)) { // no owner dir && not "driveDir" -> create
|
||||
CreateDir(url.OwnerDir()); // recursive
|
||||
ownerDir = FetchDir(url.OwnerDir());
|
||||
}
|
||||
@ -118,8 +118,8 @@ public class IoEngine_memory extends IoEngine_base {
|
||||
IoItmDir ownerDir = FetchDir(url.OwnerDir()); if (ownerDir == null) return; // no ownerDir; no need to unregister
|
||||
ownerDir.SubDirs().Del(url);
|
||||
}
|
||||
@Override public void XferDir(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Fetch(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void MoveDirDeep(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Fetch(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void XferDir(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Get_by(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void MoveDirDeep(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Get_by(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void MoveDir(Io_url src, Io_url trg) {if (ExistsDir(trg)) throw Err_.new_("trg already exists").Add("trg", trg);
|
||||
IoItmDir dir = FetchDir(src); dir.Name_(trg.NameAndExt());
|
||||
for (Object filObj : dir.SubFils()) { // move all subFiles
|
||||
@ -159,11 +159,11 @@ public class IoEngine_memory extends IoEngine_base {
|
||||
dir.SubFils().Del(fil.Url());
|
||||
dir.SubFils().Add(fil);
|
||||
}
|
||||
IoItmDir FetchDir(Io_url url) {return IoItmDir_.as_(dirs.Fetch(url));}
|
||||
IoItmDir FetchDir(Io_url url) {return IoItmDir_.as_(dirs.Get_by(url));}
|
||||
IoItmFil_mem FetchFil(Io_url url) {
|
||||
IoItmDir ownerDir = FetchDir(url.OwnerDir());
|
||||
if (ownerDir == null) return IoItmFil_mem.Null;
|
||||
IoItmFil_mem rv = IoItmFil_mem.as_(ownerDir.SubFils().Fetch(url.NameAndExt()));
|
||||
IoItmFil_mem rv = IoItmFil_mem.as_(ownerDir.SubFils().Get_by(url.NameAndExt()));
|
||||
if (rv == null) rv = IoItmFil_mem.Null;
|
||||
return rv;
|
||||
}
|
||||
@ -187,7 +187,7 @@ public class IoEngine_memory extends IoEngine_base {
|
||||
xrg.Rslt_(IoEngine_xrg_downloadFil.Rslt_fail_file_not_found);
|
||||
return Io_stream_rdr_.Null;
|
||||
}
|
||||
byte[] bry = Bry_.new_utf8_(FetchFil(Io_url_.mem_fil_(xrg.Src())).Text());
|
||||
byte[] bry = Bry_.new_u8(FetchFil(Io_url_.mem_fil_(xrg.Src())).Text());
|
||||
return Io_stream_rdr_.mem_(bry);
|
||||
}
|
||||
IoItmHash dirs = IoItmHash.new_();
|
||||
|
||||
@ -31,11 +31,11 @@ import gplx.core.criterias.*;
|
||||
public class IoEngine_system extends IoEngine_base {
|
||||
@Override public String Key() {return IoEngine_.SysKey;}
|
||||
@Override public void DeleteDirDeep(IoEngine_xrg_deleteDir args) {utl.DeleteDirDeep(this, args.Url(), args);}
|
||||
@Override public void XferDir(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Fetch(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void XferDir(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Get_by(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void XferFil(IoEngine_xrg_xferFil args) {utl.XferFil(this, args);}
|
||||
@Override public IoItmDir QueryDirDeep(IoEngine_xrg_queryDir args) {return utl.QueryDirDeep(this, args);}
|
||||
@Override public void CopyDir(Io_url src, Io_url trg) {IoEngine_xrg_xferDir.copy_(src, trg).Recur_().Exec();}
|
||||
@Override public void MoveDirDeep(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Fetch(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void MoveDirDeep(IoEngine_xrg_xferDir args) {Io_url trg = args.Trg(); utl.XferDir(this, args.Src(), IoEnginePool._.Get_by(trg.Info().EngineKey()), trg, args);}
|
||||
@Override public void DeleteFil_api(IoEngine_xrg_deleteFil args) {
|
||||
Io_url url = args.Url();
|
||||
File fil = Fil_(url);
|
||||
@ -52,7 +52,7 @@ public class IoEngine_system extends IoEngine_base {
|
||||
|
||||
// encode string
|
||||
byte[] textBytes = null;
|
||||
textBytes = Bry_.new_utf8_(mpo.Text());
|
||||
textBytes = Bry_.new_u8(mpo.Text());
|
||||
|
||||
FileChannel fc = null; FileOutputStream fos = null;
|
||||
if (!ExistsDir(url.OwnerDir())) CreateDir(url.OwnerDir());
|
||||
@ -96,7 +96,7 @@ public class IoEngine_system extends IoEngine_base {
|
||||
}
|
||||
return Load_from_stream_as_str(stream, url_str);
|
||||
}
|
||||
public static String Load_from_stream_as_str(InputStream stream, String url_str) {
|
||||
@SuppressWarnings("resource") public static String Load_from_stream_as_str(InputStream stream, String url_str) {
|
||||
InputStreamReader reader = null;
|
||||
try {reader = new InputStreamReader(stream, IoEngineArgs._.LoadFilStr_Encoding);}
|
||||
catch (UnsupportedEncodingException e) {
|
||||
@ -394,11 +394,11 @@ public class IoEngine_system extends IoEngine_base {
|
||||
java.net.URL src_url = null;
|
||||
HttpURLConnection src_conn = null;
|
||||
if (user_agent_needs_resetting) {user_agent_needs_resetting = false; System.setProperty("http.agent", "");}
|
||||
boolean exists = Io_mgr._.ExistsDir(xrg.Trg().OwnerDir());
|
||||
boolean exists = Io_mgr.I.ExistsDir(xrg.Trg().OwnerDir());
|
||||
Gfo_usr_dlg prog_dlg = null;
|
||||
String src_str = xrg.Src();
|
||||
Io_download_fmt xfer_fmt = xrg.Download_fmt();
|
||||
prog_dlg = xfer_fmt.usr_dlg;
|
||||
prog_dlg = xfer_fmt.Usr_dlg();
|
||||
if (!Web_access_enabled) {
|
||||
if (prog_dlg != null) {
|
||||
if (session_fil == null) session_fil = prog_dlg.Log_wkr().Session_dir().GenSubFil("internet.txt");
|
||||
@ -407,7 +407,7 @@ public class IoEngine_system extends IoEngine_base {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
trg_stream = Io_mgr._.OpenStreamWrite(xrg.Trg());
|
||||
trg_stream = Io_mgr.I.OpenStreamWrite(xrg.Trg());
|
||||
src_url = new java.net.URL(src_str);
|
||||
src_conn = (HttpURLConnection)src_url.openConnection();
|
||||
// src_conn.setReadTimeout(5000); // do not set; if file does not exist, will wait 5 seconds before timing out; want to fail immediately
|
||||
@ -419,7 +419,7 @@ public class IoEngine_system extends IoEngine_base {
|
||||
if (xrg.Exec_meta_only()) return true;
|
||||
src_stream = new java.io.BufferedInputStream(src_conn.getInputStream());
|
||||
if (!exists) {
|
||||
Io_mgr._.CreateDir(xrg.Trg().OwnerDir()); // dir must exist for OpenStreamWrite; create dir at last possible moment in case stream does not exist.
|
||||
Io_mgr.I.CreateDir(xrg.Trg().OwnerDir()); // dir must exist for OpenStreamWrite; create dir at last possible moment in case stream does not exist.
|
||||
}
|
||||
byte[] download_bfr = new byte[Download_bfr_len]; // NOTE: download_bfr was originally member variable; DATE:2013-05-03
|
||||
xfer_fmt.Bgn(content_length);
|
||||
@ -428,7 +428,7 @@ public class IoEngine_system extends IoEngine_base {
|
||||
if (xrg.Prog_cancel()) {
|
||||
src_stream.close();
|
||||
trg_stream.Rls();
|
||||
Io_mgr._.DeleteFil(xrg.Trg());
|
||||
Io_mgr.I.DeleteFil(xrg.Trg());
|
||||
}
|
||||
xfer_fmt.Prog(count);
|
||||
trg_stream.Write(download_bfr, 0, count);
|
||||
@ -518,10 +518,10 @@ class Io_download_http {
|
||||
Io_stream_rdr_http rdr = new Io_stream_rdr_http(xrg);
|
||||
IoStream trg_stream = null;
|
||||
try {
|
||||
boolean exists = Io_mgr._.ExistsDir(xrg.Trg().OwnerDir());
|
||||
boolean exists = Io_mgr.I.ExistsDir(xrg.Trg().OwnerDir());
|
||||
if (!exists)
|
||||
Io_mgr._.CreateDir(xrg.Trg().OwnerDir()); // dir must exist for OpenStreamWrite; create dir at last possible moment in case stream does not exist.
|
||||
trg_stream = Io_mgr._.OpenStreamWrite(xrg.Trg());
|
||||
Io_mgr.I.CreateDir(xrg.Trg().OwnerDir()); // dir must exist for OpenStreamWrite; create dir at last possible moment in case stream does not exist.
|
||||
trg_stream = Io_mgr.I.OpenStreamWrite(xrg.Trg());
|
||||
byte[] bfr = new byte[Download_bfr_len];
|
||||
rdr.Open();
|
||||
while (rdr.Read(bfr, 0, Download_bfr_len) != Read_done) {
|
||||
@ -532,7 +532,7 @@ class Io_download_http {
|
||||
if (trg_stream != null) trg_stream.Rls();
|
||||
}
|
||||
if (xrg.Rslt() != IoEngine_xrg_downloadFil.Rslt_pass)
|
||||
Io_mgr._.DeleteFil_args(xrg.Trg()).MissingFails_off().Exec();
|
||||
Io_mgr.I.DeleteFil_args(xrg.Trg()).MissingFails_off().Exec();
|
||||
}
|
||||
public static final int Read_done = -1;
|
||||
public static final int Download_bfr_len = Io_mgr.Len_kb * 128;
|
||||
@ -542,6 +542,7 @@ class Io_stream_rdr_http implements Io_stream_rdr {
|
||||
this.xrg = xrg;
|
||||
} private IoEngine_xrg_downloadFil xrg;
|
||||
public byte Tid() {return Io_stream_.Tid_raw;}
|
||||
public boolean Exists() {return exists;} private boolean exists = false;
|
||||
public Io_url Url() {return url;} public Io_stream_rdr Url_(Io_url v) {url = v; return this;} private Io_url url;
|
||||
public long Len() {return len;} public Io_stream_rdr Len_(long v) {len = v; return this;} private long len = IoItmFil.Size_invalid; // NOTE: must default size to -1; DATE:2014-06-21
|
||||
private String src_str; private HttpURLConnection src_conn; private java.io.BufferedInputStream src_stream;
|
||||
@ -556,12 +557,11 @@ class Io_stream_rdr_http implements Io_stream_rdr {
|
||||
return this;
|
||||
}
|
||||
src_str = xrg.Src();
|
||||
xfer_fmt = xrg.Download_fmt(); prog_dlg = xfer_fmt.usr_dlg;
|
||||
xfer_fmt = xrg.Download_fmt(); prog_dlg = xfer_fmt.Usr_dlg();
|
||||
try {
|
||||
src_conn = (HttpURLConnection)new java.net.URL(src_str).openConnection();
|
||||
String user_agent = xrg.User_agent();
|
||||
if (user_agent != null)
|
||||
src_conn.setRequestProperty("User-Agent", user_agent);
|
||||
if (user_agent != null) src_conn.setRequestProperty("User-Agent", user_agent); // NOTE: must be set right after openConnection
|
||||
// src_conn.setReadTimeout(5000); // do not set; if file does not exist, will wait 5 seconds before timing out; want to fail immediately
|
||||
long content_length = Long_.parse_or_(src_conn.getHeaderField("Content-Length"), IoItmFil.Size_invalid_int);
|
||||
xrg.Src_content_length_(content_length);
|
||||
@ -573,6 +573,7 @@ class Io_stream_rdr_http implements Io_stream_rdr {
|
||||
return this;
|
||||
}
|
||||
read_done = false;
|
||||
this.exists = src_conn.getResponseCode() == 200; // ASSUME: response code of 200 means that file exists; note that content_length seems to always be -1; DATE:2015-05-20
|
||||
src_stream = new java.io.BufferedInputStream(src_conn.getInputStream());
|
||||
xfer_fmt.Bgn(content_length);
|
||||
}
|
||||
|
||||
@ -25,7 +25,7 @@ public class IoEngine_xrg_deleteDir {
|
||||
public Criteria MatchCrt() {return matchCrt;} public IoEngine_xrg_deleteDir MatchCrt_(Criteria v) {matchCrt = v; return this;} Criteria matchCrt = Criteria_.All;
|
||||
public Criteria SubDirScanCrt() {return subDirScanCrt;} public IoEngine_xrg_deleteDir SubDirScanCrt_(Criteria v) {subDirScanCrt = v; return this;} Criteria subDirScanCrt = Criteria_.All;
|
||||
public ConsoleDlg UsrDlg() {return usrDlg;} public IoEngine_xrg_deleteDir UsrDlg_(ConsoleDlg v) {usrDlg = v; return this;} ConsoleDlg usrDlg = ConsoleDlg_.Null;
|
||||
public void Exec() {IoEnginePool._.Fetch(url.Info().EngineKey()).DeleteDirDeep(this);}
|
||||
public void Exec() {IoEnginePool._.Get_by(url.Info().EngineKey()).DeleteDirDeep(this);}
|
||||
public static IoEngine_xrg_deleteDir new_(Io_url url) {
|
||||
IoEngine_xrg_deleteDir rv = new IoEngine_xrg_deleteDir();
|
||||
rv.url = url;
|
||||
|
||||
@ -20,7 +20,7 @@ public class IoEngine_xrg_deleteFil extends IoEngine_xrg_fil_affects1_base {
|
||||
@gplx.New public IoEngine_xrg_deleteFil Url_(Io_url val) {Url_set(val); return this;}
|
||||
public IoEngine_xrg_deleteFil ReadOnlyFails_off() {return ReadOnlyFails_(false);} public IoEngine_xrg_deleteFil ReadOnlyFails_(boolean v) {ReadOnlyFails_set(v); return this;}
|
||||
public IoEngine_xrg_deleteFil MissingFails_off() {return MissingFails_(false);} public IoEngine_xrg_deleteFil MissingFails_(boolean v) {MissingFails_set(v); return this;}
|
||||
@Override public void Exec() {IoEnginePool._.Fetch(this.Url().Info().EngineKey()).DeleteFil_api(this);}
|
||||
@Override public void Exec() {IoEnginePool._.Get_by(this.Url().Info().EngineKey()).DeleteFil_api(this);}
|
||||
public static IoEngine_xrg_deleteFil proto_() {return new IoEngine_xrg_deleteFil();}
|
||||
public static IoEngine_xrg_deleteFil new_(Io_url url) {
|
||||
IoEngine_xrg_deleteFil rv = new IoEngine_xrg_deleteFil();
|
||||
|
||||
@ -18,37 +18,37 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
package gplx.ios; import gplx.*;
|
||||
public class IoEngine_xrg_downloadFil {
|
||||
public String Src() {return src;} public IoEngine_xrg_downloadFil Src_(String v) {src = v; return this;} private String src;
|
||||
public Io_url Trg() {return trg;} public IoEngine_xrg_downloadFil Trg_(Io_url v) {trg = v; return this;} Io_url trg;
|
||||
public Io_url Trg() {return trg;} public IoEngine_xrg_downloadFil Trg_(Io_url v) {trg = v; return this;} private Io_url trg;
|
||||
public byte Rslt() {return rslt;} public IoEngine_xrg_downloadFil Rslt_(byte v) {rslt = v; return this;} private byte rslt = Rslt_pass;
|
||||
public Exception Rslt_err() {return rslt_err;} public IoEngine_xrg_downloadFil Rslt_err_(Exception v) {rslt_err = v; return this;} Exception rslt_err;
|
||||
public Exception Rslt_err() {return rslt_err;} public IoEngine_xrg_downloadFil Rslt_err_(Exception v) {rslt_err = v; return this;} private Exception rslt_err;
|
||||
public String Rslt_err_str() {
|
||||
return rslt_err == null ? "none" : Err_.Message_gplx_brief(rslt_err);
|
||||
}
|
||||
public String User_agent() {return user_agent;} public IoEngine_xrg_downloadFil User_agent_(String v) {user_agent = v; return this;} private String user_agent;
|
||||
public Gfo_usr_dlg Prog_dlg() {return prog_dlg;} public IoEngine_xrg_downloadFil Prog_dlg_(Gfo_usr_dlg v) {prog_dlg = v; download_fmt.Ctor(prog_dlg); return this;} Gfo_usr_dlg prog_dlg;
|
||||
public Bry_fmtr Prog_fmtr() {return prog_fmtr;} Bry_fmtr prog_fmtr = Bry_fmtr.new_("~{download_header}: ~{download_read} of ~{download_length} kb;", "download_header", "download_url", "download_read", "download_length");
|
||||
public Gfo_usr_dlg Prog_dlg() {return prog_dlg;} public IoEngine_xrg_downloadFil Prog_dlg_(Gfo_usr_dlg v) {prog_dlg = v; download_fmt.Ctor(prog_dlg); return this;} private Gfo_usr_dlg prog_dlg;
|
||||
public Bry_fmtr Prog_fmtr() {return prog_fmtr;} private final Bry_fmtr prog_fmtr = Bry_fmtr.new_("~{download_header}: ~{download_read} of ~{download_length} kb;", "download_header", "download_url", "download_read", "download_length");
|
||||
public String Prog_fmt_hdr() {return prog_fmt_hdr;} public IoEngine_xrg_downloadFil Prog_fmt_hdr_(String v) {prog_fmt_hdr = v; return this;} private String prog_fmt_hdr = ""; // NOTE: must init to "", else null ref when building String
|
||||
public boolean Prog_cancel() {return prog_cancel;} public IoEngine_xrg_downloadFil Prog_cancel_y_() {prog_cancel = true; return this;} volatile boolean prog_cancel;
|
||||
public boolean Prog_cancel() {return prog_cancel;} public IoEngine_xrg_downloadFil Prog_cancel_y_() {prog_cancel = true; return this;} private volatile boolean prog_cancel;
|
||||
public boolean Prog_running() {return prog_running;} public IoEngine_xrg_downloadFil Prog_running_(boolean v) {prog_running = v; return this;} private boolean prog_running;
|
||||
public long Src_content_length() {return src_content_length;} public IoEngine_xrg_downloadFil Src_content_length_(long v) {src_content_length = v; return this;} long src_content_length;
|
||||
public DateAdp Src_last_modified() {return src_last_modified;} public IoEngine_xrg_downloadFil Src_last_modified_(DateAdp v) {src_last_modified = v; return this;} DateAdp src_last_modified;
|
||||
public long Src_content_length() {return src_content_length;} public IoEngine_xrg_downloadFil Src_content_length_(long v) {src_content_length = v; return this;} private long src_content_length;
|
||||
public DateAdp Src_last_modified() {return src_last_modified;} public IoEngine_xrg_downloadFil Src_last_modified_(DateAdp v) {src_last_modified = v; return this;} private DateAdp src_last_modified;
|
||||
public boolean Src_last_modified_query() {return src_last_modified_query;} public IoEngine_xrg_downloadFil Src_last_modified_query_(boolean v) {src_last_modified_query = v; return this;} private boolean src_last_modified_query;
|
||||
public String Trg_engine_key() {return trg_engine_key;} public IoEngine_xrg_downloadFil Trg_engine_key_(String v) {trg_engine_key = v; return this;} private String trg_engine_key = IoEngine_.SysKey;
|
||||
public Io_download_fmt Download_fmt() {return download_fmt;} Io_download_fmt download_fmt = new Io_download_fmt();
|
||||
public boolean Exec() {return IoEnginePool._.Fetch(trg.Info().EngineKey()).DownloadFil(this);}
|
||||
public Io_stream_rdr Exec_as_rdr() {return IoEnginePool._.Fetch(IoEngine_.SysKey).DownloadFil_as_rdr(this);}
|
||||
public Io_download_fmt Download_fmt() {return download_fmt;} private final Io_download_fmt download_fmt = new Io_download_fmt();
|
||||
public boolean Exec() {return IoEnginePool._.Get_by(trg.Info().EngineKey()).DownloadFil(this);}
|
||||
public Io_stream_rdr Exec_as_rdr() {return IoEnginePool._.Get_by(IoEngine_.SysKey).DownloadFil_as_rdr(this);}
|
||||
public boolean Exec_meta_only() {return exec_meta_only;} private boolean exec_meta_only;
|
||||
public byte[] Exec_as_bry(String src) {
|
||||
this.Src_(src); this.Trg_(trg_mem);
|
||||
download_fmt.Init(src, prog_fmt_hdr); // NOTE: must set src else NULL error
|
||||
boolean pass = IoEnginePool._.Fetch(trg_engine_key).DownloadFil(this);
|
||||
return pass ? Io_mgr._.LoadFilBry(trg_mem) : null;
|
||||
} Io_url trg_mem = Io_url_.mem_fil_("mem/download.tmp");
|
||||
download_fmt.Download_init(src, prog_fmt_hdr); // NOTE: must set src else NULL error
|
||||
boolean pass = IoEnginePool._.Get_by(trg_engine_key).DownloadFil(this);
|
||||
return pass ? Io_mgr.I.LoadFilBry(trg_mem) : null;
|
||||
} private Io_url trg_mem = Io_url_.mem_fil_("mem/download.tmp");
|
||||
public boolean Exec_meta(String src) {
|
||||
this.Src_(src); this.Trg_(trg_mem); // NOTE: set Trg_ else error in download proc
|
||||
download_fmt.Init(src, prog_fmt_hdr); // NOTE: must set src else NULL error
|
||||
download_fmt.Download_init(src, prog_fmt_hdr); // NOTE: must set src else NULL error
|
||||
exec_meta_only = true;
|
||||
boolean rv = IoEnginePool._.Fetch(trg_engine_key).DownloadFil(this);
|
||||
boolean rv = IoEnginePool._.Get_by(trg_engine_key).DownloadFil(this);
|
||||
exec_meta_only = false;
|
||||
return rv;
|
||||
}
|
||||
@ -58,7 +58,7 @@ public class IoEngine_xrg_downloadFil {
|
||||
rslt_err = null;
|
||||
rslt = Rslt_pass;
|
||||
prog_running = true;
|
||||
download_fmt.Init(src, "downloading ~{src_name}: ~{prog_left} left (@ ~{prog_rate}); ~{prog_done} of ~{src_len} (~{prog_pct}%)");
|
||||
download_fmt.Download_init(src, "downloading ~{src_name}: ~{prog_left} left (@ ~{prog_rate}); ~{prog_done} of ~{src_len} (~{prog_pct}%)");
|
||||
}
|
||||
public static IoEngine_xrg_downloadFil new_(String src, Io_url trg) {
|
||||
IoEngine_xrg_downloadFil rv = new IoEngine_xrg_downloadFil();
|
||||
|
||||
@ -22,7 +22,7 @@ public class IoEngine_xrg_loadFilStr {
|
||||
public boolean MissingIgnored() {return missingIgnored;} public IoEngine_xrg_loadFilStr MissingIgnored_() {return MissingIgnored_(true);} public IoEngine_xrg_loadFilStr MissingIgnored_(boolean v) {missingIgnored = v; return this;} private boolean missingIgnored = false;
|
||||
public boolean BomUtf8Convert() {return bomUtf8Convert;} public IoEngine_xrg_loadFilStr BomUtf8Convert_(boolean v) {bomUtf8Convert = v; return this;} private boolean bomUtf8Convert = true;
|
||||
public String Exec() {
|
||||
String s = IoEnginePool._.Fetch(url.Info().EngineKey()).LoadFilStr(this);
|
||||
String s = IoEnginePool._.Get_by(url.Info().EngineKey()).LoadFilStr(this);
|
||||
if (bomUtf8Convert && String_.Len(s) > 0 && String_.CodePointAt(s, 0) == Bom_Utf8) {
|
||||
s = String_.Mid(s, 1);
|
||||
UsrDlg_._.Warn(UsrMsg.new_("UTF8 BOM removed").Add("url", url.Xto_api()));
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user