Best code snippets using tc.oc.commons.core.util(Showing top 15 results out of 315)

  /**
   * Return a generated implementation of {@link T} that delegates all method calls
   * to the instance returned by the given {@link Provider}. That instance is not
   * retrieved until the first time a method is called, after which the returned
   * instance is cached and reused forever.
   *
   * The provider's {@link ClassLoader} is used to load the generated class.
   */
  public static <T> T newCachingProviderProxy(Class<T> type, Provider<T> provider) {
    return newProxy(type, MethodHandleInvoker.caching(provider));
  }
}

  private void handleCompletion() {
    for(ThrowingRunnable<?> handler : completionHandlers) {
      try {
        handler.runThrows();
      } catch(Throwable e) {
        handleFailure(e);
      }
    }
  }
}

public <U, E extends Throwable> U let(T value, ThrowingSupplier<U, E> block) throws E {
  if(value == get()) {
    return block.getThrows();
  } else {
    try(CheckedCloseable x = let(value)) {
      return block.getThrows();
    }
  }
}

/**
 * Add or use an object to this usage collection.
 * @param object the object to add or use.
 */
public void use(E object) {
  if(!containsKey(object)) {
    put(object, new Index());
  } else {
    get(object).change(+1);
  }
}

  @Override public Uniformity<T> combine(Uniformity<T> that) {
    if(that instanceof Intermediate) {
      return add(((Intermediate<T>) that).value);
    } else {
      return that.combine(this);
    }
  }
}

public static <E extends Throwable> void propagate(Class<E> ex, ThrowingRunnable<Throwable> block) throws E {
  propagate(ex, () -> {
    block.runThrows();
    return null;
  });
}

/**
 * Allocate an additional usage space for an object.
 * @param object the object to allocate an additional space for.
 */
public void allocate(E object) {
  if(containsValue(object)) {
    get(object).change(-1);
  }
}

@Override
default Object[] toArray() {
  final E value = orElse(null);
  return value == null ? ArrayUtils.zeroObjects()
             : new Object[] {value};
}

/**
 * Return a formatted stack trace
 */
@Override
public String toString() {
  return ExceptionUtils.formatStackTrace(trace(), skipTest());
}

public static <K, V> void forEachWithIndex(Multimap<K, V> multimap, int start, IndexedBiConsumer<? super K, ? super V> consumer) {
  final Counter index = new Counter(start);
  forEach(multimap, (k, v) -> consumer.accept(k, v, index.next()));
}

  public CheckedCloseable let(T value) {
    final T old = get();
    set(value);
    return () -> set(old);
  }
}

public static <T> T propagate(ThrowingSupplier<T, Throwable> block) {
  try {
    return block.getThrows();
  } catch(Throwable e) {
    throw propagate(e);
  }
}

/**
 * Return a generated implementation of {@link T} that delegates all method calls
 * to the instance returned by the given {@link Provider}. The provider is called
 * for every method invocation.
 *
 * The provider's {@link ClassLoader} is used to load the generated class.
 */
public static <T> T newProviderProxy(Class<T> type, Provider<T> provider) {
  return newProxy(type, MethodHandleInvoker.dynamic(provider));
}

public static void propagate(ThrowingRunnable<Throwable> block) {
  propagate(() -> {
    block.runThrows();
    return null;
  });
}

public <E extends Throwable> void let(T value, ThrowingRunnable<E> block) throws E {
  if(value == get()) {
    block.runThrows();
  } else {
    try(CheckedCloseable x = let(value)) {
      block.runThrows();
    }
  }
}