Skip to content

core

Jump to bottom
muune edited this page Feb 28, 2019 · 17 revisions

ChDate[목차]

ChMath[목차]

ChReflect[목차]

statement[목차]

Type 확장함수[목차]

Boolean

String

List

MutableList

MutableMap

JSONArray

JSONObject

ChDate

  • Date 대한 함수들 모음

Ch.date.offset()

Ch.date.offset():Int
  • Date의 offset을 리턴함

ChMath

  • Math 대한 함수들 모음

Ch.math.rand()

Ch.math.rand(start:Int, end:Int):Int
Ch.math.rand(start:Double, end:Double):Int
  • start(포함)~end(포함)까지의 랜덤 수를 리턴함
val s = Ch.math.rand(1.5, 2.0)
val a = Ch.math.rand(0.2, 0.5)
val r = Ch.math.rand(-37.0, 37.0)

ChReflect

Ch.reflect.fields()

fields(cls: KClass<*>):Item

statement

_try()

_try(block:()->T)
  • try catch 함수
  • inline함수
_try{Ch.model.jsonToModel(json, arg[0])}?.let{
    res.result = it
    return@ch true
}
_try{JSONObject("$v")}?.let{
    res.extra[EXTRA_JSON] = it
    res.result = it
    true
}
_try{Ch.sql.db("seller")}?.let {
    val v = it.select("se_get") { User() }
    if (v.isNotEmpty()) {
        App.user = v[0]
        ...
    }
}

_requiredNotNull()

_requiredNotNull(vararg v:Any?, block:()->Unit)

Type 확장함수[목차]

Boolean

Boolean._true()

Boolean._true(block:()->Unit)
  • inline함수

Boolean._false()

Boolean._false(block:()->Unit)
  • inline함수

String

String._shift()

String._shift():String
  • 맨 앞에 한 글자를 없앤다.
"abc"._shift() //bc
var key = if(t == 'o') k else i.toString()
return key._shift()
if(updater == null) updater = mutableMapOf()
updater?.put(k._shift(), v)

String._pop()

String._pop():String
  • 맨 뒤에 한 글자를 없앤다.
"abc"._pop() //ab

String._firstUpper()

String._firstUpper():String
  • 맨 앞 글자를 대문자로 만든다.
"abc"._firstUpper() //Abc

String._firstLower()

String._firstLower():String
  • 맨 앞 글자를 소문자로 만든다.
"ABC"._firstLower() //aBC

String._notBlank()

String._notBlank(block:(String)->Unit)
  • 빈 문자열이 아니면 그 문자열을 가지고 block을 실행한다.
c.v._shift()._notBlank{if(c.p != null) st += c.p.clone(v=it)}

String._split()

String._split(s:String):List<String>
  • 받은 문자열로 split한 후 각각 trim해서 List으로 만든다. 
"a-b-c-d"._split("-")

List

List<Pair<String, Any>>?._toString()

List<Pair<String, Any>>?._toString():String
  • List를 String으로 바꿈(k:v,k:v,k:v...)형태임
(it as JSONObject)._long(arg[0])?.let{v->
    val k = "${res.key}:${res.arg._toString()}"
    timestamp[k]?.let{t -> if(v > t) timestamp[k] = v else false} ?:
    run{timestamp[k] = v}
}

List<Pair<String, Any>>?._stringify()

List<Pair<String, Any>>?._stringify():String
  • List를 String으로 바꿈(json)형태임
http.extra[EXTRA_JSON] = arg._stringify()

MutableList

MutableList._shift() 

MutableList<T>._shift():T?
  • 리스트의 첫 번째 아이템을 없앰
private val itemPool = mutableListOf<ChItem>()
itemPool._shift() ?: ChItem()

MutableList._pop() 

MutableList<T>._pop():T?
  • 리스트의 마지막 아이템을 없앰
ChThread.main(Runnable {
    base._pop(h, false)
    stack._pop()
    if (stack.isNotEmpty()) base._resume(stack.last(), true)
})

MutableList._notEmpty() 

MutableList<T>._notEmpty(block:(MutableList<T>)->Unit)
  • 리스트가 비어있지 않으면 그 리스트를 가지고 block을 실행한다.

MutableList._allStack() 

MutableList<T>._allStack(block:(MutableList<T>)->Boolean)
  • 리스트의 각각의 아이템을 돌면서 그 아이템으로 block를 실행하고 Boolean을 리턴한다.
stack._allStack{v, _->
    if (holder === v) {
        base._resume(holder, false)
        false
    } else {
        base._pop(holder, true)
        true
    }
}

MutableList._cutStack() 

MutableList<T>._cutStack(block:(MutableList<T>)->Boolean)
  • 리스트를 뒤에서부터 각각의 아이템을 돌면서 그 아이템으로 block를 실행하고 Boolean을 리턴한다.

MutableMap

Map<K, V>._toJSON()

Map<K, V>._toJSON():String
  • Map을 json형식으로 바꿈
map?._toJSON()

JSONArray

JSONArray._for()

JSONArray._for(block:(i:Int, v:T)->Unit)
  • JSONArray를 돌면서 인덱스와, 아이템(i:Int, v:T)으로 각각 block을 실행한다.
res._array("remove")?._for<String>{ _, v->
    _try{Res("", JSONObject(db.s("ch_getId", "id" to v))).remove()}
    db.exec("ch_remove", "id" to v)
}

JSONArray._toList()

JSONArray._toList():List<T>?
  • JSONArray를 List로 만든다.(Type으로)
when(it){
    is String->it
    is JSONArray -> it._toList<String>()?.joinToString(" ")
    else->null
}
json.getJSONArray("error")._toList<JSONObject>()?.forEach{
    when(it._string("method")){
        "alert"-> AppVM.alert(it._string("message") ?: Ch.i18n["alert.error"], AppVM.lastScanned)
    }
}

JSONArray._get()

JSONArray._get(idx:Int)
  • JSONArray의 index로 해당 아이템을 리턴한다.

JSONObject

JSONObject._for()

JSONObject._for(key:String? = null, block:(key:String, v:Any)->Unit)
  • JSONObject를 돌면서 key와 아이템(v:Any)으로 각각 block을 실행한다.
o._for{k, v ->
    setter[k]?.let { s ->
        @Suppress("UNCHECKED_CAST")
        when (v) {
            is JSONObject -> obj(v, (getter[k]?.call(target) as? Model) ?: throw Exception("invalid key $k"))
            is JSONArray -> arr(v, (getter[k]?.call(target) as? MutableList<Any>) ?: throw Exception("invalid key $k"))
            else -> s.call(target, v)
        }
    }
}

JSONObject._forObject()

JSONObject._forObject(key:String? = null, block:(key:String, v:JSONObject)->Unit)
  • JSONObject를 돌면서 key와 아이템(obj:JSONObject)으로 각각 block을 실행한다.
res._forObject{k, obj->load(Res(k, obj))}
v._object("data")?._forObject{k, obj->
    val m = mutableMapOf<String, String>()
    obj._forString{k, v->m[k] = v}
    data[k] = m
}

JSONObject._forList()

JSONObject._forList(key:String? = null, block:(key:String, list:List<T>)->Unit)
  • JSONObject를 돌면서 key와 아이템(list:List)으로 각각 block을 실행한다.

JSONObject._forString()

JSONObject._forString(key:String? = null, block:(key:String, v:String)->Unit)
  • JSONObject를 돌면서 key와 아이템(v:String)으로 각각 block을 실행한다.
obj._forString{k, v->m[k] = v}
this._forString{key, v->block(v)?.let{map[key] = it}}

JSONObject._forString()

JSONObject._forString(key:String? = null, block:(key:String, v:Any)->Unit)
  • JSONObject를 돌면서 key와 아이템(v:Any)으로 각각 block을 실행한다.
obj._forValue { key, v ->
    when(key.toLowerCase()) {
        "strokewidth" -> {
            if (v is Number) arg += Param.StrokeWidth(v.toInt())
            else if (v is String) reV.num(v)?.let {arg += Param.StrokeWidth(it.toInt())}
        }
        "corner" -> {
            if (v is Number) arg += Param.Corner(v.toFloat())
            else if (v is String) reV.num(v)?.let {arg += Param.Corner(it.toFloat())}
        }
        "strokecolor" -> arg += Param.StrokeColor("$v")
        "solid" -> arg += Param.Solid("$v")
        else -> Param::class.sealedSubclasses.
            find { it.simpleName?.toLowerCase() == key.toLowerCase() }?.
            let {it.objectInstance}?.let{arg += it}
    }
}

JSONObject._mapValue()

JSONObject._mapValue():Map<String, T>?
  • JSONObject를 Map<String, T>형으로 변환한다.
private var map:Map<String, Any>? = v._mapValue() //v는 JSONObject

JSONObject._map()

JSONObject._map(block:(Any)->T?):Map<String, T>?
  • JSONObject를 Map<String, T>형으로 변환되고 돌면서 아이템(v:Any)으로 각각 block을 실행한다.
it._map{
    when(it){ //it은 Any
        is String->it
        is JSONArray -> it._toList<String>()?.joinToString(" ")
        else->null
    }
}

JSONObject._mapObject()

JSONObject._mapObject(block:(JSONObject)->T?):Map<String, T>?
  • JSONObject를 Map<String, T>형으로 변환되고 돌면서 아이템(v:JSONObject)으로 각각 block을 실행한다.
v._object("request")?._mapObject{ //it은 JSONObject
    ApiRequest(
        it._string("name"),
        it._string("rules"),
        it._string("task")?.split("|")?.map{it.trim()}
    )
}

JSONObject._mapString()

JSONObject._mapString(block:(String)->T?):Map<String, T>?
  • JSONObject를 Map<String, T>형으로 변환되고 돌면서 아이템(v:String)으로 각각 block을 실행한다.
it._mapString{Font(it)} //it은 String

JSONObject._list()

JSONObject._list(vararg key:String):List<T>?
  • JSONObject에서 특정 key를 가진 아이템을 List형태로 리턴함 
obj._list<String>("gradient")?.map{Color.parseColor(it)}?.let {
    if(it.isNotEmpty()) arg += Param.Gradient(it.toIntArray())
}

JSONObject._get()

JSONObject._get(vararg key:String):Any?
  • JSONObject에서 특정 key를 가진 아이템을 Any형태로 리턴함

JSONObject._object()

JSONObject._object(vararg key:String):JSONObject?
  • JSONObject에서 특정 key를 가진 아이템을 JSONObject형태로 리턴함
v._object("data")?._forObject{k, obj->
    val m = mutableMapOf<String, String>()
    obj._forString{k, v->m[k] = v}
    data[k] = m
}
it._object("data")?.let{json->
    if(arg.size == 1){
        _try{Ch.model.jsonToModel(json, arg[0])}?.let{
            res.result = it
            return@ch true
        }
    }else{
        res.result = json
        return@ch true
    }
}

JSONObject._array()

JSONObject._array(vararg key:String):JSONArray?
  • JSONObject에서 특정 key를 가진 아이템을 JSONArray형태로 리턴함
res._array("remove")?._for<String>{ _, v->
    _try{Res("", JSONObject(db.s("ch_getId", "id" to v))).remove()}
    db.exec("ch_remove", "id" to v)
}

JSONObject._string()

JSONObject._string(vararg key:String):String?
  • JSONObject에서 특정 key를 가진 아이템을 String형태로 리턴함
v._string("id")?.let{id = it}
it._string("language")?.let{ChI18n(it)}
when(it._string("method")){
    "alert"-> AppVM.alert(it._string("message") ?: Ch.i18n["alert.error"], AppVM.lastScanned)
}

JSONObject._int()

JSONObject._int(vararg key:String):Int?
  • JSONObject에서 특정 key를 가진 아이템을 Int형태로 리턴함
if (json._int("islogin") == 1) App.router.push(Main, false)

JSONObject._long()

JSONObject._long(vararg key:String):Long?
  • JSONObject에서 특정 key를 가진 아이템을 Long형태로 리턴함
(it as JSONObject)._long(arg[0])?.let{v->
    val k = "${res.key}:${res.arg._toString()}"
    timestamp[k]?.let{t -> if(v > t) timestamp[k] = v else false} ?:
    run{timestamp[k] = v}
}

JSONObject._float()

JSONObject._float(vararg key:String):Float?
  • JSONObject에서 특정 key를 가진 아이템을 Float형태로 리턴함

JSONObject._double()

JSONObject._double(vararg key:String):Double?
  • JSONObject에서 특정 key를 가진 아이템을 Float형태로 리턴함

JSONObject._boolean()

JSONObject._boolean(vararg key:String):Boolean?
  • JSONObject에서 특정 key를 가진 아이템을 Float형태로 리턴함
Clone this wiki locally