utkan / gcloud_cheat_sheet.md

Created December 22, 2020 19:56 — forked from pydevops/gcloud-cheat-sheet.md

gcp gcloud cheat sheet

	import android.content.Context;
	import android.os.Debug;
	import java.io.File;

	public class OomExceptionHandler implements Thread.UncaughtExceptionHandler {

	private static final String FILENAME = "out-of-memory.hprof";

	public static void install(Context context) {
	Thread.UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler();

utkan / Lol.java

Created March 29, 2019 12:26 — forked from pyricau/Lol.java

	import java.util.concurrent.Callable;

	public enum Lol implements Callable<CharSequence> {

	ಠ_ಠ {
	@Override public String call() {
	return "Foo";
	}
	};

utkan / BundleDelegate.kt

Last active June 9, 2018 21:18

	sealed class BundleDelegate<T>(protected val key: kotlin.String) : ReadWriteProperty<Bundle, T> {

	class Int(key: kotlin.String) : BundleDelegate<kotlin.Int>(key) {
	override fun getValue(thisRef: Bundle, property: KProperty<*>) = thisRef.getInt(key)

	override fun setValue(thisRef: Bundle, property: KProperty<*>, value: kotlin.Int) {
	thisRef.putInt(key, value)
	}
	}

utkan / SimpleDI.kt

Created April 15, 2018 20:21

Another, still undervalued, way to reuse factory methods is by using interface delegation. We could use it in above example this way:

	interface Dependency<T> {
	var mocked: T?
	fun get(): T
	fun lazyGet(): Lazy<T> = lazy { get() }
	}

	class Provider<T>(val init: () -> T) : Dependency<T> {
	var original: T? = null
	override var mocked: T? = null
	override fun get(): T = mocked ?: original ?: init().apply { original = this }

utkan / SimpleDI.kt

Created April 15, 2018 19:52

	abstract class Provider<T> {
	var orginal: T? = null
	var mocked: T? = null

	abstract fun create(): T

	fun get(): T = mocked ?: orginal ?: create().apply {
	orginal = this
	}

utkan / EnumInfix.kt

Created March 21, 2018 11:09

	enum class Rank {
	TWO, THREE, FOUR, FIVE,
	SIX, SEVEN, EIGHT, NINE,
	TEN, JACK, QUEEN, KING, ACE;

	fun of(suit: Suit) = Card(this, suit)
	}

	enum class Suit {
	HEARTS,

	import java.math.BigInteger

	interface Fibonacci {
	fun fib(n: Int): Int
	}

	object LawfulGood : Fibonacci {
	override fun fib(n: Int): Int {
	check(n >= 0) { "fib is undefined for negative values: $n" }
	return when (n) {

	inline fun <VM : ViewModel> viewModelFactory(
	crossinline f: () -> VM) =
	object : ViewModelProvider.Factory {
	override fun <T : ViewModel> create(aClass: Class<T>) =
	f() as T
	}

	private val viewModel by lazy {
	val factory = viewModelFactory { component.myViewModel() }
	ViewModelProviders.of(this, factory)

	class NotificationParams(val map: Map<String, String>) {
	val title: String by map
	val content: String by map
	}

	override fun onMessageReceived(message: RemoteMessage?) {
	super.onMessageReceived(message)
	val data = (message?.data ?: emptyMap()).withDefault { "" }

	val params = NotificationParams(data)

Utkan SARGIN utkan

Table of Contents