luo.go

Documentation: github.com/go-playground/locales/luo

     1  package luo
     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 luo 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  	monthsAbbreviated  []string
    26  	monthsNarrow       []string
    27  	monthsWide         []string
    28  	daysAbbreviated    []string
    29  	daysNarrow         []string
    30  	daysShort          []string
    31  	daysWide           []string
    32  	periodsAbbreviated []string
    33  	periodsNarrow      []string
    34  	periodsShort       []string
    35  	periodsWide        []string
    36  	erasAbbreviated    []string
    37  	erasNarrow         []string
    38  	erasWide           []string
    39  	timezones          map[string]string
    40  }
    41  
    42  // New returns a new instance of translator for the 'luo' locale
    43  func New() locales.Translator {
    44  	return &luo{
    45  		locale:             "luo",
    46  		pluralsCardinal:    nil,
    47  		pluralsOrdinal:     nil,
    48  		pluralsRange:       nil,
    49  		timeSeparator:      ":",
    50  		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", "CNH", "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", "Ksh", "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", "MRU", "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", "STN", "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", "UYW", "UZS", "VEB", "VEF", "VES", "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"},
    51  		monthsAbbreviated:  []string{"", "DAC", "DAR", "DAD", "DAN", "DAH", "DAU", "DAO", "DAB", "DOC", "DAP", "DGI", "DAG"},
    52  		monthsNarrow:       []string{"", "C", "R", "D", "N", "B", "U", "B", "B", "C", "P", "C", "P"},
    53  		monthsWide:         []string{"", "Dwe mar Achiel", "Dwe mar Ariyo", "Dwe mar Adek", "Dwe mar Ang’wen", "Dwe mar Abich", "Dwe mar Auchiel", "Dwe mar Abiriyo", "Dwe mar Aboro", "Dwe mar Ochiko", "Dwe mar Apar", "Dwe mar gi achiel", "Dwe mar Apar gi ariyo"},
    54  		daysAbbreviated:    []string{"JMP", "WUT", "TAR", "TAD", "TAN", "TAB", "NGS"},
    55  		daysNarrow:         []string{"J", "W", "T", "T", "T", "T", "N"},
    56  		daysWide:           []string{"Jumapil", "Wuok Tich", "Tich Ariyo", "Tich Adek", "Tich Ang’wen", "Tich Abich", "Ngeso"},
    57  		periodsAbbreviated: []string{"OD", "OT"},
    58  		periodsWide:        []string{"OD", "OT"},
    59  		erasAbbreviated:    []string{"BC", "AD"},
    60  		erasNarrow:         []string{"", ""},
    61  		erasWide:           []string{"Kapok Kristo obiro", "Ka Kristo osebiro"},
    62  		timezones:          map[string]string{"ACDT": "ACDT", "ACST": "ACST", "ACWDT": "ACWDT", "ACWST": "ACWST", "ADT": "ADT", "AEDT": "AEDT", "AEST": "AEST", "AKDT": "AKDT", "AKST": "AKST", "ARST": "ARST", "ART": "ART", "AST": "AST", "AWDT": "AWDT", "AWST": "AWST", "BOT": "BOT", "BT": "BT", "CAT": "CAT", "CDT": "CDT", "CHADT": "CHADT", "CHAST": "CHAST", "CLST": "CLST", "CLT": "CLT", "COST": "COST", "COT": "COT", "CST": "CST", "ChST": "ChST", "EAT": "EAT", "ECT": "ECT", "EDT": "EDT", "EST": "EST", "GFT": "GFT", "GMT": "GMT", "GST": "GST", "GYT": "GYT", "HADT": "HADT", "HAST": "HAST", "HAT": "HAT", "HECU": "HECU", "HEEG": "HEEG", "HENOMX": "HENOMX", "HEOG": "HEOG", "HEPM": "HEPM", "HEPMX": "HEPMX", "HKST": "HKST", "HKT": "HKT", "HNCU": "HNCU", "HNEG": "HNEG", "HNNOMX": "HNNOMX", "HNOG": "HNOG", "HNPM": "HNPM", "HNPMX": "HNPMX", "HNT": "HNT", "IST": "IST", "JDT": "JDT", "JST": "JST", "LHDT": "LHDT", "LHST": "LHST", "MDT": "MDT", "MESZ": "MESZ", "MEZ": "MEZ", "MST": "MST", "MYT": "MYT", "NZDT": "NZDT", "NZST": "NZST", "OESZ": "OESZ", "OEZ": "OEZ", "PDT": "PDT", "PST": "PST", "SAST": "SAST", "SGT": "SGT", "SRT": "SRT", "TMST": "TMST", "TMT": "TMT", "UYST": "UYST", "UYT": "UYT", "VET": "VET", "WARST": "WARST", "WART": "WART", "WAST": "WAST", "WAT": "WAT", "WESZ": "WESZ", "WEZ": "WEZ", "WIB": "WIB", "WIT": "WIT", "WITA": "WITA", "∅∅∅": "∅∅∅"},
    63  	}
    64  }
    65  
    66  // Locale returns the current translators string locale
    67  func (luo *luo) Locale() string {
    68  	return luo.locale
    69  }
    70  
    71  // PluralsCardinal returns the list of cardinal plural rules associated with 'luo'
    72  func (luo *luo) PluralsCardinal() []locales.PluralRule {
    73  	return luo.pluralsCardinal
    74  }
    75  
    76  // PluralsOrdinal returns the list of ordinal plural rules associated with 'luo'
    77  func (luo *luo) PluralsOrdinal() []locales.PluralRule {
    78  	return luo.pluralsOrdinal
    79  }
    80  
    81  // PluralsRange returns the list of range plural rules associated with 'luo'
    82  func (luo *luo) PluralsRange() []locales.PluralRule {
    83  	return luo.pluralsRange
    84  }
    85  
    86  // CardinalPluralRule returns the cardinal PluralRule given 'num' and digits/precision of 'v' for 'luo'
    87  func (luo *luo) CardinalPluralRule(num float64, v uint64) locales.PluralRule {
    88  	return locales.PluralRuleUnknown
    89  }
    90  
    91  // OrdinalPluralRule returns the ordinal PluralRule given 'num' and digits/precision of 'v' for 'luo'
    92  func (luo *luo) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
    93  	return locales.PluralRuleUnknown
    94  }
    95  
    96  // RangePluralRule returns the ordinal PluralRule given 'num1', 'num2' and digits/precision of 'v1' and 'v2' for 'luo'
    97  func (luo *luo) RangePluralRule(num1 float64, v1 uint64, num2 float64, v2 uint64) locales.PluralRule {
    98  	return locales.PluralRuleUnknown
    99  }
   100  
   101  // MonthAbbreviated returns the locales abbreviated month given the 'month' provided
   102  func (luo *luo) MonthAbbreviated(month time.Month) string {
   103  	return luo.monthsAbbreviated[month]
   104  }
   105  
   106  // MonthsAbbreviated returns the locales abbreviated months
   107  func (luo *luo) MonthsAbbreviated() []string {
   108  	return luo.monthsAbbreviated[1:]
   109  }
   110  
   111  // MonthNarrow returns the locales narrow month given the 'month' provided
   112  func (luo *luo) MonthNarrow(month time.Month) string {
   113  	return luo.monthsNarrow[month]
   114  }
   115  
   116  // MonthsNarrow returns the locales narrow months
   117  func (luo *luo) MonthsNarrow() []string {
   118  	return luo.monthsNarrow[1:]
   119  }
   120  
   121  // MonthWide returns the locales wide month given the 'month' provided
   122  func (luo *luo) MonthWide(month time.Month) string {
   123  	return luo.monthsWide[month]
   124  }
   125  
   126  // MonthsWide returns the locales wide months
   127  func (luo *luo) MonthsWide() []string {
   128  	return luo.monthsWide[1:]
   129  }
   130  
   131  // WeekdayAbbreviated returns the locales abbreviated weekday given the 'weekday' provided
   132  func (luo *luo) WeekdayAbbreviated(weekday time.Weekday) string {
   133  	return luo.daysAbbreviated[weekday]
   134  }
   135  
   136  // WeekdaysAbbreviated returns the locales abbreviated weekdays
   137  func (luo *luo) WeekdaysAbbreviated() []string {
   138  	return luo.daysAbbreviated
   139  }
   140  
   141  // WeekdayNarrow returns the locales narrow weekday given the 'weekday' provided
   142  func (luo *luo) WeekdayNarrow(weekday time.Weekday) string {
   143  	return luo.daysNarrow[weekday]
   144  }
   145  
   146  // WeekdaysNarrow returns the locales narrow weekdays
   147  func (luo *luo) WeekdaysNarrow() []string {
   148  	return luo.daysNarrow
   149  }
   150  
   151  // WeekdayShort returns the locales short weekday given the 'weekday' provided
   152  func (luo *luo) WeekdayShort(weekday time.Weekday) string {
   153  	return luo.daysShort[weekday]
   154  }
   155  
   156  // WeekdaysShort returns the locales short weekdays
   157  func (luo *luo) WeekdaysShort() []string {
   158  	return luo.daysShort
   159  }
   160  
   161  // WeekdayWide returns the locales wide weekday given the 'weekday' provided
   162  func (luo *luo) WeekdayWide(weekday time.Weekday) string {
   163  	return luo.daysWide[weekday]
   164  }
   165  
   166  // WeekdaysWide returns the locales wide weekdays
   167  func (luo *luo) WeekdaysWide() []string {
   168  	return luo.daysWide
   169  }
   170  
   171  // Decimal returns the decimal point of number
   172  func (luo *luo) Decimal() string {
   173  	return luo.decimal
   174  }
   175  
   176  // Group returns the group of number
   177  func (luo *luo) Group() string {
   178  	return luo.group
   179  }
   180  
   181  // Group returns the minus sign of number
   182  func (luo *luo) Minus() string {
   183  	return luo.minus
   184  }
   185  
   186  // FmtNumber returns 'num' with digits/precision of 'v' for 'luo' and handles both Whole and Real numbers based on 'v'
   187  func (luo *luo) FmtNumber(num float64, v uint64) string {
   188  
   189  	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
   190  }
   191  
   192  // FmtPercent returns 'num' with digits/precision of 'v' for 'luo' and handles both Whole and Real numbers based on 'v'
   193  // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
   194  func (luo *luo) FmtPercent(num float64, v uint64) string {
   195  	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
   196  }
   197  
   198  // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'luo'
   199  func (luo *luo) FmtCurrency(num float64, v uint64, currency currency.Type) string {
   200  
   201  	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
   202  	symbol := luo.currencies[currency]
   203  	l := len(s) + len(symbol) + 0
   204  	count := 0
   205  	inWhole := v == 0
   206  	b := make([]byte, 0, l)
   207  
   208  	for i := len(s) - 1; i >= 0; i-- {
   209  
   210  		if s[i] == '.' {
   211  			b = append(b, luo.decimal[0])
   212  			inWhole = true
   213  			continue
   214  		}
   215  
   216  		if inWhole {
   217  			if count == 3 {
   218  				b = append(b, luo.group[0])
   219  				count = 1
   220  			} else {
   221  				count++
   222  			}
   223  		}
   224  
   225  		b = append(b, s[i])
   226  	}
   227  
   228  	if num < 0 {
   229  		b = append(b, luo.minus[0])
   230  	}
   231  
   232  	// reverse
   233  	for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
   234  		b[i], b[j] = b[j], b[i]
   235  	}
   236  
   237  	if int(v) < 2 {
   238  
   239  		if v == 0 {
   240  			b = append(b, luo.decimal...)
   241  		}
   242  
   243  		for i := 0; i < 2-int(v); i++ {
   244  			b = append(b, '0')
   245  		}
   246  	}
   247  
   248  	b = append(b, symbol...)
   249  
   250  	return string(b)
   251  }
   252  
   253  // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'luo'
   254  // in accounting notation.
   255  func (luo *luo) FmtAccounting(num float64, v uint64, currency currency.Type) string {
   256  
   257  	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
   258  	symbol := luo.currencies[currency]
   259  	l := len(s) + len(symbol) + 0
   260  	count := 0
   261  	inWhole := v == 0
   262  	b := make([]byte, 0, l)
   263  
   264  	for i := len(s) - 1; i >= 0; i-- {
   265  
   266  		if s[i] == '.' {
   267  			b = append(b, luo.decimal[0])
   268  			inWhole = true
   269  			continue
   270  		}
   271  
   272  		if inWhole {
   273  			if count == 3 {
   274  				b = append(b, luo.group[0])
   275  				count = 1
   276  			} else {
   277  				count++
   278  			}
   279  		}
   280  
   281  		b = append(b, s[i])
   282  	}
   283  
   284  	if num < 0 {
   285  
   286  		b = append(b, luo.minus[0])
   287  
   288  	}
   289  
   290  	// reverse
   291  	for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
   292  		b[i], b[j] = b[j], b[i]
   293  	}
   294  
   295  	if int(v) < 2 {
   296  
   297  		if v == 0 {
   298  			b = append(b, luo.decimal...)
   299  		}
   300  
   301  		for i := 0; i < 2-int(v); i++ {
   302  			b = append(b, '0')
   303  		}
   304  	}
   305  
   306  	if num < 0 {
   307  		b = append(b, symbol...)
   308  	} else {
   309  
   310  		b = append(b, symbol...)
   311  	}
   312  
   313  	return string(b)
   314  }
   315  
   316  // FmtDateShort returns the short date representation of 't' for 'luo'
   317  func (luo *luo) FmtDateShort(t time.Time) string {
   318  
   319  	b := make([]byte, 0, 32)
   320  
   321  	if t.Day() < 10 {
   322  		b = append(b, '0')
   323  	}
   324  
   325  	b = strconv.AppendInt(b, int64(t.Day()), 10)
   326  	b = append(b, []byte{0x2f}...)
   327  
   328  	if t.Month() < 10 {
   329  		b = append(b, '0')
   330  	}
   331  
   332  	b = strconv.AppendInt(b, int64(t.Month()), 10)
   333  
   334  	b = append(b, []byte{0x2f}...)
   335  
   336  	if t.Year() > 0 {
   337  		b = strconv.AppendInt(b, int64(t.Year()), 10)
   338  	} else {
   339  		b = strconv.AppendInt(b, int64(-t.Year()), 10)
   340  	}
   341  
   342  	return string(b)
   343  }
   344  
   345  // FmtDateMedium returns the medium date representation of 't' for 'luo'
   346  func (luo *luo) FmtDateMedium(t time.Time) string {
   347  
   348  	b := make([]byte, 0, 32)
   349  
   350  	b = strconv.AppendInt(b, int64(t.Day()), 10)
   351  	b = append(b, []byte{0x20}...)
   352  	b = append(b, luo.monthsAbbreviated[t.Month()]...)
   353  	b = append(b, []byte{0x20}...)
   354  
   355  	if t.Year() > 0 {
   356  		b = strconv.AppendInt(b, int64(t.Year()), 10)
   357  	} else {
   358  		b = strconv.AppendInt(b, int64(-t.Year()), 10)
   359  	}
   360  
   361  	return string(b)
   362  }
   363  
   364  // FmtDateLong returns the long date representation of 't' for 'luo'
   365  func (luo *luo) FmtDateLong(t time.Time) string {
   366  
   367  	b := make([]byte, 0, 32)
   368  
   369  	b = strconv.AppendInt(b, int64(t.Day()), 10)
   370  	b = append(b, []byte{0x20}...)
   371  	b = append(b, luo.monthsWide[t.Month()]...)
   372  	b = append(b, []byte{0x20}...)
   373  
   374  	if t.Year() > 0 {
   375  		b = strconv.AppendInt(b, int64(t.Year()), 10)
   376  	} else {
   377  		b = strconv.AppendInt(b, int64(-t.Year()), 10)
   378  	}
   379  
   380  	return string(b)
   381  }
   382  
   383  // FmtDateFull returns the full date representation of 't' for 'luo'
   384  func (luo *luo) FmtDateFull(t time.Time) string {
   385  
   386  	b := make([]byte, 0, 32)
   387  
   388  	b = append(b, luo.daysWide[t.Weekday()]...)
   389  	b = append(b, []byte{0x2c, 0x20}...)
   390  	b = strconv.AppendInt(b, int64(t.Day()), 10)
   391  	b = append(b, []byte{0x20}...)
   392  	b = append(b, luo.monthsWide[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  // FmtTimeShort returns the short time representation of 't' for 'luo'
   405  func (luo *luo) FmtTimeShort(t time.Time) string {
   406  
   407  	b := make([]byte, 0, 32)
   408  
   409  	if t.Hour() < 10 {
   410  		b = append(b, '0')
   411  	}
   412  
   413  	b = strconv.AppendInt(b, int64(t.Hour()), 10)
   414  	b = append(b, luo.timeSeparator...)
   415  
   416  	if t.Minute() < 10 {
   417  		b = append(b, '0')
   418  	}
   419  
   420  	b = strconv.AppendInt(b, int64(t.Minute()), 10)
   421  
   422  	return string(b)
   423  }
   424  
   425  // FmtTimeMedium returns the medium time representation of 't' for 'luo'
   426  func (luo *luo) FmtTimeMedium(t time.Time) string {
   427  
   428  	b := make([]byte, 0, 32)
   429  
   430  	if t.Hour() < 10 {
   431  		b = append(b, '0')
   432  	}
   433  
   434  	b = strconv.AppendInt(b, int64(t.Hour()), 10)
   435  	b = append(b, luo.timeSeparator...)
   436  
   437  	if t.Minute() < 10 {
   438  		b = append(b, '0')
   439  	}
   440  
   441  	b = strconv.AppendInt(b, int64(t.Minute()), 10)
   442  	b = append(b, luo.timeSeparator...)
   443  
   444  	if t.Second() < 10 {
   445  		b = append(b, '0')
   446  	}
   447  
   448  	b = strconv.AppendInt(b, int64(t.Second()), 10)
   449  
   450  	return string(b)
   451  }
   452  
   453  // FmtTimeLong returns the long time representation of 't' for 'luo'
   454  func (luo *luo) FmtTimeLong(t time.Time) string {
   455  
   456  	b := make([]byte, 0, 32)
   457  
   458  	if t.Hour() < 10 {
   459  		b = append(b, '0')
   460  	}
   461  
   462  	b = strconv.AppendInt(b, int64(t.Hour()), 10)
   463  	b = append(b, luo.timeSeparator...)
   464  
   465  	if t.Minute() < 10 {
   466  		b = append(b, '0')
   467  	}
   468  
   469  	b = strconv.AppendInt(b, int64(t.Minute()), 10)
   470  	b = append(b, luo.timeSeparator...)
   471  
   472  	if t.Second() < 10 {
   473  		b = append(b, '0')
   474  	}
   475  
   476  	b = strconv.AppendInt(b, int64(t.Second()), 10)
   477  	b = append(b, []byte{0x20}...)
   478  
   479  	tz, _ := t.Zone()
   480  	b = append(b, tz...)
   481  
   482  	return string(b)
   483  }
   484  
   485  // FmtTimeFull returns the full time representation of 't' for 'luo'
   486  func (luo *luo) FmtTimeFull(t time.Time) string {
   487  
   488  	b := make([]byte, 0, 32)
   489  
   490  	if t.Hour() < 10 {
   491  		b = append(b, '0')
   492  	}
   493  
   494  	b = strconv.AppendInt(b, int64(t.Hour()), 10)
   495  	b = append(b, luo.timeSeparator...)
   496  
   497  	if t.Minute() < 10 {
   498  		b = append(b, '0')
   499  	}
   500  
   501  	b = strconv.AppendInt(b, int64(t.Minute()), 10)
   502  	b = append(b, luo.timeSeparator...)
   503  
   504  	if t.Second() < 10 {
   505  		b = append(b, '0')
   506  	}
   507  
   508  	b = strconv.AppendInt(b, int64(t.Second()), 10)
   509  	b = append(b, []byte{0x20}...)
   510  
   511  	tz, _ := t.Zone()
   512  
   513  	if btz, ok := luo.timezones[tz]; ok {
   514  		b = append(b, btz...)
   515  	} else {
   516  		b = append(b, tz...)
   517  	}
   518  
   519  	return string(b)
   520  }
   521
View as plain text