mirror of
https://gitee.com/johng/gf.git
synced 2024-12-05 05:37:55 +08:00
800 lines
16 KiB
Go
800 lines
16 KiB
Go
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
// If a copy of the MIT was not distributed with this file,
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
// Package gconv implements powerful and convenient converting functionality for any types of variables.
|
|
//
|
|
// This package should keep much less dependencies with other packages.
|
|
package gconv
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/gogf/gf/v2/internal/json"
|
|
"github.com/gogf/gf/v2/os/gtime"
|
|
"math"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gogf/gf/v2/encoding/gbinary"
|
|
)
|
|
|
|
var (
|
|
// Empty strings.
|
|
emptyStringMap = map[string]struct{}{
|
|
"": {},
|
|
"0": {},
|
|
"no": {},
|
|
"off": {},
|
|
"false": {},
|
|
}
|
|
|
|
// StructTagPriority defines the default priority tags for Map*/Struct* functions.
|
|
// Note, the "gconv", "param", "params" tags are used by old version of package.
|
|
// It is strongly recommended using short tag "c" or "p" instead in the future.
|
|
StructTagPriority = []string{"gconv", "param", "params", "c", "p", "json"}
|
|
)
|
|
|
|
type doConvertInput struct {
|
|
FromValue interface{} // Value that is converted from.
|
|
ToTypeName string // Target value type name in string.
|
|
ReferValue interface{} // Referred value, a value in type `ToTypeName`.
|
|
Extra []interface{} // Extra values for implementing the converting.
|
|
}
|
|
|
|
// doConvert does commonly use types converting.
|
|
func doConvert(in doConvertInput) interface{} {
|
|
switch in.ToTypeName {
|
|
case "int":
|
|
return Int(in.FromValue)
|
|
case "*int":
|
|
if _, ok := in.FromValue.(*int); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Int(in.FromValue)
|
|
return &v
|
|
|
|
case "int8":
|
|
return Int8(in.FromValue)
|
|
case "*int8":
|
|
if _, ok := in.FromValue.(*int8); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Int8(in.FromValue)
|
|
return &v
|
|
|
|
case "int16":
|
|
return Int16(in.FromValue)
|
|
case "*int16":
|
|
if _, ok := in.FromValue.(*int16); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Int16(in.FromValue)
|
|
return &v
|
|
|
|
case "int32":
|
|
return Int32(in.FromValue)
|
|
case "*int32":
|
|
if _, ok := in.FromValue.(*int32); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Int32(in.FromValue)
|
|
return &v
|
|
|
|
case "int64":
|
|
return Int64(in.FromValue)
|
|
case "*int64":
|
|
if _, ok := in.FromValue.(*int64); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Int64(in.FromValue)
|
|
return &v
|
|
|
|
case "uint":
|
|
return Uint(in.FromValue)
|
|
case "*uint":
|
|
if _, ok := in.FromValue.(*uint); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Uint(in.FromValue)
|
|
return &v
|
|
|
|
case "uint8":
|
|
return Uint8(in.FromValue)
|
|
case "*uint8":
|
|
if _, ok := in.FromValue.(*uint8); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Uint8(in.FromValue)
|
|
return &v
|
|
|
|
case "uint16":
|
|
return Uint16(in.FromValue)
|
|
case "*uint16":
|
|
if _, ok := in.FromValue.(*uint16); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Uint16(in.FromValue)
|
|
return &v
|
|
|
|
case "uint32":
|
|
return Uint32(in.FromValue)
|
|
case "*uint32":
|
|
if _, ok := in.FromValue.(*uint32); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Uint32(in.FromValue)
|
|
return &v
|
|
|
|
case "uint64":
|
|
return Uint64(in.FromValue)
|
|
case "*uint64":
|
|
if _, ok := in.FromValue.(*uint64); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Uint64(in.FromValue)
|
|
return &v
|
|
|
|
case "float32":
|
|
return Float32(in.FromValue)
|
|
case "*float32":
|
|
if _, ok := in.FromValue.(*float32); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Float32(in.FromValue)
|
|
return &v
|
|
|
|
case "float64":
|
|
return Float64(in.FromValue)
|
|
case "*float64":
|
|
if _, ok := in.FromValue.(*float64); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Float64(in.FromValue)
|
|
return &v
|
|
|
|
case "bool":
|
|
return Bool(in.FromValue)
|
|
case "*bool":
|
|
if _, ok := in.FromValue.(*bool); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Bool(in.FromValue)
|
|
return &v
|
|
|
|
case "string":
|
|
return String(in.FromValue)
|
|
case "*string":
|
|
if _, ok := in.FromValue.(*string); ok {
|
|
return in.FromValue
|
|
}
|
|
v := String(in.FromValue)
|
|
return &v
|
|
|
|
case "[]byte":
|
|
return Bytes(in.FromValue)
|
|
case "[]int":
|
|
return Ints(in.FromValue)
|
|
case "[]int32":
|
|
return Int32s(in.FromValue)
|
|
case "[]int64":
|
|
return Int64s(in.FromValue)
|
|
case "[]uint":
|
|
return Uints(in.FromValue)
|
|
case "[]uint8":
|
|
return Bytes(in.FromValue)
|
|
case "[]uint32":
|
|
return Uint32s(in.FromValue)
|
|
case "[]uint64":
|
|
return Uint64s(in.FromValue)
|
|
case "[]float32":
|
|
return Float32s(in.FromValue)
|
|
case "[]float64":
|
|
return Float64s(in.FromValue)
|
|
case "[]string":
|
|
return Strings(in.FromValue)
|
|
|
|
case "Time", "time.Time":
|
|
if len(in.Extra) > 0 {
|
|
return Time(in.FromValue, String(in.Extra[0]))
|
|
}
|
|
return Time(in.FromValue)
|
|
case "*time.Time":
|
|
var v interface{}
|
|
if len(in.Extra) > 0 {
|
|
v = Time(in.FromValue, String(in.Extra[0]))
|
|
} else {
|
|
if _, ok := in.FromValue.(*time.Time); ok {
|
|
return in.FromValue
|
|
}
|
|
v = Time(in.FromValue)
|
|
}
|
|
return &v
|
|
|
|
case "GTime", "gtime.Time":
|
|
if len(in.Extra) > 0 {
|
|
if v := GTime(in.FromValue, String(in.Extra[0])); v != nil {
|
|
return *v
|
|
} else {
|
|
return *gtime.New()
|
|
}
|
|
}
|
|
if v := GTime(in.FromValue); v != nil {
|
|
return *v
|
|
} else {
|
|
return *gtime.New()
|
|
}
|
|
case "*gtime.Time":
|
|
if len(in.Extra) > 0 {
|
|
if v := GTime(in.FromValue, String(in.Extra[0])); v != nil {
|
|
return v
|
|
} else {
|
|
return gtime.New()
|
|
}
|
|
}
|
|
if v := GTime(in.FromValue); v != nil {
|
|
return v
|
|
} else {
|
|
return gtime.New()
|
|
}
|
|
|
|
case "Duration", "time.Duration":
|
|
return Duration(in.FromValue)
|
|
case "*time.Duration":
|
|
if _, ok := in.FromValue.(*time.Duration); ok {
|
|
return in.FromValue
|
|
}
|
|
v := Duration(in.FromValue)
|
|
return &v
|
|
|
|
case "map[string]string":
|
|
return MapStrStr(in.FromValue)
|
|
|
|
case "map[string]interface{}":
|
|
return Map(in.FromValue)
|
|
|
|
case "[]map[string]interface{}":
|
|
return Maps(in.FromValue)
|
|
|
|
default:
|
|
if in.ReferValue != nil {
|
|
var (
|
|
referReflectValue reflect.Value
|
|
)
|
|
if v, ok := in.ReferValue.(reflect.Value); ok {
|
|
referReflectValue = v
|
|
} else {
|
|
referReflectValue = reflect.ValueOf(in.ReferValue)
|
|
}
|
|
in.ToTypeName = referReflectValue.Kind().String()
|
|
in.ReferValue = nil
|
|
return reflect.ValueOf(doConvert(in)).Convert(referReflectValue.Type()).Interface()
|
|
}
|
|
return in.FromValue
|
|
}
|
|
}
|
|
|
|
// Convert converts the variable `fromValue` to the type `toTypeName`, the type `toTypeName` is specified by string.
|
|
// The optional parameter `extraParams` is used for additional necessary parameter for this conversion.
|
|
// It supports common types conversion as its conversion based on type name string.
|
|
func Convert(fromValue interface{}, toTypeName string, extraParams ...interface{}) interface{} {
|
|
return doConvert(doConvertInput{
|
|
FromValue: fromValue,
|
|
ToTypeName: toTypeName,
|
|
ReferValue: nil,
|
|
Extra: extraParams,
|
|
})
|
|
}
|
|
|
|
// Byte converts `any` to byte.
|
|
func Byte(any interface{}) byte {
|
|
if v, ok := any.(byte); ok {
|
|
return v
|
|
}
|
|
return Uint8(any)
|
|
}
|
|
|
|
// Bytes converts `any` to []byte.
|
|
func Bytes(any interface{}) []byte {
|
|
if any == nil {
|
|
return nil
|
|
}
|
|
switch value := any.(type) {
|
|
case string:
|
|
return []byte(value)
|
|
case []byte:
|
|
return value
|
|
default:
|
|
if f, ok := value.(iBytes); ok {
|
|
return f.Bytes()
|
|
}
|
|
var (
|
|
reflectValue = reflect.ValueOf(any)
|
|
reflectKind = reflectValue.Kind()
|
|
)
|
|
for reflectKind == reflect.Ptr {
|
|
reflectValue = reflectValue.Elem()
|
|
reflectKind = reflectValue.Kind()
|
|
}
|
|
switch reflectKind {
|
|
case reflect.Array, reflect.Slice:
|
|
var (
|
|
ok = true
|
|
bytes = make([]byte, reflectValue.Len())
|
|
)
|
|
for i, _ := range bytes {
|
|
int32Value := Int32(reflectValue.Index(i).Interface())
|
|
if int32Value < 0 || int32Value > math.MaxUint8 {
|
|
ok = false
|
|
break
|
|
}
|
|
bytes[i] = byte(int32Value)
|
|
}
|
|
if ok {
|
|
return bytes
|
|
}
|
|
}
|
|
return gbinary.Encode(any)
|
|
}
|
|
}
|
|
|
|
// Rune converts `any` to rune.
|
|
func Rune(any interface{}) rune {
|
|
if v, ok := any.(rune); ok {
|
|
return v
|
|
}
|
|
return Int32(any)
|
|
}
|
|
|
|
// Runes converts `any` to []rune.
|
|
func Runes(any interface{}) []rune {
|
|
if v, ok := any.([]rune); ok {
|
|
return v
|
|
}
|
|
return []rune(String(any))
|
|
}
|
|
|
|
// String converts `any` to string.
|
|
// It's most commonly used converting function.
|
|
func String(any interface{}) string {
|
|
if any == nil {
|
|
return ""
|
|
}
|
|
switch value := any.(type) {
|
|
case int:
|
|
return strconv.Itoa(value)
|
|
case int8:
|
|
return strconv.Itoa(int(value))
|
|
case int16:
|
|
return strconv.Itoa(int(value))
|
|
case int32:
|
|
return strconv.Itoa(int(value))
|
|
case int64:
|
|
return strconv.FormatInt(value, 10)
|
|
case uint:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint8:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint16:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint32:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint64:
|
|
return strconv.FormatUint(value, 10)
|
|
case float32:
|
|
return strconv.FormatFloat(float64(value), 'f', -1, 32)
|
|
case float64:
|
|
return strconv.FormatFloat(value, 'f', -1, 64)
|
|
case bool:
|
|
return strconv.FormatBool(value)
|
|
case string:
|
|
return value
|
|
case []byte:
|
|
return string(value)
|
|
case time.Time:
|
|
if value.IsZero() {
|
|
return ""
|
|
}
|
|
return value.String()
|
|
case *time.Time:
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return value.String()
|
|
case gtime.Time:
|
|
if value.IsZero() {
|
|
return ""
|
|
}
|
|
return value.String()
|
|
case *gtime.Time:
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return value.String()
|
|
default:
|
|
// Empty checks.
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
if f, ok := value.(iString); ok {
|
|
// If the variable implements the String() interface,
|
|
// then use that interface to perform the conversion
|
|
return f.String()
|
|
}
|
|
if f, ok := value.(iError); ok {
|
|
// If the variable implements the Error() interface,
|
|
// then use that interface to perform the conversion
|
|
return f.Error()
|
|
}
|
|
// Reflect checks.
|
|
var (
|
|
rv = reflect.ValueOf(value)
|
|
kind = rv.Kind()
|
|
)
|
|
switch kind {
|
|
case reflect.Chan,
|
|
reflect.Map,
|
|
reflect.Slice,
|
|
reflect.Func,
|
|
reflect.Ptr,
|
|
reflect.Interface,
|
|
reflect.UnsafePointer:
|
|
if rv.IsNil() {
|
|
return ""
|
|
}
|
|
case reflect.String:
|
|
return rv.String()
|
|
}
|
|
if kind == reflect.Ptr {
|
|
return String(rv.Elem().Interface())
|
|
}
|
|
// Finally, we use json.Marshal to convert.
|
|
if jsonContent, err := json.Marshal(value); err != nil {
|
|
return fmt.Sprint(value)
|
|
} else {
|
|
return string(jsonContent)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bool converts `any` to bool.
|
|
// It returns false if `any` is: false, "", 0, "false", "off", "no", empty slice/map.
|
|
func Bool(any interface{}) bool {
|
|
if any == nil {
|
|
return false
|
|
}
|
|
switch value := any.(type) {
|
|
case bool:
|
|
return value
|
|
case []byte:
|
|
if _, ok := emptyStringMap[strings.ToLower(string(value))]; ok {
|
|
return false
|
|
}
|
|
return true
|
|
case string:
|
|
if _, ok := emptyStringMap[strings.ToLower(value)]; ok {
|
|
return false
|
|
}
|
|
return true
|
|
default:
|
|
if f, ok := value.(iBool); ok {
|
|
return f.Bool()
|
|
}
|
|
rv := reflect.ValueOf(any)
|
|
switch rv.Kind() {
|
|
case reflect.Ptr:
|
|
return !rv.IsNil()
|
|
case reflect.Map:
|
|
fallthrough
|
|
case reflect.Array:
|
|
fallthrough
|
|
case reflect.Slice:
|
|
return rv.Len() != 0
|
|
case reflect.Struct:
|
|
return true
|
|
default:
|
|
s := strings.ToLower(String(any))
|
|
if _, ok := emptyStringMap[s]; ok {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
// Int converts `any` to int.
|
|
func Int(any interface{}) int {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(int); ok {
|
|
return v
|
|
}
|
|
return int(Int64(any))
|
|
}
|
|
|
|
// Int8 converts `any` to int8.
|
|
func Int8(any interface{}) int8 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(int8); ok {
|
|
return v
|
|
}
|
|
return int8(Int64(any))
|
|
}
|
|
|
|
// Int16 converts `any` to int16.
|
|
func Int16(any interface{}) int16 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(int16); ok {
|
|
return v
|
|
}
|
|
return int16(Int64(any))
|
|
}
|
|
|
|
// Int32 converts `any` to int32.
|
|
func Int32(any interface{}) int32 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(int32); ok {
|
|
return v
|
|
}
|
|
return int32(Int64(any))
|
|
}
|
|
|
|
// Int64 converts `any` to int64.
|
|
func Int64(any interface{}) int64 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
switch value := any.(type) {
|
|
case int:
|
|
return int64(value)
|
|
case int8:
|
|
return int64(value)
|
|
case int16:
|
|
return int64(value)
|
|
case int32:
|
|
return int64(value)
|
|
case int64:
|
|
return value
|
|
case uint:
|
|
return int64(value)
|
|
case uint8:
|
|
return int64(value)
|
|
case uint16:
|
|
return int64(value)
|
|
case uint32:
|
|
return int64(value)
|
|
case uint64:
|
|
return int64(value)
|
|
case float32:
|
|
return int64(value)
|
|
case float64:
|
|
return int64(value)
|
|
case bool:
|
|
if value {
|
|
return 1
|
|
}
|
|
return 0
|
|
case []byte:
|
|
return gbinary.DecodeToInt64(value)
|
|
default:
|
|
if f, ok := value.(iInt64); ok {
|
|
return f.Int64()
|
|
}
|
|
s := String(value)
|
|
isMinus := false
|
|
if len(s) > 0 {
|
|
if s[0] == '-' {
|
|
isMinus = true
|
|
s = s[1:]
|
|
} else if s[0] == '+' {
|
|
s = s[1:]
|
|
}
|
|
}
|
|
// Hexadecimal
|
|
if len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') {
|
|
if v, e := strconv.ParseInt(s[2:], 16, 64); e == nil {
|
|
if isMinus {
|
|
return -v
|
|
}
|
|
return v
|
|
}
|
|
}
|
|
// Octal
|
|
if len(s) > 1 && s[0] == '0' {
|
|
if v, e := strconv.ParseInt(s[1:], 8, 64); e == nil {
|
|
if isMinus {
|
|
return -v
|
|
}
|
|
return v
|
|
}
|
|
}
|
|
// Decimal
|
|
if v, e := strconv.ParseInt(s, 10, 64); e == nil {
|
|
if isMinus {
|
|
return -v
|
|
}
|
|
return v
|
|
}
|
|
// Float64
|
|
return int64(Float64(value))
|
|
}
|
|
}
|
|
|
|
// Uint converts `any` to uint.
|
|
func Uint(any interface{}) uint {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(uint); ok {
|
|
return v
|
|
}
|
|
return uint(Uint64(any))
|
|
}
|
|
|
|
// Uint8 converts `any` to uint8.
|
|
func Uint8(any interface{}) uint8 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(uint8); ok {
|
|
return v
|
|
}
|
|
return uint8(Uint64(any))
|
|
}
|
|
|
|
// Uint16 converts `any` to uint16.
|
|
func Uint16(any interface{}) uint16 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(uint16); ok {
|
|
return v
|
|
}
|
|
return uint16(Uint64(any))
|
|
}
|
|
|
|
// Uint32 converts `any` to uint32.
|
|
func Uint32(any interface{}) uint32 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
if v, ok := any.(uint32); ok {
|
|
return v
|
|
}
|
|
return uint32(Uint64(any))
|
|
}
|
|
|
|
// Uint64 converts `any` to uint64.
|
|
func Uint64(any interface{}) uint64 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
switch value := any.(type) {
|
|
case int:
|
|
return uint64(value)
|
|
case int8:
|
|
return uint64(value)
|
|
case int16:
|
|
return uint64(value)
|
|
case int32:
|
|
return uint64(value)
|
|
case int64:
|
|
return uint64(value)
|
|
case uint:
|
|
return uint64(value)
|
|
case uint8:
|
|
return uint64(value)
|
|
case uint16:
|
|
return uint64(value)
|
|
case uint32:
|
|
return uint64(value)
|
|
case uint64:
|
|
return value
|
|
case float32:
|
|
return uint64(value)
|
|
case float64:
|
|
return uint64(value)
|
|
case bool:
|
|
if value {
|
|
return 1
|
|
}
|
|
return 0
|
|
case []byte:
|
|
return gbinary.DecodeToUint64(value)
|
|
default:
|
|
if f, ok := value.(iUint64); ok {
|
|
return f.Uint64()
|
|
}
|
|
s := String(value)
|
|
// Hexadecimal
|
|
if len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') {
|
|
if v, e := strconv.ParseUint(s[2:], 16, 64); e == nil {
|
|
return v
|
|
}
|
|
}
|
|
// Octal
|
|
if len(s) > 1 && s[0] == '0' {
|
|
if v, e := strconv.ParseUint(s[1:], 8, 64); e == nil {
|
|
return v
|
|
}
|
|
}
|
|
// Decimal
|
|
if v, e := strconv.ParseUint(s, 10, 64); e == nil {
|
|
return v
|
|
}
|
|
// Float64
|
|
return uint64(Float64(value))
|
|
}
|
|
}
|
|
|
|
// Float32 converts `any` to float32.
|
|
func Float32(any interface{}) float32 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
switch value := any.(type) {
|
|
case float32:
|
|
return value
|
|
case float64:
|
|
return float32(value)
|
|
case []byte:
|
|
return gbinary.DecodeToFloat32(value)
|
|
default:
|
|
if f, ok := value.(iFloat32); ok {
|
|
return f.Float32()
|
|
}
|
|
v, _ := strconv.ParseFloat(String(any), 64)
|
|
return float32(v)
|
|
}
|
|
}
|
|
|
|
// Float64 converts `any` to float64.
|
|
func Float64(any interface{}) float64 {
|
|
if any == nil {
|
|
return 0
|
|
}
|
|
switch value := any.(type) {
|
|
case float32:
|
|
return float64(value)
|
|
case float64:
|
|
return value
|
|
case []byte:
|
|
return gbinary.DecodeToFloat64(value)
|
|
default:
|
|
if f, ok := value.(iFloat64); ok {
|
|
return f.Float64()
|
|
}
|
|
v, _ := strconv.ParseFloat(String(any), 64)
|
|
return v
|
|
}
|
|
}
|
|
|
|
// checkJsonAndUnmarshalUseNumber checks if given `any` is JSON formatted string value and does converting using `json.UnmarshalUseNumber`.
|
|
func checkJsonAndUnmarshalUseNumber(any interface{}, target interface{}) bool {
|
|
switch r := any.(type) {
|
|
case []byte:
|
|
if json.Valid(r) {
|
|
_ = json.UnmarshalUseNumber(r, &target)
|
|
return true
|
|
}
|
|
|
|
case string:
|
|
anyAsBytes := []byte(r)
|
|
if json.Valid(anyAsBytes) {
|
|
_ = json.UnmarshalUseNumber(anyAsBytes, &target)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|