267 lines
6.3 KiB
Go
267 lines
6.3 KiB
Go
// +-------------------------------------------------------------------------
|
|
// | Copyright (C) 2016 Yunify, Inc.
|
|
// +-------------------------------------------------------------------------
|
|
// | Licensed under the Apache License, Version 2.0 (the "License");
|
|
// | you may not use this work except in compliance with the License.
|
|
// | You may obtain a copy of the License in the LICENSE file, or at:
|
|
// |
|
|
// | http://www.apache.org/licenses/LICENSE-2.0
|
|
// |
|
|
// | Unless required by applicable law or agreed to in writing, software
|
|
// | distributed under the License is distributed on an "AS IS" BASIS,
|
|
// | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// | See the License for the specific language governing permissions and
|
|
// | limitations under the License.
|
|
// +-------------------------------------------------------------------------
|
|
|
|
package service
|
|
|
|
import (
|
|
"time"
|
|
)
|
|
|
|
// String returns a pointer to the given string value.
|
|
func String(v string) *string {
|
|
return &v
|
|
}
|
|
|
|
// StringValue returns the value of the given string pointer or
|
|
// "" if the pointer is nil.
|
|
func StringValue(v *string) string {
|
|
if v != nil {
|
|
return *v
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// StringSlice converts a slice of string values into a slice of
|
|
// string pointers
|
|
func StringSlice(src []string) []*string {
|
|
dst := make([]*string, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
dst[i] = &(src[i])
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// StringValueSlice converts a slice of string pointers into a slice of
|
|
// string values
|
|
func StringValueSlice(src []*string) []string {
|
|
dst := make([]string, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
if src[i] != nil {
|
|
dst[i] = *(src[i])
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// StringMap converts a string map of string values into a string
|
|
// map of string pointers
|
|
func StringMap(src map[string]string) map[string]*string {
|
|
dst := make(map[string]*string)
|
|
for k, val := range src {
|
|
v := val
|
|
dst[k] = &v
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// StringValueMap converts a string map of string pointers into a string
|
|
// map of string values
|
|
func StringValueMap(src map[string]*string) map[string]string {
|
|
dst := make(map[string]string)
|
|
for k, val := range src {
|
|
if val != nil {
|
|
dst[k] = *val
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// Bool returns a pointer to the given bool value.
|
|
func Bool(v bool) *bool {
|
|
return &v
|
|
}
|
|
|
|
// BoolValue returns the value of the given bool pointer or
|
|
// false if the pointer is nil.
|
|
func BoolValue(v *bool) bool {
|
|
if v != nil {
|
|
return *v
|
|
}
|
|
return false
|
|
}
|
|
|
|
// BoolSlice converts a slice of bool values into a slice of
|
|
// bool pointers
|
|
func BoolSlice(src []bool) []*bool {
|
|
dst := make([]*bool, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
dst[i] = &(src[i])
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// BoolValueSlice converts a slice of bool pointers into a slice of
|
|
// bool values
|
|
func BoolValueSlice(src []*bool) []bool {
|
|
dst := make([]bool, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
if src[i] != nil {
|
|
dst[i] = *(src[i])
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// BoolMap converts a string map of bool values into a string
|
|
// map of bool pointers
|
|
func BoolMap(src map[string]bool) map[string]*bool {
|
|
dst := make(map[string]*bool)
|
|
for k, val := range src {
|
|
v := val
|
|
dst[k] = &v
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// BoolValueMap converts a string map of bool pointers into a string
|
|
// map of bool values
|
|
func BoolValueMap(src map[string]*bool) map[string]bool {
|
|
dst := make(map[string]bool)
|
|
for k, val := range src {
|
|
if val != nil {
|
|
dst[k] = *val
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// Int returns a pointer to the given int value.
|
|
func Int(v int) *int {
|
|
return &v
|
|
}
|
|
|
|
// IntValue returns the value of the given int pointer or
|
|
// 0 if the pointer is nil.
|
|
func IntValue(v *int) int {
|
|
if v != nil {
|
|
return *v
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// IntSlice converts a slice of int values into a slice of
|
|
// int pointers
|
|
func IntSlice(src []int) []*int {
|
|
dst := make([]*int, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
dst[i] = &(src[i])
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// IntValueSlice converts a slice of int pointers into a slice of
|
|
// int values
|
|
func IntValueSlice(src []*int) []int {
|
|
dst := make([]int, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
if src[i] != nil {
|
|
dst[i] = *(src[i])
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// IntMap converts a string map of int values into a string
|
|
// map of int pointers
|
|
func IntMap(src map[string]int) map[string]*int {
|
|
dst := make(map[string]*int)
|
|
for k, val := range src {
|
|
v := val
|
|
dst[k] = &v
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// IntValueMap converts a string map of int pointers into a string
|
|
// map of int values
|
|
func IntValueMap(src map[string]*int) map[string]int {
|
|
dst := make(map[string]int)
|
|
for k, val := range src {
|
|
if val != nil {
|
|
dst[k] = *val
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// Time returns a pointer to the given time.Time value.
|
|
func Time(v time.Time) *time.Time {
|
|
return &v
|
|
}
|
|
|
|
// TimeValue returns the value of the given time.Time pointer or
|
|
// time.Time{} if the pointer is nil.
|
|
func TimeValue(v *time.Time) time.Time {
|
|
if v != nil {
|
|
return *v
|
|
}
|
|
return time.Time{}
|
|
}
|
|
|
|
// TimeUnixMilli returns a Unix timestamp in milliseconds from "January 1, 1970 UTC".
|
|
// The result is undefined if the Unix time cannot be represented by an int64.
|
|
// Which includes calling TimeUnixMilli on a zero Time is undefined.
|
|
//
|
|
// See Go stdlib https://golang.org/pkg/time/#Time.UnixNano for more information.
|
|
func TimeUnixMilli(t time.Time) int64 {
|
|
return t.UnixNano() / int64(time.Millisecond/time.Nanosecond)
|
|
}
|
|
|
|
// TimeSlice converts a slice of time.Time values into a slice of
|
|
// time.Time pointers
|
|
func TimeSlice(src []time.Time) []*time.Time {
|
|
dst := make([]*time.Time, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
dst[i] = &(src[i])
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// TimeValueSlice converts a slice of time.Time pointers into a slice of
|
|
// time.Time values
|
|
func TimeValueSlice(src []*time.Time) []time.Time {
|
|
dst := make([]time.Time, len(src))
|
|
for i := 0; i < len(src); i++ {
|
|
if src[i] != nil {
|
|
dst[i] = *(src[i])
|
|
}
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// TimeMap converts a string map of time.Time values into a string
|
|
// map of time.Time pointers
|
|
func TimeMap(src map[string]time.Time) map[string]*time.Time {
|
|
dst := make(map[string]*time.Time)
|
|
for k, val := range src {
|
|
v := val
|
|
dst[k] = &v
|
|
}
|
|
return dst
|
|
}
|
|
|
|
// TimeValueMap converts a string map of time.Time pointers into a string
|
|
// map of time.Time values
|
|
func TimeValueMap(src map[string]*time.Time) map[string]time.Time {
|
|
dst := make(map[string]time.Time)
|
|
for k, val := range src {
|
|
if val != nil {
|
|
dst[k] = *val
|
|
}
|
|
}
|
|
return dst
|
|
}
|