How to use org.nutz.lang

public Object invoke(Object obj) {
  try {
    return invoker.invoke(obj);
  }
  catch (Throwable e) {
    throw new InvokingException(msg(), Lang.unwrapThrow(e));
  }
}

/**
 * @see #copyFile(File, File, long)
 */
public static boolean copyFileWithoutException(File src, File target, long count) {
  try {
    return copyFile(src, target, -1);
  }
  catch (IOException e) {
    throw Lang.wrapThrow(e);
  }
}

public Date fromString(String str) {
  str = Strings.trim(str);
  if (Strings.isEmpty(str))
    return null;
  return Times.D(str);
}

public ObjectNavlPairInjector(String prefix, Type type) {
  prefix = Strings.isBlank(prefix) ? "" : Strings.trim(prefix);
  this.prefix = prefix;
  this.mirror = Mirror.me(type);
  this.type = type;
}

@Override
public Boolean cast(String src, Class<?> toType, String... args) {
  if (Strings.isBlank(src))
    return false;
  return Lang.parseBoolean(src);
}

/**
 * 根据一个文件路径建立一个输出流
 * 
 * @param path
 *            文件路径
 * @return 输出流
 */
public static OutputStream fileOut(String path) {
  return fileOut(Files.findFile(path));
}

/**
 * 根据一个文件路径建立一个 UTF-8 文本输出流
 * 
 * @param path
 *            文件路径
 * @return 文本输出流
 */
public static Writer fileOutw(String path) {
  return fileOutw(Files.findFile(path));
}

@Override
public boolean equals(Object obj) {
  if (this == obj)
    return true;
  if (obj instanceof Pair<?>)
    if (Strings.equals(((Pair<?>) obj).name, name))
      return Lang.equals(((Pair<?>) obj).value, value);
  return false;
}

public static boolean isAnnotationExists(Method method,
                     Class<? extends Annotation>... classes) {
  if (!Lang.isEmptyArray(classes)) {
    for (Class<? extends Annotation> klass : classes) {
      if (getAnnotationDeep(method, klass) != null)
        return true;
    }
  }
  return false;
}

/**
 * 读取 UTF-8 文件全部内容
 * 
 * @param f
 *            文件
 * @return 文件内容
 */
public static String read(File f) {
  return Lang.readAll(Streams.fileInr(f));
}

/**
 * 在指定的时间点启动，两次任务间保持固定的时间间隔
 * @param task 具体待执行的任务
 * @param startTime 首次运行的时间点,支持 "yyyy-MM-dd HH:mm:ss" 格式
 * @param period 两次任务的间隔时间
 * @param unit 时间单位
 */
public static void scheduleWithFixedDelay(Runnable task, String startTime, long period, TimeUnit unit) throws ParseException {
  Date dt = Times.D(startTime);
  scheduleWithFixedDelay(task, dt, period, unit);
}

/**
 * 获取输出流
 * 
 * @param path
 *            文件路径
 * 
 * @return 输出流
 */
public static InputStream findFileAsStream(String path) {
  return findFileAsStream(path, Files.class, Encoding.defaultEncoding());
}

/**
 * 在指定的时间点开始以固定的频率运行任务。后续任务的启动时间不受前次任务延时影响。
 * @param task 具体待执行的任务
 * @param startTime 首次运行的时间点,支持 "yyyy-MM-dd HH:mm:ss" 格式
 * @param period 每次执行任务的间隔时间
 * @param unit 时间单位
 */
public static void scheduleAtFixedRate(Runnable task, String startTime, long period, TimeUnit unit) throws ParseException {
  Date dt = Times.D(startTime);
  scheduleAtFixedRate(task, dt, period, unit);
}

/**
 * 从字符串计算出数字签名
 *
 * @param algorithm
 *            算法，比如 "SHA1" 或者 "MD5" 等
 * @param cs
 *            字符串
 * @return 数字签名
 */
public static String digest(String algorithm, CharSequence cs) {
  return digest(algorithm, Strings.getBytesUTF8(null == cs ? "" : cs), null, 1);
}

/**
 * 当一个类使用<T,K>来定义泛型时,本方法返回类的一个字段的具体类型。
 *
 * @param me
 * @param field
 */
public static Type getFieldType(Mirror<?> me, String field) throws NoSuchFieldException {
  return getFieldType(me, me.getField(field));
}

private void init(String keys, Object obj) {
  this.keys = Lang.arrayFirst("obj", Strings.split(keys, false, '.'));
  this.val = obj;
  this.arrayItem = 0;
}

/**
 * 将一个毫秒秒数（天中），转换成一个格式为 HH:mm:ss,SSS 的字符串（精确到毫秒）
 * 
 * @param ams
 *            当天毫秒数
 * @return 格式为 HH:mm:ss,SSS 的字符串
 */
public static String sTms(long ams) {
  return Tims(ams).toString("HH:mm:ss,SSS");
}

/**
 * 根据一个当天的绝对毫秒数，得到一个时间字符串，格式为 "HH:mm:ss.EEE"
 * 
 * @param ms
 *            当天的绝对毫秒数
 * @return 时间字符串
 */
public static String mss(int ms) {
  int sec = ms / 1000;
  ms = ms - sec * 1000;
  return secs(sec) + "." + Strings.alignRight(ms, 3, '0');
}

public Object convert(String[] ss) {
  if (ss == null || ss.length == 0)
    return null;
  if (Strings.isBlank(ss[0]))
    return null;
  return Lang.parseBoolean(ss[0]);
}

  public static boolean isAnnotationExists(Class<?> type,
                       Class<? extends Annotation>... classes) {
    if (!Lang.isEmptyArray(classes)) {
      for (Class<? extends Annotation> klass : classes) {
        if (getAnnotationDeep(type, klass) != null)
          return true;
      }
    }
    return false;
  }
}