ur_PK.go 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637
  1. package ur_PK
  2. import (
  3. "math"
  4. "strconv"
  5. "time"
  6. "github.com/go-playground/locales"
  7. "github.com/go-playground/locales/currency"
  8. )
  9. type ur_PK struct {
  10. locale string
  11. pluralsCardinal []locales.PluralRule
  12. pluralsOrdinal []locales.PluralRule
  13. pluralsRange []locales.PluralRule
  14. decimal string
  15. group string
  16. minus string
  17. percent string
  18. perMille string
  19. timeSeparator string
  20. inifinity string
  21. currencies []string // idx = enum of currency code
  22. monthsAbbreviated []string
  23. monthsNarrow []string
  24. monthsWide []string
  25. daysAbbreviated []string
  26. daysNarrow []string
  27. daysShort []string
  28. daysWide []string
  29. periodsAbbreviated []string
  30. periodsNarrow []string
  31. periodsShort []string
  32. periodsWide []string
  33. erasAbbreviated []string
  34. erasNarrow []string
  35. erasWide []string
  36. timezones map[string]string
  37. }
  38. // New returns a new instance of translator for the 'ur_PK' locale
  39. func New() locales.Translator {
  40. return &ur_PK{
  41. locale: "ur_PK",
  42. pluralsCardinal: []locales.PluralRule{2, 6},
  43. pluralsOrdinal: []locales.PluralRule{6},
  44. pluralsRange: []locales.PluralRule{6},
  45. decimal: ".",
  46. group: ",",
  47. minus: "‎-",
  48. percent: "%",
  49. perMille: "‰",
  50. timeSeparator: ":",
  51. inifinity: "∞",
  52. 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", "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", "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", "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"},
  53. monthsAbbreviated: []string{"", "جنوری", "فروری", "مارچ", "اپریل", "مئی", "جون", "جولائی", "اگست", "ستمبر", "اکتوبر", "نومبر", "دسمبر"},
  54. monthsNarrow: []string{"", "J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"},
  55. monthsWide: []string{"", "جنوری", "فروری", "مارچ", "اپریل", "مئی", "جون", "جولائی", "اگست", "ستمبر", "اکتوبر", "نومبر", "دسمبر"},
  56. daysAbbreviated: []string{"اتوار", "پیر", "منگل", "بدھ", "جمعرات", "جمعہ", "ہفتہ"},
  57. daysNarrow: []string{"S", "M", "T", "W", "T", "F", "S"},
  58. daysShort: []string{"اتوار", "پیر", "منگل", "بدھ", "جمعرات", "جمعہ", "ہفتہ"},
  59. daysWide: []string{"اتوار", "پیر", "منگل", "بدھ", "جمعرات", "جمعہ", "ہفتہ"},
  60. periodsAbbreviated: []string{"AM", "PM"},
  61. periodsNarrow: []string{"a", "p"},
  62. periodsWide: []string{"AM", "PM"},
  63. erasAbbreviated: []string{"قبل مسیح", "عیسوی"},
  64. erasNarrow: []string{"", ""},
  65. erasWide: []string{"قبل مسیح", "عیسوی"},
  66. timezones: map[string]string{"GFT": "فرینچ گیانا کا وقت", "MST": "ماؤنٹین اسٹینڈرڈ ٹائم", "BOT": "بولیویا کا وقت", "EST": "ایسٹرن اسٹینڈرڈ ٹائم", "CHAST": "چیتھم اسٹینڈرڈ ٹائم", "HAT": "نیو فاؤنڈ لینڈ ڈے لائٹ ٹائم", "HNNOMX": "شمال مغربی میکسیکو اسٹینڈرڈ ٹائم", "HADT": "ہوائی الیوٹیئن ڈے لائٹ ٹائم", "PDT": "پیسفک ڈے لائٹ ٹائم", "COST": "کولمبیا کا موسم گرما کا وقت", "MDT": "ماؤنٹین ڈے لائٹ ٹائم", "WAT": "مغربی افریقہ سٹینڈرڈ ٹائم", "ACWDT": "آسٹریلین سنٹرل ویسٹرن ڈے لائٹ ٹائم", "EDT": "ایسٹرن ڈے لائٹ ٹائم", "WIT": "مشرقی انڈونیشیا ٹائم", "HENOMX": "شمال مغربی میکسیکو ڈے لائٹ ٹائم", "UYT": "یوروگوئے کا معیاری وقت", "CST": "سنٹرل اسٹینڈرڈ ٹائم", "ADT": "اٹلانٹک ڈے لائٹ ٹائم", "WESZ": "مغربی یورپ کا موسم گرما کا وقت", "ACDT": "آسٹریلین سنٹرل ڈے لائٹ ٹائم", "ACWST": "آسٹریلین سنٹرل ویسٹرن اسٹینڈرڈ ٹائم", "HKST": "ہانگ کانگ سمر ٹائم", "GYT": "گیانا کا وقت", "HEPMX": "میکسیکن پیسفک ڈے لائٹ ٹائم", "AEST": "آسٹریلین ایسٹرن اسٹینڈرڈ ٹائم", "HEOG": "مغربی گرین لینڈ کا موسم گرما کا وقت", "IST": "ہندوستان کا معیاری وقت", "WITA": "وسطی انڈونیشیا ٹائم", "ARST": "ارجنٹینا سمر ٹائم", "MYT": "ملیشیا ٹائم", "HAST": "ہوائی الیوٹیئن اسٹینڈرڈ ٹائم", "OEZ": "مشرقی یورپ کا معیاری وقت", "GMT": "گرین وچ کا اصل وقت", "CHADT": "چیتھم ڈے لائٹ ٹائم", "EAT": "مشرقی افریقہ ٹائم", "TMST": "ترکمانستان کا موسم گرما کا وقت", "CAT": "وسطی افریقہ ٹائم", "UYST": "یوروگوئے کا موسم گرما کا وقت", "OESZ": "مشرقی یورپ کا موسم گرما کا وقت", "AWST": "آسٹریلیا ویسٹرن اسٹینڈرڈ ٹائم", "AWDT": "آسٹریلین ویسٹرن ڈے لائٹ ٹائم", "WEZ": "مغربی یورپ کا معیاری وقت", "WIB": "مغربی انڈونیشیا ٹائم", "NZDT": "نیوزی لینڈ ڈے لائٹ ٹائم", "ECT": "ایکواڈور کا وقت", "LHST": "لارڈ ہووے اسٹینڈرڈ ٹائم", "HNPMX": "میکسیکن پیسفک اسٹینڈرڈ ٹائم", "JST": "جاپان سٹینڈرڈ ٹائم", "HNEG": "مشرقی گرین لینڈ اسٹینڈرڈ ٹائم", "HNOG": "مغربی گرین لینڈ اسٹینڈرڈ ٹائم", "HEPM": "سینٹ پیئر اور مکلیئون ڈے لائٹ ٹائم", "TMT": "ترکمانستان کا معیاری وقت", "AST": "اٹلانٹک اسٹینڈرڈ ٹائم", "AKDT": "الاسکا ڈے لائٹ ٹائم", "WAST": "مغربی افریقہ سمر ٹائم", "HNPM": "سینٹ پیئر اور مکلیئون اسٹینڈرڈ ٹائم", "HECU": "کیوبا ڈے لائٹ ٹائم", "PST": "پیسفک اسٹینڈرڈ ٹائم", "MESZ": "وسطی یورپ کا موسم گرما کا وقت", "LHDT": "لارڈ ہووے ڈے لائٹ ٹائم", "VET": "وینزوئیلا کا وقت", "HNT": "نیو فاؤنڈ لینڈ اسٹینڈرڈ ٹائم", "CLT": "چلی کا معیاری وقت", "CLST": "چلی کا موسم گرما کا وقت", "ChST": "چامورو سٹینڈرڈ ٹائم", "HNCU": "کیوبا اسٹینڈرڈ ٹائم", "∅∅∅": "∅∅∅", "NZST": "نیوزی لینڈ کا معیاری وقت", "AKST": "الاسکا اسٹینڈرڈ ٹائم", "ACST": "آسٹریلین سنٹرل اسٹینڈرڈ ٹائم", "HEEG": "مشرقی گرین لینڈ کا موسم گرما کا وقت", "CDT": "سنٹرل ڈے لائٹ ٹائم", "JDT": "جاپان ڈے لائٹ ٹائم", "SGT": "سنگاپور سٹینڈرڈ ٹائم", "MEZ": "وسطی یورپ کا معیاری وقت", "SRT": "سورینام کا وقت", "COT": "کولمبیا کا معیاری وقت", "WARST": "مغربی ارجنٹینا کا موسم گرما کا وقت", "ART": "ارجنٹینا سٹینڈرڈ ٹائم", "AEDT": "آسٹریلین ایسٹرن ڈے لائٹ ٹائم", "SAST": "جنوبی افریقہ سٹینڈرڈ ٹائم", "BT": "بھوٹان کا وقت", "HKT": "ہانگ کانگ سٹینڈرڈ ٹائم", "WART": "مغربی ارجنٹینا کا معیاری وقت"},
  67. }
  68. }
  69. // Locale returns the current translators string locale
  70. func (ur *ur_PK) Locale() string {
  71. return ur.locale
  72. }
  73. // PluralsCardinal returns the list of cardinal plural rules associated with 'ur_PK'
  74. func (ur *ur_PK) PluralsCardinal() []locales.PluralRule {
  75. return ur.pluralsCardinal
  76. }
  77. // PluralsOrdinal returns the list of ordinal plural rules associated with 'ur_PK'
  78. func (ur *ur_PK) PluralsOrdinal() []locales.PluralRule {
  79. return ur.pluralsOrdinal
  80. }
  81. // PluralsRange returns the list of range plural rules associated with 'ur_PK'
  82. func (ur *ur_PK) PluralsRange() []locales.PluralRule {
  83. return ur.pluralsRange
  84. }
  85. // CardinalPluralRule returns the cardinal PluralRule given 'num' and digits/precision of 'v' for 'ur_PK'
  86. func (ur *ur_PK) CardinalPluralRule(num float64, v uint64) locales.PluralRule {
  87. n := math.Abs(num)
  88. i := int64(n)
  89. if i == 1 && v == 0 {
  90. return locales.PluralRuleOne
  91. }
  92. return locales.PluralRuleOther
  93. }
  94. // OrdinalPluralRule returns the ordinal PluralRule given 'num' and digits/precision of 'v' for 'ur_PK'
  95. func (ur *ur_PK) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
  96. return locales.PluralRuleOther
  97. }
  98. // RangePluralRule returns the ordinal PluralRule given 'num1', 'num2' and digits/precision of 'v1' and 'v2' for 'ur_PK'
  99. func (ur *ur_PK) RangePluralRule(num1 float64, v1 uint64, num2 float64, v2 uint64) locales.PluralRule {
  100. return locales.PluralRuleOther
  101. }
  102. // MonthAbbreviated returns the locales abbreviated month given the 'month' provided
  103. func (ur *ur_PK) MonthAbbreviated(month time.Month) string {
  104. return ur.monthsAbbreviated[month]
  105. }
  106. // MonthsAbbreviated returns the locales abbreviated months
  107. func (ur *ur_PK) MonthsAbbreviated() []string {
  108. return ur.monthsAbbreviated[1:]
  109. }
  110. // MonthNarrow returns the locales narrow month given the 'month' provided
  111. func (ur *ur_PK) MonthNarrow(month time.Month) string {
  112. return ur.monthsNarrow[month]
  113. }
  114. // MonthsNarrow returns the locales narrow months
  115. func (ur *ur_PK) MonthsNarrow() []string {
  116. return ur.monthsNarrow[1:]
  117. }
  118. // MonthWide returns the locales wide month given the 'month' provided
  119. func (ur *ur_PK) MonthWide(month time.Month) string {
  120. return ur.monthsWide[month]
  121. }
  122. // MonthsWide returns the locales wide months
  123. func (ur *ur_PK) MonthsWide() []string {
  124. return ur.monthsWide[1:]
  125. }
  126. // WeekdayAbbreviated returns the locales abbreviated weekday given the 'weekday' provided
  127. func (ur *ur_PK) WeekdayAbbreviated(weekday time.Weekday) string {
  128. return ur.daysAbbreviated[weekday]
  129. }
  130. // WeekdaysAbbreviated returns the locales abbreviated weekdays
  131. func (ur *ur_PK) WeekdaysAbbreviated() []string {
  132. return ur.daysAbbreviated
  133. }
  134. // WeekdayNarrow returns the locales narrow weekday given the 'weekday' provided
  135. func (ur *ur_PK) WeekdayNarrow(weekday time.Weekday) string {
  136. return ur.daysNarrow[weekday]
  137. }
  138. // WeekdaysNarrow returns the locales narrow weekdays
  139. func (ur *ur_PK) WeekdaysNarrow() []string {
  140. return ur.daysNarrow
  141. }
  142. // WeekdayShort returns the locales short weekday given the 'weekday' provided
  143. func (ur *ur_PK) WeekdayShort(weekday time.Weekday) string {
  144. return ur.daysShort[weekday]
  145. }
  146. // WeekdaysShort returns the locales short weekdays
  147. func (ur *ur_PK) WeekdaysShort() []string {
  148. return ur.daysShort
  149. }
  150. // WeekdayWide returns the locales wide weekday given the 'weekday' provided
  151. func (ur *ur_PK) WeekdayWide(weekday time.Weekday) string {
  152. return ur.daysWide[weekday]
  153. }
  154. // WeekdaysWide returns the locales wide weekdays
  155. func (ur *ur_PK) WeekdaysWide() []string {
  156. return ur.daysWide
  157. }
  158. // Decimal returns the decimal point of number
  159. func (ur *ur_PK) Decimal() string {
  160. return ur.decimal
  161. }
  162. // Group returns the group of number
  163. func (ur *ur_PK) Group() string {
  164. return ur.group
  165. }
  166. // Group returns the minus sign of number
  167. func (ur *ur_PK) Minus() string {
  168. return ur.minus
  169. }
  170. // FmtNumber returns 'num' with digits/precision of 'v' for 'ur_PK' and handles both Whole and Real numbers based on 'v'
  171. func (ur *ur_PK) FmtNumber(num float64, v uint64) string {
  172. s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  173. l := len(s) + 5 + 1*len(s[:len(s)-int(v)-1])/3
  174. count := 0
  175. inWhole := v == 0
  176. b := make([]byte, 0, l)
  177. for i := len(s) - 1; i >= 0; i-- {
  178. if s[i] == '.' {
  179. b = append(b, ur.decimal[0])
  180. inWhole = true
  181. continue
  182. }
  183. if inWhole {
  184. if count == 3 {
  185. b = append(b, ur.group[0])
  186. count = 1
  187. } else {
  188. count++
  189. }
  190. }
  191. b = append(b, s[i])
  192. }
  193. if num < 0 {
  194. for j := len(ur.minus) - 1; j >= 0; j-- {
  195. b = append(b, ur.minus[j])
  196. }
  197. }
  198. // reverse
  199. for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
  200. b[i], b[j] = b[j], b[i]
  201. }
  202. return string(b)
  203. }
  204. // FmtPercent returns 'num' with digits/precision of 'v' for 'ur_PK' and handles both Whole and Real numbers based on 'v'
  205. // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
  206. func (ur *ur_PK) FmtPercent(num float64, v uint64) string {
  207. s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  208. l := len(s) + 6
  209. b := make([]byte, 0, l)
  210. for i := len(s) - 1; i >= 0; i-- {
  211. if s[i] == '.' {
  212. b = append(b, ur.decimal[0])
  213. continue
  214. }
  215. b = append(b, s[i])
  216. }
  217. if num < 0 {
  218. for j := len(ur.minus) - 1; j >= 0; j-- {
  219. b = append(b, ur.minus[j])
  220. }
  221. }
  222. // reverse
  223. for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
  224. b[i], b[j] = b[j], b[i]
  225. }
  226. b = append(b, ur.percent...)
  227. return string(b)
  228. }
  229. // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'ur_PK'
  230. func (ur *ur_PK) FmtCurrency(num float64, v uint64, currency currency.Type) string {
  231. s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  232. symbol := ur.currencies[currency]
  233. l := len(s) + len(symbol) + 5 + 1*len(s[:len(s)-int(v)-1])/3
  234. count := 0
  235. inWhole := v == 0
  236. b := make([]byte, 0, l)
  237. for i := len(s) - 1; i >= 0; i-- {
  238. if s[i] == '.' {
  239. b = append(b, ur.decimal[0])
  240. inWhole = true
  241. continue
  242. }
  243. if inWhole {
  244. if count == 3 {
  245. b = append(b, ur.group[0])
  246. count = 1
  247. } else {
  248. count++
  249. }
  250. }
  251. b = append(b, s[i])
  252. }
  253. for j := len(symbol) - 1; j >= 0; j-- {
  254. b = append(b, symbol[j])
  255. }
  256. if num < 0 {
  257. for j := len(ur.minus) - 1; j >= 0; j-- {
  258. b = append(b, ur.minus[j])
  259. }
  260. }
  261. // reverse
  262. for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
  263. b[i], b[j] = b[j], b[i]
  264. }
  265. if int(v) < 2 {
  266. if v == 0 {
  267. b = append(b, ur.decimal...)
  268. }
  269. for i := 0; i < 2-int(v); i++ {
  270. b = append(b, '0')
  271. }
  272. }
  273. return string(b)
  274. }
  275. // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'ur_PK'
  276. // in accounting notation.
  277. func (ur *ur_PK) FmtAccounting(num float64, v uint64, currency currency.Type) string {
  278. s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  279. symbol := ur.currencies[currency]
  280. l := len(s) + len(symbol) + 5 + 1*len(s[:len(s)-int(v)-1])/3
  281. count := 0
  282. inWhole := v == 0
  283. b := make([]byte, 0, l)
  284. for i := len(s) - 1; i >= 0; i-- {
  285. if s[i] == '.' {
  286. b = append(b, ur.decimal[0])
  287. inWhole = true
  288. continue
  289. }
  290. if inWhole {
  291. if count == 3 {
  292. b = append(b, ur.group[0])
  293. count = 1
  294. } else {
  295. count++
  296. }
  297. }
  298. b = append(b, s[i])
  299. }
  300. if num < 0 {
  301. for j := len(symbol) - 1; j >= 0; j-- {
  302. b = append(b, symbol[j])
  303. }
  304. for j := len(ur.minus) - 1; j >= 0; j-- {
  305. b = append(b, ur.minus[j])
  306. }
  307. } else {
  308. for j := len(symbol) - 1; j >= 0; j-- {
  309. b = append(b, symbol[j])
  310. }
  311. }
  312. // reverse
  313. for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
  314. b[i], b[j] = b[j], b[i]
  315. }
  316. if int(v) < 2 {
  317. if v == 0 {
  318. b = append(b, ur.decimal...)
  319. }
  320. for i := 0; i < 2-int(v); i++ {
  321. b = append(b, '0')
  322. }
  323. }
  324. return string(b)
  325. }
  326. // FmtDateShort returns the short date representation of 't' for 'ur_PK'
  327. func (ur *ur_PK) FmtDateShort(t time.Time) string {
  328. b := make([]byte, 0, 32)
  329. b = strconv.AppendInt(b, int64(t.Day()), 10)
  330. b = append(b, []byte{0x2f}...)
  331. b = strconv.AppendInt(b, int64(t.Month()), 10)
  332. b = append(b, []byte{0x2f}...)
  333. if t.Year() > 9 {
  334. b = append(b, strconv.Itoa(t.Year())[2:]...)
  335. } else {
  336. b = append(b, strconv.Itoa(t.Year())[1:]...)
  337. }
  338. return string(b)
  339. }
  340. // FmtDateMedium returns the medium date representation of 't' for 'ur_PK'
  341. func (ur *ur_PK) FmtDateMedium(t time.Time) string {
  342. b := make([]byte, 0, 32)
  343. b = append(b, ur.monthsAbbreviated[t.Month()]...)
  344. b = append(b, []byte{0x20}...)
  345. b = strconv.AppendInt(b, int64(t.Day()), 10)
  346. b = append(b, []byte{0x2c, 0x20}...)
  347. if t.Year() > 0 {
  348. b = strconv.AppendInt(b, int64(t.Year()), 10)
  349. } else {
  350. b = strconv.AppendInt(b, int64(-t.Year()), 10)
  351. }
  352. return string(b)
  353. }
  354. // FmtDateLong returns the long date representation of 't' for 'ur_PK'
  355. func (ur *ur_PK) FmtDateLong(t time.Time) string {
  356. b := make([]byte, 0, 32)
  357. b = append(b, ur.monthsWide[t.Month()]...)
  358. b = append(b, []byte{0x20}...)
  359. b = strconv.AppendInt(b, int64(t.Day()), 10)
  360. b = append(b, []byte{0x2c, 0x20}...)
  361. if t.Year() > 0 {
  362. b = strconv.AppendInt(b, int64(t.Year()), 10)
  363. } else {
  364. b = strconv.AppendInt(b, int64(-t.Year()), 10)
  365. }
  366. return string(b)
  367. }
  368. // FmtDateFull returns the full date representation of 't' for 'ur_PK'
  369. func (ur *ur_PK) FmtDateFull(t time.Time) string {
  370. b := make([]byte, 0, 32)
  371. b = append(b, ur.daysWide[t.Weekday()]...)
  372. b = append(b, []byte{0x2c, 0x20}...)
  373. b = append(b, ur.monthsWide[t.Month()]...)
  374. b = append(b, []byte{0x20}...)
  375. b = strconv.AppendInt(b, int64(t.Day()), 10)
  376. b = append(b, []byte{0x2c, 0x20}...)
  377. if t.Year() > 0 {
  378. b = strconv.AppendInt(b, int64(t.Year()), 10)
  379. } else {
  380. b = strconv.AppendInt(b, int64(-t.Year()), 10)
  381. }
  382. return string(b)
  383. }
  384. // FmtTimeShort returns the short time representation of 't' for 'ur_PK'
  385. func (ur *ur_PK) FmtTimeShort(t time.Time) string {
  386. b := make([]byte, 0, 32)
  387. h := t.Hour()
  388. if h > 12 {
  389. h -= 12
  390. }
  391. b = strconv.AppendInt(b, int64(h), 10)
  392. b = append(b, ur.timeSeparator...)
  393. if t.Minute() < 10 {
  394. b = append(b, '0')
  395. }
  396. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  397. b = append(b, []byte{0x20}...)
  398. if t.Hour() < 12 {
  399. b = append(b, ur.periodsAbbreviated[0]...)
  400. } else {
  401. b = append(b, ur.periodsAbbreviated[1]...)
  402. }
  403. return string(b)
  404. }
  405. // FmtTimeMedium returns the medium time representation of 't' for 'ur_PK'
  406. func (ur *ur_PK) FmtTimeMedium(t time.Time) string {
  407. b := make([]byte, 0, 32)
  408. h := t.Hour()
  409. if h > 12 {
  410. h -= 12
  411. }
  412. b = strconv.AppendInt(b, int64(h), 10)
  413. b = append(b, ur.timeSeparator...)
  414. if t.Minute() < 10 {
  415. b = append(b, '0')
  416. }
  417. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  418. b = append(b, ur.timeSeparator...)
  419. if t.Second() < 10 {
  420. b = append(b, '0')
  421. }
  422. b = strconv.AppendInt(b, int64(t.Second()), 10)
  423. b = append(b, []byte{0x20}...)
  424. if t.Hour() < 12 {
  425. b = append(b, ur.periodsAbbreviated[0]...)
  426. } else {
  427. b = append(b, ur.periodsAbbreviated[1]...)
  428. }
  429. return string(b)
  430. }
  431. // FmtTimeLong returns the long time representation of 't' for 'ur_PK'
  432. func (ur *ur_PK) FmtTimeLong(t time.Time) string {
  433. b := make([]byte, 0, 32)
  434. h := t.Hour()
  435. if h > 12 {
  436. h -= 12
  437. }
  438. b = strconv.AppendInt(b, int64(h), 10)
  439. b = append(b, ur.timeSeparator...)
  440. if t.Minute() < 10 {
  441. b = append(b, '0')
  442. }
  443. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  444. b = append(b, ur.timeSeparator...)
  445. if t.Second() < 10 {
  446. b = append(b, '0')
  447. }
  448. b = strconv.AppendInt(b, int64(t.Second()), 10)
  449. b = append(b, []byte{0x20}...)
  450. if t.Hour() < 12 {
  451. b = append(b, ur.periodsAbbreviated[0]...)
  452. } else {
  453. b = append(b, ur.periodsAbbreviated[1]...)
  454. }
  455. b = append(b, []byte{0x20}...)
  456. tz, _ := t.Zone()
  457. b = append(b, tz...)
  458. return string(b)
  459. }
  460. // FmtTimeFull returns the full time representation of 't' for 'ur_PK'
  461. func (ur *ur_PK) FmtTimeFull(t time.Time) string {
  462. b := make([]byte, 0, 32)
  463. h := t.Hour()
  464. if h > 12 {
  465. h -= 12
  466. }
  467. b = strconv.AppendInt(b, int64(h), 10)
  468. b = append(b, ur.timeSeparator...)
  469. if t.Minute() < 10 {
  470. b = append(b, '0')
  471. }
  472. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  473. b = append(b, ur.timeSeparator...)
  474. if t.Second() < 10 {
  475. b = append(b, '0')
  476. }
  477. b = strconv.AppendInt(b, int64(t.Second()), 10)
  478. b = append(b, []byte{0x20}...)
  479. if t.Hour() < 12 {
  480. b = append(b, ur.periodsAbbreviated[0]...)
  481. } else {
  482. b = append(b, ur.periodsAbbreviated[1]...)
  483. }
  484. b = append(b, []byte{0x20}...)
  485. tz, _ := t.Zone()
  486. if btz, ok := ur.timezones[tz]; ok {
  487. b = append(b, btz...)
  488. } else {
  489. b = append(b, tz...)
  490. }
  491. return string(b)
  492. }