vendor/github.com/go-playground/locales/ksf/ksf.go

   1 package ksf
   2
   3 import (
   4         "math"
   5         "strconv"
   6         "time"
   7
   8         "github.com/go-playground/locales"
   9         "github.com/go-playground/locales/currency"
  10 )
  11
  12 type ksf struct {
  13         locale                 string
  14         pluralsCardinal        []locales.PluralRule
  15         pluralsOrdinal         []locales.PluralRule
  16         pluralsRange           []locales.PluralRule
  17         decimal                string
  18         group                  string
  19         minus                  string
  20         percent                string
  21         perMille               string
  22         timeSeparator          string
  23         inifinity              string
  24         currencies             []string // idx = enum of currency code
  25         currencyPositiveSuffix string
  26         currencyNegativeSuffix string
  27         monthsAbbreviated      []string
  28         monthsNarrow           []string
  29         monthsWide             []string
  30         daysAbbreviated        []string
  31         daysNarrow             []string
  32         daysShort              []string
  33         daysWide               []string
  34         periodsAbbreviated     []string
  35         periodsNarrow          []string
  36         periodsShort           []string
  37         periodsWide            []string
  38         erasAbbreviated        []string
  39         erasNarrow             []string
  40         erasWide               []string
  41         timezones              map[string]string
  42 }
  43
  44 // New returns a new instance of translator for the 'ksf' locale
  45 func New() locales.Translator {
  46         return &ksf{
  47                 locale:                 "ksf",
  48                 pluralsCardinal:        nil,
  49                 pluralsOrdinal:         nil,
  50                 pluralsRange:           nil,
  51                 decimal:                ",",
  52                 group:                  " ",
  53                 timeSeparator:          ":",
  54                 currencies:             []string{"ADP", "AED", "AFA", "AFN", "ALK", "ALL", "AMD", "ANG", "AOA", "AOK", "AON", "AOR", "ARA", "ARL", "ARM", "ARP", "ARS", "ATS", "AUD", "AWG", "AZM", "AZN", "BAD", "BAM", "BAN", "BBD", "BDT", "BEC", "BEF", "BEL", "BGL", "BGM", "BGN", "BGO", "BHD", "BIF", "BMD", "BND", "BOB", "BOL", "BOP", "BOV", "BRB", "BRC", "BRE", "BRL", "BRN", "BRR", "BRZ", "BSD", "BTN", "BUK", "BWP", "BYB", "BYN", "BYR", "BZD", "CAD", "CDF", "CHE", "CHF", "CHW", "CLE", "CLF", "CLP", "CNX", "CNY", "COP", "COU", "CRC", "CSD", "CSK", "CUC", "CUP", "CVE", "CYP", "CZK", "DDM", "DEM", "DJF", "DKK", "DOP", "DZD", "ECS", "ECV", "EEK", "EGP", "ERN", "ESA", "ESB", "ESP", "ETB", "EUR", "FIM", "FJD", "FKP", "FRF", "GBP", "GEK", "GEL", "GHC", "GHS", "GIP", "GMD", "GNF", "GNS", "GQE", "GRD", "GTQ", "GWE", "GWP", "GYD", "HKD", "HNL", "HRD", "HRK", "HTG", "HUF", "IDR", "IEP", "ILP", "ILR", "ILS", "INR", "IQD", "IRR", "ISJ", "ISK", "ITL", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRH", "KRO", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LTL", "LTT", "LUC", "LUF", "LUL", "LVL", "LVR", "LYD", "MAD", "MAF", "MCF", "MDC", "MDL", "MGA", "MGF", "MKD", "MKN", "MLF", "MMK", "MNT", "MOP", "MRO", "MTL", "MTP", "MUR", "MVP", "MVR", "MWK", "MXN", "MXP", "MXV", "MYR", "MZE", "MZM", "MZN", "NAD", "NGN", "NIC", "NIO", "NLG", "NOK", "NPR", "NZD", "OMR", "PAB", "PEI", "PEN", "PES", "PGK", "PHP", "PKR", "PLN", "PLZ", "PTE", "PYG", "QAR", "RHD", "ROL", "RON", "RSD", "RUB", "RUR", "RWF", "SAR", "SBD", "SCR", "SDD", "SDG", "SDP", "SEK", "SGD", "SHP", "SIT", "SKK", "SLL", "SOS", "SRD", "SRG", "SSP", "STD", "SUR", "SVC", "SYP", "SZL", "THB", "TJR", "TJS", "TMM", "TMT", "TND", "TOP", "TPE", "TRL", "TRY", "TTD", "TWD", "TZS", "UAH", "UAK", "UGS", "UGX", "USD", "USN", "USS", "UYI", "UYP", "UYU", "UZS", "VEB", "VEF", "VND", "VNN", "VUV", "WST", "XAF", "XAG", "XAU", "XBA", "XBB", "XBC", "XBD", "XCD", "XDR", "XEU", "XFO", "XFU", "XOF", "XPD", "XPF", "XPT", "XRE", "XSU", "XTS", "XUA", "XXX", "YDD", "YER", "YUD", "YUM", "YUN", "YUR", "ZAL", "ZAR", "ZMK", "ZMW", "ZRN", "ZRZ", "ZWD", "ZWL", "ZWR"},
  55                 currencyPositiveSuffix: " ",
  56                 currencyNegativeSuffix: " ",
  57                 monthsAbbreviated:      []string{"", "ŋ1", "ŋ2", "ŋ3", "ŋ4", "ŋ5", "ŋ6", "ŋ7", "ŋ8", "ŋ9", "ŋ10", "ŋ11", "ŋ12"},
  58                 monthsWide:             []string{"", "ŋwíí a ntɔ́ntɔ", "ŋwíí akǝ bɛ́ɛ", "ŋwíí akǝ ráá", "ŋwíí akǝ nin", "ŋwíí akǝ táan", "ŋwíí akǝ táafɔk", "ŋwíí akǝ táabɛɛ", "ŋwíí akǝ táaraa", "ŋwíí akǝ táanin", "ŋwíí akǝ ntɛk", "ŋwíí akǝ ntɛk di bɔ́k", "ŋwíí akǝ ntɛk di bɛ́ɛ"},
  59                 daysAbbreviated:        []string{"sɔ́n", "lǝn", "maa", "mɛk", "jǝǝ", "júm", "sam"},
  60                 daysNarrow:             []string{"s", "l", "m", "m", "j", "j", "s"},
  61                 daysWide:               []string{"sɔ́ndǝ", "lǝndí", "maadí", "mɛkrɛdí", "jǝǝdí", "júmbá", "samdí"},
  62                 periodsAbbreviated:     []string{"sárúwá", "cɛɛ́nko"},
  63                 periodsWide:            []string{"sárúwá", "cɛɛ́nko"},
  64                 erasAbbreviated:        []string{"d.Y.", "k.Y."},
  65                 erasNarrow:             []string{"", ""},
  66                 erasWide:               []string{"di Yɛ́sus aká yálɛ", "cámɛɛn kǝ kǝbɔpka Y"},
  67                 timezones:              map[string]string{"HKT": "HKT", "WESZ": "WESZ", "HECU": "HECU", "WIB": "WIB", "HNPM": "HNPM", "HENOMX": "HENOMX", "AEST": "AEST", "ARST": "ARST", "AKST": "AKST", "AKDT": "AKDT", "HNNOMX": "HNNOMX", "CLST": "CLST", "ChST": "ChST", "HNPMX": "HNPMX", "TMST": "TMST", "WITA": "WITA", "WAST": "WAST", "COT": "COT", "CAT": "CAT", "PDT": "PDT", "CST": "CST", "ACWST": "ACWST", "NZDT": "NZDT", "AST": "AST", "HEEG": "HEEG", "HKST": "HKST", "WEZ": "WEZ", "LHST": "LHST", "EST": "EST", "GYT": "GYT", "HEPMX": "HEPMX", "EDT": "EDT", "BT": "BT", "AWDT": "AWDT", "MESZ": "MESZ", "NZST": "NZST", "MDT": "MDT", "ADT": "ADT", "CLT": "CLT", "ACDT": "ACDT", "GMT": "GMT", "SRT": "SRT", "MEZ": "MEZ", "OESZ": "OESZ", "MST": "MST", "EAT": "EAT", "ACST": "ACST", "CDT": "CDT", "ACWDT": "ACWDT", "TMT": "TMT", "HNOG": "HNOG", "HAT": "HAT", "PST": "PST", "HNCU": "HNCU", "JDT": "JDT", "WARST": "WARST", "BOT": "BOT", "UYST": "UYST", "JST": "JST", "SAST": "SAST", "COST": "COST", "GFT": "GFT", "CHAST": "CHAST", "VET": "VET", "IST": "IST", "WAT": "WAT", "HEPM": "HEPM", "CHADT": "CHADT", "OEZ": "OEZ", "ART": "ART", "HEOG": "HEOG", "HNEG": "HNEG", "ECT": "ECT", "UYT": "UYT", "WIT": "WIT", "LHDT": "LHDT", "HNT": "HNT", "SGT": "SGT", "AWST": "AWST", "MYT": "MYT", "HAST": "HAST", "HADT": "HADT", "WART": "WART", "∅∅∅": "∅∅∅", "AEDT": "AEDT"},
  68         }
  69 }
  70
  71 // Locale returns the current translators string locale
  72 func (ksf *ksf) Locale() string {
  73         return ksf.locale
  74 }
  75
  76 // PluralsCardinal returns the list of cardinal plural rules associated with 'ksf'
  77 func (ksf *ksf) PluralsCardinal() []locales.PluralRule {
  78         return ksf.pluralsCardinal
  79 }
  80
  81 // PluralsOrdinal returns the list of ordinal plural rules associated with 'ksf'
  82 func (ksf *ksf) PluralsOrdinal() []locales.PluralRule {
  83         return ksf.pluralsOrdinal
  84 }
  85
  86 // PluralsRange returns the list of range plural rules associated with 'ksf'
  87 func (ksf *ksf) PluralsRange() []locales.PluralRule {
  88         return ksf.pluralsRange
  89 }
  90
  91 // CardinalPluralRule returns the cardinal PluralRule given 'num' and digits/precision of 'v' for 'ksf'
  92 func (ksf *ksf) CardinalPluralRule(num float64, v uint64) locales.PluralRule {
  93         return locales.PluralRuleUnknown
  94 }
  95
  96 // OrdinalPluralRule returns the ordinal PluralRule given 'num' and digits/precision of 'v' for 'ksf'
  97 func (ksf *ksf) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
  98         return locales.PluralRuleUnknown
  99 }
 100
 101 // RangePluralRule returns the ordinal PluralRule given 'num1', 'num2' and digits/precision of 'v1' and 'v2' for 'ksf'
 102 func (ksf *ksf) RangePluralRule(num1 float64, v1 uint64, num2 float64, v2 uint64) locales.PluralRule {
 103         return locales.PluralRuleUnknown
 104 }
 105
 106 // MonthAbbreviated returns the locales abbreviated month given the 'month' provided
 107 func (ksf *ksf) MonthAbbreviated(month time.Month) string {
 108         return ksf.monthsAbbreviated[month]
 109 }
 110
 111 // MonthsAbbreviated returns the locales abbreviated months
 112 func (ksf *ksf) MonthsAbbreviated() []string {
 113         return ksf.monthsAbbreviated[1:]
 114 }
 115
 116 // MonthNarrow returns the locales narrow month given the 'month' provided
 117 func (ksf *ksf) MonthNarrow(month time.Month) string {
 118         return ksf.monthsNarrow[month]
 119 }
 120
 121 // MonthsNarrow returns the locales narrow months
 122 func (ksf *ksf) MonthsNarrow() []string {
 123         return nil
 124 }
 125
 126 // MonthWide returns the locales wide month given the 'month' provided
 127 func (ksf *ksf) MonthWide(month time.Month) string {
 128         return ksf.monthsWide[month]
 129 }
 130
 131 // MonthsWide returns the locales wide months
 132 func (ksf *ksf) MonthsWide() []string {
 133         return ksf.monthsWide[1:]
 134 }
 135
 136 // WeekdayAbbreviated returns the locales abbreviated weekday given the 'weekday' provided
 137 func (ksf *ksf) WeekdayAbbreviated(weekday time.Weekday) string {
 138         return ksf.daysAbbreviated[weekday]
 139 }
 140
 141 // WeekdaysAbbreviated returns the locales abbreviated weekdays
 142 func (ksf *ksf) WeekdaysAbbreviated() []string {
 143         return ksf.daysAbbreviated
 144 }
 145
 146 // WeekdayNarrow returns the locales narrow weekday given the 'weekday' provided
 147 func (ksf *ksf) WeekdayNarrow(weekday time.Weekday) string {
 148         return ksf.daysNarrow[weekday]
 149 }
 150
 151 // WeekdaysNarrow returns the locales narrow weekdays
 152 func (ksf *ksf) WeekdaysNarrow() []string {
 153         return ksf.daysNarrow
 154 }
 155
 156 // WeekdayShort returns the locales short weekday given the 'weekday' provided
 157 func (ksf *ksf) WeekdayShort(weekday time.Weekday) string {
 158         return ksf.daysShort[weekday]
 159 }
 160
 161 // WeekdaysShort returns the locales short weekdays
 162 func (ksf *ksf) WeekdaysShort() []string {
 163         return ksf.daysShort
 164 }
 165
 166 // WeekdayWide returns the locales wide weekday given the 'weekday' provided
 167 func (ksf *ksf) WeekdayWide(weekday time.Weekday) string {
 168         return ksf.daysWide[weekday]
 169 }
 170
 171 // WeekdaysWide returns the locales wide weekdays
 172 func (ksf *ksf) WeekdaysWide() []string {
 173         return ksf.daysWide
 174 }
 175
 176 // Decimal returns the decimal point of number
 177 func (ksf *ksf) Decimal() string {
 178         return ksf.decimal
 179 }
 180
 181 // Group returns the group of number
 182 func (ksf *ksf) Group() string {
 183         return ksf.group
 184 }
 185
 186 // Group returns the minus sign of number
 187 func (ksf *ksf) Minus() string {
 188         return ksf.minus
 189 }
 190
 191 // FmtNumber returns 'num' with digits/precision of 'v' for 'ksf' and handles both Whole and Real numbers based on 'v'
 192 func (ksf *ksf) FmtNumber(num float64, v uint64) string {
 193
 194         s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 195         l := len(s) + 1 + 2*len(s[:len(s)-int(v)-1])/3
 196         count := 0
 197         inWhole := v == 0
 198         b := make([]byte, 0, l)
 199
 200         for i := len(s) - 1; i >= 0; i-- {
 201
 202                 if s[i] == '.' {
 203                         b = append(b, ksf.decimal[0])
 204                         inWhole = true
 205                         continue
 206                 }
 207
 208                 if inWhole {
 209                         if count == 3 {
 210                                 for j := len(ksf.group) - 1; j >= 0; j-- {
 211                                         b = append(b, ksf.group[j])
 212                                 }
 213                                 count = 1
 214                         } else {
 215                                 count++
 216                         }
 217                 }
 218
 219                 b = append(b, s[i])
 220         }
 221
 222         if num < 0 {
 223                 b = append(b, ksf.minus[0])
 224         }
 225
 226         // reverse
 227         for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
 228                 b[i], b[j] = b[j], b[i]
 229         }
 230
 231         return string(b)
 232 }
 233
 234 // FmtPercent returns 'num' with digits/precision of 'v' for 'ksf' and handles both Whole and Real numbers based on 'v'
 235 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
 236 func (ksf *ksf) FmtPercent(num float64, v uint64) string {
 237         return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 238 }
 239
 240 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'ksf'
 241 func (ksf *ksf) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 242
 243         s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 244         symbol := ksf.currencies[currency]
 245         l := len(s) + len(symbol) + 3 + 2*len(s[:len(s)-int(v)-1])/3
 246         count := 0
 247         inWhole := v == 0
 248         b := make([]byte, 0, l)
 249
 250         for i := len(s) - 1; i >= 0; i-- {
 251
 252                 if s[i] == '.' {
 253                         b = append(b, ksf.decimal[0])
 254                         inWhole = true
 255                         continue
 256                 }
 257
 258                 if inWhole {
 259                         if count == 3 {
 260                                 for j := len(ksf.group) - 1; j >= 0; j-- {
 261                                         b = append(b, ksf.group[j])
 262                                 }
 263                                 count = 1
 264                         } else {
 265                                 count++
 266                         }
 267                 }
 268
 269                 b = append(b, s[i])
 270         }
 271
 272         if num < 0 {
 273                 b = append(b, ksf.minus[0])
 274         }
 275
 276         // reverse
 277         for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
 278                 b[i], b[j] = b[j], b[i]
 279         }
 280
 281         if int(v) < 2 {
 282
 283                 if v == 0 {
 284                         b = append(b, ksf.decimal...)
 285                 }
 286
 287                 for i := 0; i < 2-int(v); i++ {
 288                         b = append(b, '0')
 289                 }
 290         }
 291
 292         b = append(b, ksf.currencyPositiveSuffix...)
 293
 294         b = append(b, symbol...)
 295
 296         return string(b)
 297 }
 298
 299 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'ksf'
 300 // in accounting notation.
 301 func (ksf *ksf) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 302
 303         s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 304         symbol := ksf.currencies[currency]
 305         l := len(s) + len(symbol) + 3 + 2*len(s[:len(s)-int(v)-1])/3
 306         count := 0
 307         inWhole := v == 0
 308         b := make([]byte, 0, l)
 309
 310         for i := len(s) - 1; i >= 0; i-- {
 311
 312                 if s[i] == '.' {
 313                         b = append(b, ksf.decimal[0])
 314                         inWhole = true
 315                         continue
 316                 }
 317
 318                 if inWhole {
 319                         if count == 3 {
 320                                 for j := len(ksf.group) - 1; j >= 0; j-- {
 321                                         b = append(b, ksf.group[j])
 322                                 }
 323                                 count = 1
 324                         } else {
 325                                 count++
 326                         }
 327                 }
 328
 329                 b = append(b, s[i])
 330         }
 331
 332         if num < 0 {
 333
 334                 b = append(b, ksf.minus[0])
 335
 336         }
 337
 338         // reverse
 339         for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
 340                 b[i], b[j] = b[j], b[i]
 341         }
 342
 343         if int(v) < 2 {
 344
 345                 if v == 0 {
 346                         b = append(b, ksf.decimal...)
 347                 }
 348
 349                 for i := 0; i < 2-int(v); i++ {
 350                         b = append(b, '0')
 351                 }
 352         }
 353
 354         if num < 0 {
 355                 b = append(b, ksf.currencyNegativeSuffix...)
 356                 b = append(b, symbol...)
 357         } else {
 358
 359                 b = append(b, ksf.currencyPositiveSuffix...)
 360                 b = append(b, symbol...)
 361         }
 362
 363         return string(b)
 364 }
 365
 366 // FmtDateShort returns the short date representation of 't' for 'ksf'
 367 func (ksf *ksf) FmtDateShort(t time.Time) string {
 368
 369         b := make([]byte, 0, 32)
 370
 371         b = strconv.AppendInt(b, int64(t.Day()), 10)
 372         b = append(b, []byte{0x2f}...)
 373         b = strconv.AppendInt(b, int64(t.Month()), 10)
 374         b = append(b, []byte{0x2f}...)
 375
 376         if t.Year() > 0 {
 377                 b = strconv.AppendInt(b, int64(t.Year()), 10)
 378         } else {
 379                 b = strconv.AppendInt(b, int64(-t.Year()), 10)
 380         }
 381
 382         return string(b)
 383 }
 384
 385 // FmtDateMedium returns the medium date representation of 't' for 'ksf'
 386 func (ksf *ksf) FmtDateMedium(t time.Time) string {
 387
 388         b := make([]byte, 0, 32)
 389
 390         b = strconv.AppendInt(b, int64(t.Day()), 10)
 391         b = append(b, []byte{0x20}...)
 392         b = append(b, ksf.monthsAbbreviated[t.Month()]...)
 393         b = append(b, []byte{0x20}...)
 394
 395         if t.Year() > 0 {
 396                 b = strconv.AppendInt(b, int64(t.Year()), 10)
 397         } else {
 398                 b = strconv.AppendInt(b, int64(-t.Year()), 10)
 399         }
 400
 401         return string(b)
 402 }
 403
 404 // FmtDateLong returns the long date representation of 't' for 'ksf'
 405 func (ksf *ksf) FmtDateLong(t time.Time) string {
 406
 407         b := make([]byte, 0, 32)
 408
 409         b = strconv.AppendInt(b, int64(t.Day()), 10)
 410         b = append(b, []byte{0x20}...)
 411         b = append(b, ksf.monthsWide[t.Month()]...)
 412         b = append(b, []byte{0x20}...)
 413
 414         if t.Year() > 0 {
 415                 b = strconv.AppendInt(b, int64(t.Year()), 10)
 416         } else {
 417                 b = strconv.AppendInt(b, int64(-t.Year()), 10)
 418         }
 419
 420         return string(b)
 421 }
 422
 423 // FmtDateFull returns the full date representation of 't' for 'ksf'
 424 func (ksf *ksf) FmtDateFull(t time.Time) string {
 425
 426         b := make([]byte, 0, 32)
 427
 428         b = append(b, ksf.daysWide[t.Weekday()]...)
 429         b = append(b, []byte{0x20}...)
 430         b = strconv.AppendInt(b, int64(t.Day()), 10)
 431         b = append(b, []byte{0x20}...)
 432         b = append(b, ksf.monthsWide[t.Month()]...)
 433         b = append(b, []byte{0x20}...)
 434
 435         if t.Year() > 0 {
 436                 b = strconv.AppendInt(b, int64(t.Year()), 10)
 437         } else {
 438                 b = strconv.AppendInt(b, int64(-t.Year()), 10)
 439         }
 440
 441         return string(b)
 442 }
 443
 444 // FmtTimeShort returns the short time representation of 't' for 'ksf'
 445 func (ksf *ksf) FmtTimeShort(t time.Time) string {
 446
 447         b := make([]byte, 0, 32)
 448
 449         if t.Hour() < 10 {
 450                 b = append(b, '0')
 451         }
 452
 453         b = strconv.AppendInt(b, int64(t.Hour()), 10)
 454         b = append(b, ksf.timeSeparator...)
 455
 456         if t.Minute() < 10 {
 457                 b = append(b, '0')
 458         }
 459
 460         b = strconv.AppendInt(b, int64(t.Minute()), 10)
 461
 462         return string(b)
 463 }
 464
 465 // FmtTimeMedium returns the medium time representation of 't' for 'ksf'
 466 func (ksf *ksf) FmtTimeMedium(t time.Time) string {
 467
 468         b := make([]byte, 0, 32)
 469
 470         if t.Hour() < 10 {
 471                 b = append(b, '0')
 472         }
 473
 474         b = strconv.AppendInt(b, int64(t.Hour()), 10)
 475         b = append(b, ksf.timeSeparator...)
 476
 477         if t.Minute() < 10 {
 478                 b = append(b, '0')
 479         }
 480
 481         b = strconv.AppendInt(b, int64(t.Minute()), 10)
 482         b = append(b, ksf.timeSeparator...)
 483
 484         if t.Second() < 10 {
 485                 b = append(b, '0')
 486         }
 487
 488         b = strconv.AppendInt(b, int64(t.Second()), 10)
 489
 490         return string(b)
 491 }
 492
 493 // FmtTimeLong returns the long time representation of 't' for 'ksf'
 494 func (ksf *ksf) FmtTimeLong(t time.Time) string {
 495
 496         b := make([]byte, 0, 32)
 497
 498         if t.Hour() < 10 {
 499                 b = append(b, '0')
 500         }
 501
 502         b = strconv.AppendInt(b, int64(t.Hour()), 10)
 503         b = append(b, ksf.timeSeparator...)
 504
 505         if t.Minute() < 10 {
 506                 b = append(b, '0')
 507         }
 508
 509         b = strconv.AppendInt(b, int64(t.Minute()), 10)
 510         b = append(b, ksf.timeSeparator...)
 511
 512         if t.Second() < 10 {
 513                 b = append(b, '0')
 514         }
 515
 516         b = strconv.AppendInt(b, int64(t.Second()), 10)
 517         b = append(b, []byte{0x20}...)
 518
 519         tz, _ := t.Zone()
 520         b = append(b, tz...)
 521
 522         return string(b)
 523 }
 524
 525 // FmtTimeFull returns the full time representation of 't' for 'ksf'
 526 func (ksf *ksf) FmtTimeFull(t time.Time) string {
 527
 528         b := make([]byte, 0, 32)
 529
 530         if t.Hour() < 10 {
 531                 b = append(b, '0')
 532         }
 533
 534         b = strconv.AppendInt(b, int64(t.Hour()), 10)
 535         b = append(b, ksf.timeSeparator...)
 536
 537         if t.Minute() < 10 {
 538                 b = append(b, '0')
 539         }
 540
 541         b = strconv.AppendInt(b, int64(t.Minute()), 10)
 542         b = append(b, ksf.timeSeparator...)
 543
 544         if t.Second() < 10 {
 545                 b = append(b, '0')
 546         }
 547
 548         b = strconv.AppendInt(b, int64(t.Second()), 10)
 549         b = append(b, []byte{0x20}...)
 550
 551         tz, _ := t.Zone()
 552
 553         if btz, ok := ksf.timezones[tz]; ok {
 554                 b = append(b, btz...)
 555         } else {
 556                 b = append(b, tz...)
 557         }
 558
 559         return string(b)
 560 }