struct.go 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512
  1. // Copyright 2014 Unknwon
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License"): you may
  4. // not use this file except in compliance with the License. You may obtain
  5. // a copy of the License at
  6. //
  7. // http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11. // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12. // License for the specific language governing permissions and limitations
  13. // under the License.
  14. package ini
  15. import (
  16. "bytes"
  17. "errors"
  18. "fmt"
  19. "reflect"
  20. "strings"
  21. "time"
  22. "unicode"
  23. )
  24. // NameMapper represents a ini tag name mapper.
  25. type NameMapper func(string) string
  26. // Built-in name getters.
  27. var (
  28. // AllCapsUnderscore converts to format ALL_CAPS_UNDERSCORE.
  29. AllCapsUnderscore NameMapper = func(raw string) string {
  30. newstr := make([]rune, 0, len(raw))
  31. for i, chr := range raw {
  32. if isUpper := 'A' <= chr && chr <= 'Z'; isUpper {
  33. if i > 0 {
  34. newstr = append(newstr, '_')
  35. }
  36. }
  37. newstr = append(newstr, unicode.ToUpper(chr))
  38. }
  39. return string(newstr)
  40. }
  41. // TitleUnderscore converts to format title_underscore.
  42. TitleUnderscore NameMapper = func(raw string) string {
  43. newstr := make([]rune, 0, len(raw))
  44. for i, chr := range raw {
  45. if isUpper := 'A' <= chr && chr <= 'Z'; isUpper {
  46. if i > 0 {
  47. newstr = append(newstr, '_')
  48. }
  49. chr -= ('A' - 'a')
  50. }
  51. newstr = append(newstr, chr)
  52. }
  53. return string(newstr)
  54. }
  55. )
  56. func (s *Section) parseFieldName(raw, actual string) string {
  57. if len(actual) > 0 {
  58. return actual
  59. }
  60. if s.f.NameMapper != nil {
  61. return s.f.NameMapper(raw)
  62. }
  63. return raw
  64. }
  65. func parseDelim(actual string) string {
  66. if len(actual) > 0 {
  67. return actual
  68. }
  69. return ","
  70. }
  71. var reflectTime = reflect.TypeOf(time.Now()).Kind()
  72. // setSliceWithProperType sets proper values to slice based on its type.
  73. func setSliceWithProperType(key *Key, field reflect.Value, delim string, allowShadow, isStrict bool) error {
  74. var strs []string
  75. if allowShadow {
  76. strs = key.StringsWithShadows(delim)
  77. } else {
  78. strs = key.Strings(delim)
  79. }
  80. numVals := len(strs)
  81. if numVals == 0 {
  82. return nil
  83. }
  84. var vals interface{}
  85. var err error
  86. sliceOf := field.Type().Elem().Kind()
  87. switch sliceOf {
  88. case reflect.String:
  89. vals = strs
  90. case reflect.Int:
  91. vals, err = key.parseInts(strs, true, false)
  92. case reflect.Int64:
  93. vals, err = key.parseInt64s(strs, true, false)
  94. case reflect.Uint:
  95. vals, err = key.parseUints(strs, true, false)
  96. case reflect.Uint64:
  97. vals, err = key.parseUint64s(strs, true, false)
  98. case reflect.Float64:
  99. vals, err = key.parseFloat64s(strs, true, false)
  100. case reflectTime:
  101. vals, err = key.parseTimesFormat(time.RFC3339, strs, true, false)
  102. default:
  103. return fmt.Errorf("unsupported type '[]%s'", sliceOf)
  104. }
  105. if err != nil && isStrict {
  106. return err
  107. }
  108. slice := reflect.MakeSlice(field.Type(), numVals, numVals)
  109. for i := 0; i < numVals; i++ {
  110. switch sliceOf {
  111. case reflect.String:
  112. slice.Index(i).Set(reflect.ValueOf(vals.([]string)[i]))
  113. case reflect.Int:
  114. slice.Index(i).Set(reflect.ValueOf(vals.([]int)[i]))
  115. case reflect.Int64:
  116. slice.Index(i).Set(reflect.ValueOf(vals.([]int64)[i]))
  117. case reflect.Uint:
  118. slice.Index(i).Set(reflect.ValueOf(vals.([]uint)[i]))
  119. case reflect.Uint64:
  120. slice.Index(i).Set(reflect.ValueOf(vals.([]uint64)[i]))
  121. case reflect.Float64:
  122. slice.Index(i).Set(reflect.ValueOf(vals.([]float64)[i]))
  123. case reflectTime:
  124. slice.Index(i).Set(reflect.ValueOf(vals.([]time.Time)[i]))
  125. }
  126. }
  127. field.Set(slice)
  128. return nil
  129. }
  130. func wrapStrictError(err error, isStrict bool) error {
  131. if isStrict {
  132. return err
  133. }
  134. return nil
  135. }
  136. // setWithProperType sets proper value to field based on its type,
  137. // but it does not return error for failing parsing,
  138. // because we want to use default value that is already assigned to strcut.
  139. func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string, allowShadow, isStrict bool) error {
  140. switch t.Kind() {
  141. case reflect.String:
  142. if len(key.String()) == 0 {
  143. return nil
  144. }
  145. field.SetString(key.String())
  146. case reflect.Bool:
  147. boolVal, err := key.Bool()
  148. if err != nil {
  149. return wrapStrictError(err, isStrict)
  150. }
  151. field.SetBool(boolVal)
  152. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  153. durationVal, err := key.Duration()
  154. // Skip zero value
  155. if err == nil && int64(durationVal) > 0 {
  156. field.Set(reflect.ValueOf(durationVal))
  157. return nil
  158. }
  159. intVal, err := key.Int64()
  160. if err != nil {
  161. return wrapStrictError(err, isStrict)
  162. }
  163. field.SetInt(intVal)
  164. // byte is an alias for uint8, so supporting uint8 breaks support for byte
  165. case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  166. durationVal, err := key.Duration()
  167. // Skip zero value
  168. if err == nil && int(durationVal) > 0 {
  169. field.Set(reflect.ValueOf(durationVal))
  170. return nil
  171. }
  172. uintVal, err := key.Uint64()
  173. if err != nil {
  174. return wrapStrictError(err, isStrict)
  175. }
  176. field.SetUint(uintVal)
  177. case reflect.Float32, reflect.Float64:
  178. floatVal, err := key.Float64()
  179. if err != nil {
  180. return wrapStrictError(err, isStrict)
  181. }
  182. field.SetFloat(floatVal)
  183. case reflectTime:
  184. timeVal, err := key.Time()
  185. if err != nil {
  186. return wrapStrictError(err, isStrict)
  187. }
  188. field.Set(reflect.ValueOf(timeVal))
  189. case reflect.Slice:
  190. return setSliceWithProperType(key, field, delim, allowShadow, isStrict)
  191. default:
  192. return fmt.Errorf("unsupported type '%s'", t)
  193. }
  194. return nil
  195. }
  196. func parseTagOptions(tag string) (rawName string, omitEmpty bool, allowShadow bool) {
  197. opts := strings.SplitN(tag, ",", 3)
  198. rawName = opts[0]
  199. if len(opts) > 1 {
  200. omitEmpty = opts[1] == "omitempty"
  201. }
  202. if len(opts) > 2 {
  203. allowShadow = opts[2] == "allowshadow"
  204. }
  205. return rawName, omitEmpty, allowShadow
  206. }
  207. func (s *Section) mapTo(val reflect.Value, isStrict bool) error {
  208. if val.Kind() == reflect.Ptr {
  209. val = val.Elem()
  210. }
  211. typ := val.Type()
  212. for i := 0; i < typ.NumField(); i++ {
  213. field := val.Field(i)
  214. tpField := typ.Field(i)
  215. tag := tpField.Tag.Get("ini")
  216. if tag == "-" {
  217. continue
  218. }
  219. rawName, _, allowShadow := parseTagOptions(tag)
  220. fieldName := s.parseFieldName(tpField.Name, rawName)
  221. if len(fieldName) == 0 || !field.CanSet() {
  222. continue
  223. }
  224. isAnonymous := tpField.Type.Kind() == reflect.Ptr && tpField.Anonymous
  225. isStruct := tpField.Type.Kind() == reflect.Struct
  226. if isAnonymous {
  227. field.Set(reflect.New(tpField.Type.Elem()))
  228. }
  229. if isAnonymous || isStruct {
  230. if sec, err := s.f.GetSection(fieldName); err == nil {
  231. if err = sec.mapTo(field, isStrict); err != nil {
  232. return fmt.Errorf("error mapping field(%s): %v", fieldName, err)
  233. }
  234. continue
  235. }
  236. }
  237. if key, err := s.GetKey(fieldName); err == nil {
  238. delim := parseDelim(tpField.Tag.Get("delim"))
  239. if err = setWithProperType(tpField.Type, key, field, delim, allowShadow, isStrict); err != nil {
  240. return fmt.Errorf("error mapping field(%s): %v", fieldName, err)
  241. }
  242. }
  243. }
  244. return nil
  245. }
  246. // MapTo maps section to given struct.
  247. func (s *Section) MapTo(v interface{}) error {
  248. typ := reflect.TypeOf(v)
  249. val := reflect.ValueOf(v)
  250. if typ.Kind() == reflect.Ptr {
  251. typ = typ.Elem()
  252. val = val.Elem()
  253. } else {
  254. return errors.New("cannot map to non-pointer struct")
  255. }
  256. return s.mapTo(val, false)
  257. }
  258. // MapTo maps section to given struct in strict mode,
  259. // which returns all possible error including value parsing error.
  260. func (s *Section) StrictMapTo(v interface{}) error {
  261. typ := reflect.TypeOf(v)
  262. val := reflect.ValueOf(v)
  263. if typ.Kind() == reflect.Ptr {
  264. typ = typ.Elem()
  265. val = val.Elem()
  266. } else {
  267. return errors.New("cannot map to non-pointer struct")
  268. }
  269. return s.mapTo(val, true)
  270. }
  271. // MapTo maps file to given struct.
  272. func (f *File) MapTo(v interface{}) error {
  273. return f.Section("").MapTo(v)
  274. }
  275. // MapTo maps file to given struct in strict mode,
  276. // which returns all possible error including value parsing error.
  277. func (f *File) StrictMapTo(v interface{}) error {
  278. return f.Section("").StrictMapTo(v)
  279. }
  280. // MapTo maps data sources to given struct with name mapper.
  281. func MapToWithMapper(v interface{}, mapper NameMapper, source interface{}, others ...interface{}) error {
  282. cfg, err := Load(source, others...)
  283. if err != nil {
  284. return err
  285. }
  286. cfg.NameMapper = mapper
  287. return cfg.MapTo(v)
  288. }
  289. // StrictMapToWithMapper maps data sources to given struct with name mapper in strict mode,
  290. // which returns all possible error including value parsing error.
  291. func StrictMapToWithMapper(v interface{}, mapper NameMapper, source interface{}, others ...interface{}) error {
  292. cfg, err := Load(source, others...)
  293. if err != nil {
  294. return err
  295. }
  296. cfg.NameMapper = mapper
  297. return cfg.StrictMapTo(v)
  298. }
  299. // MapTo maps data sources to given struct.
  300. func MapTo(v, source interface{}, others ...interface{}) error {
  301. return MapToWithMapper(v, nil, source, others...)
  302. }
  303. // StrictMapTo maps data sources to given struct in strict mode,
  304. // which returns all possible error including value parsing error.
  305. func StrictMapTo(v, source interface{}, others ...interface{}) error {
  306. return StrictMapToWithMapper(v, nil, source, others...)
  307. }
  308. // reflectSliceWithProperType does the opposite thing as setSliceWithProperType.
  309. func reflectSliceWithProperType(key *Key, field reflect.Value, delim string) error {
  310. slice := field.Slice(0, field.Len())
  311. if field.Len() == 0 {
  312. return nil
  313. }
  314. var buf bytes.Buffer
  315. sliceOf := field.Type().Elem().Kind()
  316. for i := 0; i < field.Len(); i++ {
  317. switch sliceOf {
  318. case reflect.String:
  319. buf.WriteString(slice.Index(i).String())
  320. case reflect.Int, reflect.Int64:
  321. buf.WriteString(fmt.Sprint(slice.Index(i).Int()))
  322. case reflect.Uint, reflect.Uint64:
  323. buf.WriteString(fmt.Sprint(slice.Index(i).Uint()))
  324. case reflect.Float64:
  325. buf.WriteString(fmt.Sprint(slice.Index(i).Float()))
  326. case reflectTime:
  327. buf.WriteString(slice.Index(i).Interface().(time.Time).Format(time.RFC3339))
  328. default:
  329. return fmt.Errorf("unsupported type '[]%s'", sliceOf)
  330. }
  331. buf.WriteString(delim)
  332. }
  333. key.SetValue(buf.String()[:buf.Len()-1])
  334. return nil
  335. }
  336. // reflectWithProperType does the opposite thing as setWithProperType.
  337. func reflectWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error {
  338. switch t.Kind() {
  339. case reflect.String:
  340. key.SetValue(field.String())
  341. case reflect.Bool:
  342. key.SetValue(fmt.Sprint(field.Bool()))
  343. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  344. key.SetValue(fmt.Sprint(field.Int()))
  345. case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  346. key.SetValue(fmt.Sprint(field.Uint()))
  347. case reflect.Float32, reflect.Float64:
  348. key.SetValue(fmt.Sprint(field.Float()))
  349. case reflectTime:
  350. key.SetValue(fmt.Sprint(field.Interface().(time.Time).Format(time.RFC3339)))
  351. case reflect.Slice:
  352. return reflectSliceWithProperType(key, field, delim)
  353. default:
  354. return fmt.Errorf("unsupported type '%s'", t)
  355. }
  356. return nil
  357. }
  358. // CR: copied from encoding/json/encode.go with modifications of time.Time support.
  359. // TODO: add more test coverage.
  360. func isEmptyValue(v reflect.Value) bool {
  361. switch v.Kind() {
  362. case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
  363. return v.Len() == 0
  364. case reflect.Bool:
  365. return !v.Bool()
  366. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  367. return v.Int() == 0
  368. case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  369. return v.Uint() == 0
  370. case reflect.Float32, reflect.Float64:
  371. return v.Float() == 0
  372. case reflect.Interface, reflect.Ptr:
  373. return v.IsNil()
  374. case reflectTime:
  375. t, ok := v.Interface().(time.Time)
  376. return ok && t.IsZero()
  377. }
  378. return false
  379. }
  380. func (s *Section) reflectFrom(val reflect.Value) error {
  381. if val.Kind() == reflect.Ptr {
  382. val = val.Elem()
  383. }
  384. typ := val.Type()
  385. for i := 0; i < typ.NumField(); i++ {
  386. field := val.Field(i)
  387. tpField := typ.Field(i)
  388. tag := tpField.Tag.Get("ini")
  389. if tag == "-" {
  390. continue
  391. }
  392. opts := strings.SplitN(tag, ",", 2)
  393. if len(opts) == 2 && opts[1] == "omitempty" && isEmptyValue(field) {
  394. continue
  395. }
  396. fieldName := s.parseFieldName(tpField.Name, opts[0])
  397. if len(fieldName) == 0 || !field.CanSet() {
  398. continue
  399. }
  400. if (tpField.Type.Kind() == reflect.Ptr && tpField.Anonymous) ||
  401. (tpField.Type.Kind() == reflect.Struct && tpField.Type.Name() != "Time") {
  402. // Note: The only error here is section doesn't exist.
  403. sec, err := s.f.GetSection(fieldName)
  404. if err != nil {
  405. // Note: fieldName can never be empty here, ignore error.
  406. sec, _ = s.f.NewSection(fieldName)
  407. }
  408. // Add comment from comment tag
  409. if len(sec.Comment) == 0 {
  410. sec.Comment = tpField.Tag.Get("comment")
  411. }
  412. if err = sec.reflectFrom(field); err != nil {
  413. return fmt.Errorf("error reflecting field (%s): %v", fieldName, err)
  414. }
  415. continue
  416. }
  417. // Note: Same reason as secion.
  418. key, err := s.GetKey(fieldName)
  419. if err != nil {
  420. key, _ = s.NewKey(fieldName, "")
  421. }
  422. // Add comment from comment tag
  423. if len(key.Comment) == 0 {
  424. key.Comment = tpField.Tag.Get("comment")
  425. }
  426. if err = reflectWithProperType(tpField.Type, key, field, parseDelim(tpField.Tag.Get("delim"))); err != nil {
  427. return fmt.Errorf("error reflecting field (%s): %v", fieldName, err)
  428. }
  429. }
  430. return nil
  431. }
  432. // ReflectFrom reflects secion from given struct.
  433. func (s *Section) ReflectFrom(v interface{}) error {
  434. typ := reflect.TypeOf(v)
  435. val := reflect.ValueOf(v)
  436. if typ.Kind() == reflect.Ptr {
  437. typ = typ.Elem()
  438. val = val.Elem()
  439. } else {
  440. return errors.New("cannot reflect from non-pointer struct")
  441. }
  442. return s.reflectFrom(val)
  443. }
  444. // ReflectFrom reflects file from given struct.
  445. func (f *File) ReflectFrom(v interface{}) error {
  446. return f.Section("").ReflectFrom(v)
  447. }
  448. // ReflectFrom reflects data sources from given struct with name mapper.
  449. func ReflectFromWithMapper(cfg *File, v interface{}, mapper NameMapper) error {
  450. cfg.NameMapper = mapper
  451. return cfg.ReflectFrom(v)
  452. }
  453. // ReflectFrom reflects data sources from given struct.
  454. func ReflectFrom(cfg *File, v interface{}) error {
  455. return ReflectFromWithMapper(cfg, v, nil)
  456. }