fun <T, R> Observable<List<T>>.lazyFromIterable(mapper: (T) -> Observable<R>): Observable<Observable<R>> {
    return flatMap { list ->
        Observable.create<Observable<R>> { emitter ->
            fun emi(index: Int) {
                if (list.size > index) {
                    emitter.onNext(mapper(list[index]).doOnComplete {
                        emi(index + 1)
                    })
                } else {
                    emitter.onComplete()
                }
            }
            emi(0)
        }
    }
}

fun <T> ObservableSource<out ObservableSource<out T>>.concat(): Observable<T> {
    return Observable.concat(this)
}

findNavController().navigate(SearchFragmentDirections.showRepo(repo.owner.login, repo.name))

val restartIntent = PendingIntent.getActivity(app, 0, Intent(app,MainActivity::class.java),PendingIntent.FLAG_ONE_SHOT);
val mgr = app.getSystemService(Context.ALARM_SERVICE) as AlarmManager
mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 1000, restartIntent)

System.exit(0)

/**
 * yyyy-MM-dd HH:mm:ss
 */
//val defSimpleDateFormat by lazy { SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault()) }

val DATE_PATTERN_DEF = "yyyy-MM-dd HH:mm:ss"

fun String.formatDate(date: Any) = getDateFormat(this).format(date)

fun String.parseDate(date: String) = getDateFormat(this).parse(date)

private val threadLocal =object :ThreadLocal<MutableMap<String, SimpleDateFormat>>(){
    override fun initialValue(): MutableMap<String, SimpleDateFormat>  = mutableMapOf()
}

private fun getDateFormat(pattern: String): SimpleDateFormat {
    return threadLocal.get().getOrPut(pattern) { SimpleDateFormat(pattern, Locale.getDefault()) }
}

import android.arch.lifecycle.MutableLiveData
import android.content.Context
import android.content.SharedPreferences
import com.google.gson.reflect.TypeToken
import com.App
import java.lang.reflect.Type
import kotlin.reflect.KProperty

val sharedPreferences by lazy { App.app.getSharedPreferences("generalDelegate", Context.MODE_PRIVATE) }

inline fun <reified T> sharedPreferencesDelegate(def: T?, noinline sp: () -> SharedPreferences = { sharedPreferences }) = SharedPreferencesDelegate(def, sp, type = object : TypeToken<T>() {}.type)

class SharedPreferencesDelegate<T>(val def: T?, val sp: () -> SharedPreferences = { sharedPreferences }, val type: Type) {
    private val json by lazy { gson.toJson(def) }
    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        val sp = sp()
        return when (type) {
            String::class.java -> sp.getString(property.name, def as String?)
            Boolean::class.java -> sp.getBoolean(property.name, def as Boolean)
            Float::class.java -> sp.getFloat(property.name, def as Float)
            Int::class.java -> sp.getInt(property.name, def as Int)
            Long::class.java -> sp.getLong(property.name, def as Long)
            else -> gson.fromJson(sp.getString(property.name, json), type)
        } as T
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T?) {
        val edit = sp().edit()
        when (type) {
            String::class.java -> edit.putString(property.name, value as String?)
            Boolean::class.java -> edit.putBoolean(property.name, value as Boolean)
            Float::class.java -> edit.putFloat(property.name, value as Float)
            Int::class.java -> edit.putInt(property.name, value as Int)
            Long::class.java -> edit.putLong(property.name, value as Long)
            else -> edit.putString(property.name, gson.toJson(value))
        }
        edit.apply()
    }
}

inline fun <reified T> liveDataDelegate(def: T?, noinline sp: () -> SharedPreferences = { sharedPreferences }) = SharedPreferencesLiveData(def, sp, type = object : TypeToken<T>() {}.type)

class SharedPreferencesLiveData<T>(val def: T?, val sp: () -> SharedPreferences = { sharedPreferences }, val type: Type) {
    private val json by lazy { gson.toJson(def) }
    private var liveData: MutableLiveData<T>? = null
    operator fun getValue(thisRef: Any?, property: KProperty<*>): MutableLiveData<T> {
        val sp = sp()
        if (liveData == null) {
            liveData = object : MutableLiveData<T>() {
                override fun setValue(value: T) {
                    val edit = sp().edit()
                    when (type) {
                        String::class.java -> edit.putString(property.name, value as String?)
                        Boolean::class.java -> edit.putBoolean(property.name, value as Boolean)
                        Float::class.java -> edit.putFloat(property.name, value as Float)
                        Int::class.java -> edit.putInt(property.name, value as Int)
                        Long::class.java -> edit.putLong(property.name, value as Long)
                        else -> edit.putString(property.name, gson.toJson(value))
                    }
                    edit.apply()
                    if (Thread.currentThread() == Looper.getMainLooper().thread) {
                        super.setValue(value)
                    } else {
                        super.postValue(value)
                    }
                }
            }
            liveData?.value = when (type) {
                String::class.java -> sp().getString(property.name, def as String?)
                Boolean::class.java -> sp().getBoolean(property.name, def as Boolean)
                Float::class.java -> sp().getFloat(property.name, def as Float)
                Int::class.java -> sp().getInt(property.name, def as Int)
                Long::class.java -> sp().getLong(property.name, def as Long)
                else -> gson.fromJson(sp().getString(property.name, json), type)
            } as T
        }
        return liveData!!
    }
}

@Expose
var key = "";

val gson = GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()

val gson = GsonBuilder().addSerializationExclusionStrategy(object : ExclusionStrategy {
    override fun shouldSkipClass(clazz: Class<*>?): Boolean = false

    override fun shouldSkipField(f: FieldAttributes): Boolean {
        val expose = f.getAnnotation(Expose::class.java)
        return expose != null && !expose.serialize
    }
}).create()

@Expose(serialize = false,)
var key = 0;

@SerializedName("authed") //json 中名字为authed
Authedaaaaa

@SerializedName(value = "ret", alternate = [ "code"])
var ret: Int = 0

inline fun <reified T> Gson.fromJson(json: String): T {
    return fromJson(json, object: TypeToken<T>() {}.type)
}

val gson = GsonBuilder()
        .also { gb ->
            ScalarsJsonDeserializer.types.forEach { gb.registerTypeAdapter(it, ScalarsJsonDeserializer) }
        }.create()

private object ScalarsJsonDeserializer : JsonDeserializer<Any> {
    val types = arrayOf<Type>(String::class.java,
            Boolean::class.java,
            Byte::class.java,
            Char::class.java,
            Double::class.java,
            Float::class.java,
            Int::class.java,
            Long::class.java,
            Short::class.java
    )

    override fun deserialize(json: JsonElement?, typeOfT: Type?, context: JsonDeserializationContext?): Any? {
        return try {
            when (TypeToken.get(typeOfT).rawType) {
                String::class.java -> json?.asString
                Boolean::class.java -> json?.asBoolean
                Byte::class.java -> json?.asByte
                Char::class.java -> json?.asCharacter
                Double::class.java -> json?.asDouble
                Float::class.java -> json?.asFloat
                Int::class.java -> json?.asInt
                Long::class.java -> json?.asLong
                Short::class.java -> json?.asShort
                else -> null
            }
        } catch (e: Exception) {
            null
        }
    }

}

import android.support.annotation.IdRes
import android.support.v4.app.Fragment
import android.support.v4.app.FragmentTransaction
import android.support.v7.app.AppCompatActivity

inline fun <reified T : Fragment> AppCompatActivity.addFragment(@IdRes containerId: Int, tag: String, init: T.() -> Unit = {}): T {
    return fragment<T>(containerId, tag, init, FragmentTransaction::add)
}

inline fun <reified T : Fragment> AppCompatActivity.fragment(@IdRes containerId: Int, tag: String, init: T.() -> Unit = {}, operate: FragmentTransaction.(Int, T, String) -> FragmentTransaction): T {
    var fragment = supportFragmentManager.findFragmentByTag(tag)
    if (fragment == null) {
        fragment = T::class.java.newInstance()
        fragment.init()
        supportFragmentManager.beginTransaction().operate(containerId, fragment, tag).commit()
    }
    return fragment as T
}

class FragmentAdapter(val data: List<Pair<String, Class<out Fragment>>>) : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
        private var with = ViewGroup.LayoutParams.MATCH_PARENT
        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
            parent.addOnLayoutChangeListener { v, left, _, right, _, _, _, _, _ ->
                val count = itemCount
                val expectWith = when (count) {
                    1 -> ViewGroup.LayoutParams.MATCH_PARENT
                    2,3 -> (right - left) / count
                    else -> (right - left) / 3
                }
                if (expectWith != with) {
                    with = expectWith
                    v.post { notifyDataSetChanged() }
                }
            }
            return object : RecyclerView.ViewHolder(LayoutInflater.from(parent.context).inflate(R.layout.item, parent, false)) {}
        }

        override fun getItemCount(): Int {
            return data.size
        }

        override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
            val lp = holder.itemView.layoutParams as RecyclerView.LayoutParams
            lp.width = with - lp.leftMargin - lp.rightMargin
        }
    }

import android.arch.lifecycle.ViewModel
import android.arch.lifecycle.ViewModelProvider
import android.arch.lifecycle.ViewModelProviders
import android.support.v4.app.Fragment
import android.support.v4.app.FragmentActivity

inline fun <reified T : ViewModel> Fragment.getModel(factory: ViewModelProvider.Factory? = null): T {
    return ViewModelProviders.of(this, factory).get(T::class.java)
}

inline fun <reified T : ViewModel> FragmentActivity.getModel(factory: ViewModelProvider.Factory? = null): T {
    return ViewModelProviders.of(this, factory).get(T::class.java)
}

@com.raizlabs.android.dbflow.annotation.TypeConverter
class PointListTypeConverter : TypeConverter<String, List<Point>>() {
    private val type = object : TypeToken<List<Point>>() {}.type
    override fun getDBValue(model: List<Point>?): String = gson.toJson(model)

    override fun getModelValue(data: String?): List<Point> = gson.fromJson(data, type)

}

package sjj.fiction.util

import android.arch.lifecycle.Lifecycle
import android.arch.lifecycle.LifecycleObserver
import android.arch.lifecycle.OnLifecycleEvent
import io.reactivex.disposables.Disposable
import java.util.*

private val map = Collections.synchronizedMap(WeakHashMap<String, BaseLifecycleObserver>())

fun Disposable.destroy(onceKey: String? = null, lifecycle: Lifecycle) {
    lifecycle.addObserver(BaseLifecycleObserver(this, lifecycle, onceKey, Lifecycle.Event.ON_DESTROY))
}

fun Disposable.stop(onceKey: String? = null, lifecycle: Lifecycle) {
    lifecycle.addObserver(BaseLifecycleObserver(this, lifecycle, onceKey, Lifecycle.Event.ON_STOP))
}

fun Disposable.pause(onceKey: String? = null, lifecycle: Lifecycle) {
    lifecycle.addObserver(BaseLifecycleObserver(this, lifecycle, onceKey, Lifecycle.Event.ON_PAUSE))
}

class BaseLifecycleObserver(val disposable: Disposable,
                            private val lifecycle: Lifecycle,
                            private val onceKey: String? = null,
                            private val event: Lifecycle.Event = Lifecycle.Event.ON_DESTROY) : LifecycleObserver {
    init {
        if (onceKey != null) {
            val observer = map.remove(onceKey)
            map[onceKey] = this
            if (observer != null) {
                observer.disposable.dispose()
                lifecycle.removeObserver(observer)
            }
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        if (event == Lifecycle.Event.ON_STOP) {
            clean()
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        if (event == Lifecycle.Event.ON_DESTROY) {
            clean()
        }
    }

    private fun clean() {
        disposable.dispose()
        if (onceKey != null)
            map.remove(onceKey)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        if (disposable.isDisposed) {
            lifecycle.removeObserver(this)
            if (onceKey != null)
                map.remove(onceKey)
        }
        if (event == Lifecycle.Event.ON_PAUSE) {
            clean()
        }
    }

}

// and fragment
class BaseActivity : AppCompatActivity() {
    fun Disposable.destroy(onceKey: String? = null) {
        destroy(onceKey, lifecycle)
    }

    fun Disposable.stop(onceKey: String? = null) {
        stop(onceKey, lifecycle)
    }

    fun Disposable.pause(onceKey: String? = null) {
        pause(onceKey, lifecycle)
    }
}

rxOfType<Any>().subscribe{

 }.destroy()

/**
 * Created by sjj on 2017/9/19.
 */
fun ByteArray.toHexString(): String = map { String.format("%02X ", it) }.reduce { acc, s -> acc + " " + s }

fun ByteArray.hex(): String = map { String.format("%02X ", it) }.reduce { acc, s -> acc + s }

fun ByteArray.toHexString(start: Int, length: Int): String {
    val sb = StringBuilder()
    for (index in start until start + length) {
        sb.append(String.format("%02X ", get(index)))
    }
    return sb.toString()
}

fun Int.hex() = String.format("%02X ", this)