Golang cast.ToString函数代码示例

func (p *Page) getParam(key string, stringToLower bool) interface{} {
	v := p.Params[strings.ToLower(key)]

	if v == nil {
		return nil
	}

	switch v.(type) {
	case bool:
		return cast.ToBool(v)
	case string:
		if stringToLower {
			return strings.ToLower(cast.ToString(v))
		}
		return cast.ToString(v)
	case int64, int32, int16, int8, int:
		return cast.ToInt(v)
	case float64, float32:
		return cast.ToFloat64(v)
	case time.Time:
		return cast.ToTime(v)
	case []string:
		if stringToLower {
			return helpers.SliceToLower(v.([]string))
		}
		return v.([]string)
	case map[string]interface{}: // JSON and TOML
		return v
	case map[interface{}]interface{}: // YAML
		return v
	}

	jww.ERROR.Printf("GetParam(\"%s\"): Unknown type %s\n", key, reflect.TypeOf(v))
	return nil
}

func toSortedLanguages(l map[string]interface{}) (helpers.Languages, error) {
	langs := make(helpers.Languages, len(l))
	i := 0

	for lang, langConf := range l {
		langsMap, err := cast.ToStringMapE(langConf)

		if err != nil {
			return nil, fmt.Errorf("Language config is not a map: %T", langConf)
		}

		language := helpers.NewLanguage(lang)

		for loki, v := range langsMap {
			switch loki {
			case "title":
				language.Title = cast.ToString(v)
			case "languagename":
				language.LanguageName = cast.ToString(v)
			case "weight":
				language.Weight = cast.ToInt(v)
			}

			// Put all into the Params map
			language.SetParam(loki, v)
		}

		langs[i] = language
		i++
	}

	sort.Sort(langs)

	return langs, nil
}

// GetConfig return configuration instance
func GetConfig() Config {
	config := Config{
		LinguaLeo: linguaLeo{
			Email:    cast.ToString(viper.Get("lingualeo.email")),
			Password: cast.ToString(viper.Get("lingualeo.password")),
		},
	}
	return config
}

func (rs *SortableRowSet) IsLess(origin *TableRow, than *TableRow) bool {
	for _, val := range rs.cols {
		if val.Orderable && val.Order != ORDER_UNDEFINED {
			if res := strings.Compare(cast.ToString(origin.Data[val.Name]), cast.ToString(than.Data[val.Name])); res != 0 {
				if val.Order == ORDER_DESC {
					return res == -1
				} else {
					return res == 1
				}
			}
		}
	}
	//no ordering provided, base on string pointers
	return strings.Compare(fmt.Sprintf("%p", origin.Data), fmt.Sprintf("%p", than.Data)) == -1
}

func parseOrdering(formValues map[string]interface{}) map[string]DataTableOrder {
	ordering := map[string]DataTableOrder{}
	if orders, ok := formValues["order"]; ok {
		for _, val := range orders.(map[string]interface{}) {
			mapValue := val.(map[string]interface{})
			column, columnExists := mapValue["column"]
			dir, dirExists := mapValue["dir"]
			if columnExists && dirExists {
				ordering[cast.ToString(column)] = DataTableOrder(cast.ToString(dir))
			}
		}
	}

	return ordering
}

func (me *MenuEntry) MarshallMap(ime map[string]interface{}) {
	for k, v := range ime {
		loki := strings.ToLower(k)
		switch loki {
		case "url":
			me.Url = cast.ToString(v)
		case "weight":
			me.Weight = cast.ToInt(v)
		case "name":
			me.Name = cast.ToString(v)
		case "parent":
			me.Parent = cast.ToString(v)
		}
	}
}

// Get returns an interface..
// Must be typecast or used by something that will typecast
func (manager *Config) Get(key string) interface{} {
	jww.TRACE.Println("Looking for", key)

	v := manager.Find(key)

	if v == nil {
		return nil
	}

	jww.TRACE.Println("Found value", v)
	switch v.(type) {
	case bool:
		return cast.ToBool(v)
	case string:
		return cast.ToString(v)
	case int64, int32, int16, int8, int:
		return cast.ToInt(v)
	case float64, float32:
		return cast.ToFloat64(v)
	case time.Time:
		return cast.ToTime(v)
	case []string:
		return v
	}
	return v
}

func (v *Viper) Get(key string) interface{} {
	key = strings.ToLower(key)
	val := v.find(key)

	if val == nil {
		return nil
	}

	switch val.(type) {
	case bool:
		return cast.ToBool(val)
	case string:
		return cast.ToString(val)
	case int64, int32, int16, int8, int:
		return cast.ToInt(val)
	case float64, float32:
		return cast.ToFloat64(val)
	case time.Time:
		return cast.ToTime(val)
	case time.Duration:
		return cast.ToDuration(val)
	case []string:
		return val
	}
	return val
}

func (ds *DefaultStore) FilterRow(row *TableRow, filter *SearchDefinition, rowSet RowSet) bool {
	if row == nil || len(row.Data) == 0 {
		return false
	}
	foundGlobally := true
	for name, value := range row.Data {
		strValue := cast.ToString(value)

		if filter.IsApplicable() {
			if filter.IsMatch(strValue) {
				return true
			} else {
				foundGlobally = false
			}
		}

		if col := rowSet.ColumnByName(name); col != nil {
			if col.Searchable && col.Search.IsApplicable() {
				if !col.Search.IsMatch(strValue) {
					return false
				}
			}
		}
	}

	return foundGlobally
}

func (v *Viper) Get(key string) interface{} {
	lcaseKey := strings.ToLower(key)
	val := v.find(lcaseKey)
	if val == nil {
		return nil
	}

	valType := val
	if v.typeByDefValue {
		// TODO(bep) this branch isn't covered by a single test.
		path := strings.Split(lcaseKey, v.keyDelim)
		defVal := v.searchMap(v.defaults, path)
		if defVal != nil {
			valType = defVal
		}
	}

	switch valType.(type) {
	case bool:
		return cast.ToBool(val)
	case string:
		return cast.ToString(val)
	case int64, int32, int16, int8, int:
		return cast.ToInt(val)
	case float64, float32:
		return cast.ToFloat64(val)
	case time.Time:
		return cast.ToTime(val)
	case time.Duration:
		return cast.ToDuration(val)
	case []string:
		return cast.ToStringSlice(val)
	}
	return val
}

// markdownify renders a given string from Markdown to HTML.
func markdownify(in interface{}) template.HTML {
	text := cast.ToString(in)
	m := helpers.RenderBytes(&helpers.RenderingContext{Content: []byte(text), PageFmt: "markdown"})
	m = bytes.TrimPrefix(m, markdownTrimPrefix)
	m = bytes.TrimSuffix(m, markdownTrimSuffix)
	return template.HTML(m)
}

func (c *Conf) AutoRepair() {
	fullUriPattern, _ := regexp.Compile("(http[s]{0,1})://([^/:]+):?([0-9]{0,}).*")
	if !fullUriPattern.MatchString(c.EndpointURI) {
		protocol := "https"
		host := getDefaultHostName()
		port := cast.ToString(c.ServerPort)
		hostWithPortPattern, _ := regexp.Compile("([^:/]+):?([0-9]{0,})")
		repaired := false

		if hostWithPortPattern.MatchString(c.EndpointURI) {
			matches := hostWithPortPattern.FindAllStringSubmatch(c.EndpointURI, -1)
			if val := matches[0][1]; val != "" {
				host = val
			}
			if val := matches[0][2]; val != "" {
				port = val
			}
			repaired = true
		}

		if repaired {
			c.EndpointURI = fmt.Sprintf("%s://%s:%s/", protocol, host, port)
			log.Printf("EndpointURI successfully reparied to: %s", c.EndpointURI)
		}
	}
}

func (c *Config) loadRedirects(seq sequence) {
	// if seq.valForKey("redirects") != "" {
	// 	panic("Configuration error: redirects should be a list of paths and destinations")
	// }
	// TODO: assert right content types (not string val, not value sequence)
	c.redirects = make(map[string]string)
	for _, el := range seq.seqForKey("redirects") {
		path := cast.ToString(el.key)
		dest := cast.ToString(el.value)
		if strings.HasPrefix(path, "/") {
			c.redirects[path[1:]] = dest
		} else {
			c.redirects[path] = dest
		}
	}
}

func (c *Config) loadS3Bucket(seq sequence) {
	val := cast.ToString(seq.valForKey("s3_bucket"))
	if val == "" {
		panic("Configuration error: s3_bucket is missing")
	}
	c.S3Bucket = val
}

func (c *Config) loadS3Region(seq sequence) {
	val := cast.ToString(seq.valForKey("s3_region"))
	if val == "" {
		val = s3RegionDefault
	}
	c.S3Region = val
}