vendorify
diff --git a/go/vendor/github.com/go-openapi/strfmt/default.go b/go/vendor/github.com/go-openapi/strfmt/default.go
new file mode 100644
index 0000000..13235ec
--- /dev/null
+++ b/go/vendor/github.com/go-openapi/strfmt/default.go
@@ -0,0 +1,1853 @@
+// Copyright 2015 go-swagger maintainers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package strfmt
+
+import (
+ "database/sql/driver"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "net/mail"
+ "regexp"
+ "strings"
+
+ "github.com/asaskevich/govalidator"
+ "github.com/globalsign/mgo/bson"
+ "github.com/mailru/easyjson/jlexer"
+ "github.com/mailru/easyjson/jwriter"
+)
+
+const (
+ // HostnamePattern http://json-schema.org/latest/json-schema-validation.html#anchor114
+ // A string instance is valid against this attribute if it is a valid
+ // representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
+ // http://tools.ietf.org/html/rfc1034#section-3.5
+ // <digit> ::= any one of the ten digits 0 through 9
+ // var digit = /[0-9]/;
+ // <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
+ // var letter = /[a-zA-Z]/;
+ // <let-dig> ::= <letter> | <digit>
+ // var letDig = /[0-9a-zA-Z]/;
+ // <let-dig-hyp> ::= <let-dig> | "-"
+ // var letDigHyp = /[-0-9a-zA-Z]/;
+ // <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+ // var ldhStr = /[-0-9a-zA-Z]+/;
+ // <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
+ // var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
+ // <subdomain> ::= <label> | <subdomain> "." <label>
+ // var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
+ // <domain> ::= <subdomain> | " "
+ HostnamePattern = `^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$`
+ // UUIDPattern Regex for UUID that allows uppercase
+ UUIDPattern = `(?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$`
+ // UUID3Pattern Regex for UUID3 that allows uppercase
+ UUID3Pattern = `(?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?3[0-9a-f]{3}-?[0-9a-f]{4}-?[0-9a-f]{12}$`
+ // UUID4Pattern Regex for UUID4 that allows uppercase
+ UUID4Pattern = `(?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?4[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$`
+ // UUID5Pattern Regex for UUID5 that allows uppercase
+ UUID5Pattern = `(?i)^[0-9a-f]{8}-?[0-9a-f]{4}-?5[0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$`
+ // json null type
+ jsonNull = "null"
+)
+
+var (
+ rxHostname = regexp.MustCompile(HostnamePattern)
+ rxUUID = regexp.MustCompile(UUIDPattern)
+ rxUUID3 = regexp.MustCompile(UUID3Pattern)
+ rxUUID4 = regexp.MustCompile(UUID4Pattern)
+ rxUUID5 = regexp.MustCompile(UUID5Pattern)
+)
+
+// IsHostname returns true when the string is a valid hostname
+func IsHostname(str string) bool {
+ if !rxHostname.MatchString(str) {
+ return false
+ }
+
+ // the sum of all label octets and label lengths is limited to 255.
+ if len(str) > 255 {
+ return false
+ }
+
+ // Each node has a label, which is zero to 63 octets in length
+ parts := strings.Split(str, ".")
+ valid := true
+ for _, p := range parts {
+ if len(p) > 63 {
+ valid = false
+ }
+ }
+ return valid
+}
+
+// IsUUID returns true is the string matches a UUID, upper case is allowed
+func IsUUID(str string) bool {
+ return rxUUID.MatchString(str)
+}
+
+// IsUUID3 returns true is the string matches a UUID, upper case is allowed
+func IsUUID3(str string) bool {
+ return rxUUID3.MatchString(str)
+}
+
+// IsUUID4 returns true is the string matches a UUID, upper case is allowed
+func IsUUID4(str string) bool {
+ return rxUUID4.MatchString(str)
+}
+
+// IsUUID5 returns true is the string matches a UUID, upper case is allowed
+func IsUUID5(str string) bool {
+ return rxUUID5.MatchString(str)
+}
+
+// Validates an email address.
+func IsEmail(str string) bool {
+ addr, e := mail.ParseAddress(str)
+ return e == nil && addr.Address != ""
+}
+
+func init() {
+ // register formats in the default registry:
+ // - byte
+ // - creditcard
+ // - email
+ // - hexcolor
+ // - hostname
+ // - ipv4
+ // - ipv6
+ // - isbn
+ // - isbn10
+ // - isbn13
+ // - mac
+ // - password
+ // - rgbcolor
+ // - ssn
+ // - uri
+ // - uuid
+ // - uuid3
+ // - uuid4
+ // - uuid5
+ u := URI("")
+ Default.Add("uri", &u, govalidator.IsRequestURI)
+
+ eml := Email("")
+ Default.Add("email", &eml, IsEmail)
+
+ hn := Hostname("")
+ Default.Add("hostname", &hn, IsHostname)
+
+ ip4 := IPv4("")
+ Default.Add("ipv4", &ip4, govalidator.IsIPv4)
+
+ ip6 := IPv6("")
+ Default.Add("ipv6", &ip6, govalidator.IsIPv6)
+
+ mac := MAC("")
+ Default.Add("mac", &mac, govalidator.IsMAC)
+
+ uid := UUID("")
+ Default.Add("uuid", &uid, IsUUID)
+
+ uid3 := UUID3("")
+ Default.Add("uuid3", &uid3, IsUUID3)
+
+ uid4 := UUID4("")
+ Default.Add("uuid4", &uid4, IsUUID4)
+
+ uid5 := UUID5("")
+ Default.Add("uuid5", &uid5, IsUUID5)
+
+ isbn := ISBN("")
+ Default.Add("isbn", &isbn, func(str string) bool { return govalidator.IsISBN10(str) || govalidator.IsISBN13(str) })
+
+ isbn10 := ISBN10("")
+ Default.Add("isbn10", &isbn10, govalidator.IsISBN10)
+
+ isbn13 := ISBN13("")
+ Default.Add("isbn13", &isbn13, govalidator.IsISBN13)
+
+ cc := CreditCard("")
+ Default.Add("creditcard", &cc, govalidator.IsCreditCard)
+
+ ssn := SSN("")
+ Default.Add("ssn", &ssn, govalidator.IsSSN)
+
+ hc := HexColor("")
+ Default.Add("hexcolor", &hc, govalidator.IsHexcolor)
+
+ rc := RGBColor("")
+ Default.Add("rgbcolor", &rc, govalidator.IsRGBcolor)
+
+ b64 := Base64([]byte(nil))
+ Default.Add("byte", &b64, govalidator.IsBase64)
+
+ pw := Password("")
+ Default.Add("password", &pw, func(_ string) bool { return true })
+}
+
+/* unused:
+var formatCheckers = map[string]Validator{
+ "byte": govalidator.IsBase64,
+}
+*/
+
+// Base64 represents a base64 encoded string
+//
+// swagger:strfmt byte
+type Base64 []byte
+
+// MarshalText turns this instance into text
+func (b Base64) MarshalText() ([]byte, error) {
+ enc := base64.URLEncoding
+ src := []byte(b)
+ buf := make([]byte, enc.EncodedLen(len(src)))
+ enc.Encode(buf, src)
+ return buf, nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (b *Base64) UnmarshalText(data []byte) error { // validation is performed later on
+ enc := base64.URLEncoding
+ dbuf := make([]byte, enc.DecodedLen(len(data)))
+
+ n, err := enc.Decode(dbuf, data)
+ if err != nil {
+ return err
+ }
+
+ *b = dbuf[:n]
+ return nil
+}
+
+// Scan read a value from a database driver
+func (b *Base64) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *b = Base64(string(v))
+ case string:
+ *b = Base64(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.Base64 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (b Base64) Value() (driver.Value, error) {
+ return driver.Value(string(b)), nil
+}
+
+func (b Base64) String() string {
+ return string(b)
+}
+
+// MarshalJSON returns the Base64 as JSON
+func (b Base64) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ b.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the Base64 to a easyjson.Writer
+func (b Base64) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(base64.StdEncoding.EncodeToString([]byte(b)))
+}
+
+// UnmarshalJSON sets the Base64 from JSON
+func (b *Base64) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ b.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the Base64 from a easyjson.Lexer
+func (b *Base64) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ enc := base64.StdEncoding
+ dbuf := make([]byte, enc.DecodedLen(len(data)))
+
+ n, err := enc.Decode(dbuf, []byte(data))
+ if err != nil {
+ in.AddError(err)
+ return
+ }
+
+ *b = dbuf[:n]
+ }
+}
+
+// GetBSON returns the Base64 as a bson.M{} map.
+func (b *Base64) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*b)}, nil
+}
+
+// SetBSON sets the Base64 from raw bson data
+func (b *Base64) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *b = Base64(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as Base64")
+}
+
+// URI represents the uri string format as specified by the json schema spec
+//
+// swagger:strfmt uri
+type URI string
+
+// MarshalText turns this instance into text
+func (u URI) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *URI) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = URI(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *URI) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = URI(string(v))
+ case string:
+ *u = URI(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.URI from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u URI) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u URI) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the URI as JSON
+func (u URI) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the URI to a easyjson.Writer
+func (u URI) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the URI from JSON
+func (u *URI) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the URI from a easyjson.Lexer
+func (u *URI) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = URI(data)
+ }
+}
+
+// GetBSON returns the URI as a bson.M{} map.
+func (u *URI) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the URI from raw bson data
+func (u *URI) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = URI(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as URI")
+}
+
+// Email represents the email string format as specified by the json schema spec
+//
+// swagger:strfmt email
+type Email string
+
+// MarshalText turns this instance into text
+func (e Email) MarshalText() ([]byte, error) {
+ return []byte(string(e)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (e *Email) UnmarshalText(data []byte) error { // validation is performed later on
+ *e = Email(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (e *Email) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *e = Email(string(v))
+ case string:
+ *e = Email(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.Email from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (e Email) Value() (driver.Value, error) {
+ return driver.Value(string(e)), nil
+}
+
+func (e Email) String() string {
+ return string(e)
+}
+
+// MarshalJSON returns the Email as JSON
+func (e Email) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ e.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the Email to a easyjson.Writer
+func (e Email) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(e))
+}
+
+// UnmarshalJSON sets the Email from JSON
+func (e *Email) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ e.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the Email from a easyjson.Lexer
+func (e *Email) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *e = Email(data)
+ }
+}
+
+// GetBSON returns the Email as a bson.M{} map.
+func (e *Email) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*e)}, nil
+}
+
+// SetBSON sets the Email from raw bson data
+func (e *Email) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *e = Email(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as Email")
+}
+
+// Hostname represents the hostname string format as specified by the json schema spec
+//
+// swagger:strfmt hostname
+type Hostname string
+
+// MarshalText turns this instance into text
+func (h Hostname) MarshalText() ([]byte, error) {
+ return []byte(string(h)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (h *Hostname) UnmarshalText(data []byte) error { // validation is performed later on
+ *h = Hostname(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (h *Hostname) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *h = Hostname(string(v))
+ case string:
+ *h = Hostname(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.Hostname from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (h Hostname) Value() (driver.Value, error) {
+ return driver.Value(string(h)), nil
+}
+
+func (h Hostname) String() string {
+ return string(h)
+}
+
+// MarshalJSON returns the Hostname as JSON
+func (h Hostname) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ h.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the Hostname to a easyjson.Writer
+func (h Hostname) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(h))
+}
+
+// UnmarshalJSON sets the Hostname from JSON
+func (h *Hostname) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ h.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the Hostname from a easyjson.Lexer
+func (h *Hostname) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *h = Hostname(data)
+ }
+}
+
+// GetBSON returns the Hostname as a bson.M{} map.
+func (h *Hostname) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*h)}, nil
+}
+
+// SetBSON sets the Hostname from raw bson data
+func (h *Hostname) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *h = Hostname(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as Hostname")
+}
+
+// IPv4 represents an IP v4 address
+//
+// swagger:strfmt ipv4
+type IPv4 string
+
+// MarshalText turns this instance into text
+func (u IPv4) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *IPv4) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = IPv4(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *IPv4) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = IPv4(string(v))
+ case string:
+ *u = IPv4(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.IPv4 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u IPv4) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u IPv4) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the IPv4 as JSON
+func (u IPv4) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the IPv4 to a easyjson.Writer
+func (u IPv4) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the IPv4 from JSON
+func (u *IPv4) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the IPv4 from a easyjson.Lexer
+func (u *IPv4) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = IPv4(data)
+ }
+}
+
+// GetBSON returns the IPv4 as a bson.M{} map.
+func (u *IPv4) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the IPv4 from raw bson data
+func (u *IPv4) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = IPv4(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as IPv4")
+}
+
+// IPv6 represents an IP v6 address
+//
+// swagger:strfmt ipv6
+type IPv6 string
+
+// MarshalText turns this instance into text
+func (u IPv6) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *IPv6) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = IPv6(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *IPv6) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = IPv6(string(v))
+ case string:
+ *u = IPv6(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.IPv6 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u IPv6) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u IPv6) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the IPv6 as JSON
+func (u IPv6) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the IPv6 to a easyjson.Writer
+func (u IPv6) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the IPv6 from JSON
+func (u *IPv6) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the IPv6 from a easyjson.Lexer
+func (u *IPv6) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = IPv6(data)
+ }
+}
+
+// GetBSON returns the IPv6 as a bson.M{} map.
+func (u *IPv6) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the IPv6 from raw bson data
+func (u *IPv6) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = IPv6(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as IPv6")
+}
+
+// MAC represents a 48 bit MAC address
+//
+// swagger:strfmt mac
+type MAC string
+
+// MarshalText turns this instance into text
+func (u MAC) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *MAC) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = MAC(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *MAC) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = MAC(string(v))
+ case string:
+ *u = MAC(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.IPv4 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u MAC) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u MAC) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the MAC as JSON
+func (u MAC) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the MAC to a easyjson.Writer
+func (u MAC) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the MAC from JSON
+func (u *MAC) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the MAC from a easyjson.Lexer
+func (u *MAC) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = MAC(data)
+ }
+}
+
+// GetBSON returns the MAC as a bson.M{} map.
+func (u *MAC) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the MAC from raw bson data
+func (u *MAC) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = MAC(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as MAC")
+}
+
+// UUID represents a uuid string format
+//
+// swagger:strfmt uuid
+type UUID string
+
+// MarshalText turns this instance into text
+func (u UUID) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *UUID) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = UUID(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *UUID) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = UUID(string(v))
+ case string:
+ *u = UUID(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.UUID from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u UUID) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u UUID) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the UUID as JSON
+func (u UUID) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the UUID to a easyjson.Writer
+func (u UUID) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the UUID from JSON
+func (u *UUID) UnmarshalJSON(data []byte) error {
+ if string(data) == jsonNull {
+ return nil
+ }
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the UUID from a easyjson.Lexer
+func (u *UUID) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = UUID(data)
+ }
+}
+
+// GetBSON returns the UUID as a bson.M{} map.
+func (u *UUID) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the UUID from raw bson data
+func (u *UUID) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = UUID(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as UUID")
+}
+
+// UUID3 represents a uuid3 string format
+//
+// swagger:strfmt uuid3
+type UUID3 string
+
+// MarshalText turns this instance into text
+func (u UUID3) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *UUID3) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = UUID3(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *UUID3) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = UUID3(string(v))
+ case string:
+ *u = UUID3(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.UUID3 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u UUID3) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u UUID3) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the UUID3 as JSON
+func (u UUID3) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the UUID3 to a easyjson.Writer
+func (u UUID3) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the UUID3 from JSON
+func (u *UUID3) UnmarshalJSON(data []byte) error {
+ if string(data) == jsonNull {
+ return nil
+ }
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the UUID3 from a easyjson.Lexer
+func (u *UUID3) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = UUID3(data)
+ }
+}
+
+// GetBSON returns the UUID3 as a bson.M{} map.
+func (u *UUID3) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the UUID3 from raw bson data
+func (u *UUID3) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = UUID3(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as UUID3")
+}
+
+// UUID4 represents a uuid4 string format
+//
+// swagger:strfmt uuid4
+type UUID4 string
+
+// MarshalText turns this instance into text
+func (u UUID4) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *UUID4) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = UUID4(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *UUID4) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = UUID4(string(v))
+ case string:
+ *u = UUID4(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.UUID4 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u UUID4) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u UUID4) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the UUID4 as JSON
+func (u UUID4) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the UUID4 to a easyjson.Writer
+func (u UUID4) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the UUID4 from JSON
+func (u *UUID4) UnmarshalJSON(data []byte) error {
+ if string(data) == jsonNull {
+ return nil
+ }
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the UUID4 from a easyjson.Lexer
+func (u *UUID4) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = UUID4(data)
+ }
+}
+
+// GetBSON returns the UUID4 as a bson.M{} map.
+func (u *UUID4) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the UUID4 from raw bson data
+func (u *UUID4) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = UUID4(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as UUID4")
+}
+
+// UUID5 represents a uuid5 string format
+//
+// swagger:strfmt uuid5
+type UUID5 string
+
+// MarshalText turns this instance into text
+func (u UUID5) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *UUID5) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = UUID5(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *UUID5) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = UUID5(string(v))
+ case string:
+ *u = UUID5(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.UUID5 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u UUID5) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u UUID5) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the UUID5 as JSON
+func (u UUID5) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the UUID5 to a easyjson.Writer
+func (u UUID5) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the UUID5 from JSON
+func (u *UUID5) UnmarshalJSON(data []byte) error {
+ if string(data) == jsonNull {
+ return nil
+ }
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the UUID5 from a easyjson.Lexer
+func (u *UUID5) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = UUID5(data)
+ }
+}
+
+// GetBSON returns the UUID5 as a bson.M{} map.
+func (u *UUID5) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the UUID5 from raw bson data
+func (u *UUID5) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = UUID5(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as UUID5")
+}
+
+// ISBN represents an isbn string format
+//
+// swagger:strfmt isbn
+type ISBN string
+
+// MarshalText turns this instance into text
+func (u ISBN) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *ISBN) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = ISBN(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *ISBN) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = ISBN(string(v))
+ case string:
+ *u = ISBN(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.ISBN from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u ISBN) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u ISBN) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the ISBN as JSON
+func (u ISBN) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the ISBN to a easyjson.Writer
+func (u ISBN) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the ISBN from JSON
+func (u *ISBN) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the ISBN from a easyjson.Lexer
+func (u *ISBN) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = ISBN(data)
+ }
+}
+
+// GetBSON returns the ISBN as a bson.M{} map.
+func (u *ISBN) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the ISBN from raw bson data
+func (u *ISBN) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = ISBN(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as ISBN")
+}
+
+// ISBN10 represents an isbn 10 string format
+//
+// swagger:strfmt isbn10
+type ISBN10 string
+
+// MarshalText turns this instance into text
+func (u ISBN10) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *ISBN10) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = ISBN10(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *ISBN10) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = ISBN10(string(v))
+ case string:
+ *u = ISBN10(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.ISBN10 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u ISBN10) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u ISBN10) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the ISBN10 as JSON
+func (u ISBN10) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the ISBN10 to a easyjson.Writer
+func (u ISBN10) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the ISBN10 from JSON
+func (u *ISBN10) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the ISBN10 from a easyjson.Lexer
+func (u *ISBN10) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = ISBN10(data)
+ }
+}
+
+// GetBSON returns the ISBN10 as a bson.M{} map.
+func (u *ISBN10) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the ISBN10 from raw bson data
+func (u *ISBN10) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = ISBN10(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as ISBN10")
+}
+
+// ISBN13 represents an isbn 13 string format
+//
+// swagger:strfmt isbn13
+type ISBN13 string
+
+// MarshalText turns this instance into text
+func (u ISBN13) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *ISBN13) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = ISBN13(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *ISBN13) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = ISBN13(string(v))
+ case string:
+ *u = ISBN13(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.ISBN13 from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u ISBN13) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u ISBN13) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the ISBN13 as JSON
+func (u ISBN13) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the ISBN13 to a easyjson.Writer
+func (u ISBN13) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the ISBN13 from JSON
+func (u *ISBN13) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the ISBN13 from a easyjson.Lexer
+func (u *ISBN13) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = ISBN13(data)
+ }
+}
+
+// GetBSON returns the ISBN13 as a bson.M{} map.
+func (u *ISBN13) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the ISBN13 from raw bson data
+func (u *ISBN13) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = ISBN13(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as ISBN13")
+}
+
+// CreditCard represents a credit card string format
+//
+// swagger:strfmt creditcard
+type CreditCard string
+
+// MarshalText turns this instance into text
+func (u CreditCard) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *CreditCard) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = CreditCard(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *CreditCard) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = CreditCard(string(v))
+ case string:
+ *u = CreditCard(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.CreditCard from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u CreditCard) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u CreditCard) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the CreditCard as JSON
+func (u CreditCard) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the CreditCard to a easyjson.Writer
+func (u CreditCard) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the CreditCard from JSON
+func (u *CreditCard) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the CreditCard from a easyjson.Lexer
+func (u *CreditCard) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = CreditCard(data)
+ }
+}
+
+// GetBSON returns the CreditCard as a bson.M{} map.
+func (u *CreditCard) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the CreditCard from raw bson data
+func (u *CreditCard) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = CreditCard(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as CreditCard")
+}
+
+// SSN represents a social security string format
+//
+// swagger:strfmt ssn
+type SSN string
+
+// MarshalText turns this instance into text
+func (u SSN) MarshalText() ([]byte, error) {
+ return []byte(string(u)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (u *SSN) UnmarshalText(data []byte) error { // validation is performed later on
+ *u = SSN(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (u *SSN) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *u = SSN(string(v))
+ case string:
+ *u = SSN(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.SSN from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (u SSN) Value() (driver.Value, error) {
+ return driver.Value(string(u)), nil
+}
+
+func (u SSN) String() string {
+ return string(u)
+}
+
+// MarshalJSON returns the SSN as JSON
+func (u SSN) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ u.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the SSN to a easyjson.Writer
+func (u SSN) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(u))
+}
+
+// UnmarshalJSON sets the SSN from JSON
+func (u *SSN) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ u.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the SSN from a easyjson.Lexer
+func (u *SSN) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *u = SSN(data)
+ }
+}
+
+// GetBSON returns the SSN as a bson.M{} map.
+func (u *SSN) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*u)}, nil
+}
+
+// SetBSON sets the SSN from raw bson data
+func (u *SSN) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *u = SSN(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as SSN")
+}
+
+// HexColor represents a hex color string format
+//
+// swagger:strfmt hexcolor
+type HexColor string
+
+// MarshalText turns this instance into text
+func (h HexColor) MarshalText() ([]byte, error) {
+ return []byte(string(h)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (h *HexColor) UnmarshalText(data []byte) error { // validation is performed later on
+ *h = HexColor(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (h *HexColor) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *h = HexColor(string(v))
+ case string:
+ *h = HexColor(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.HexColor from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (h HexColor) Value() (driver.Value, error) {
+ return driver.Value(string(h)), nil
+}
+
+func (h HexColor) String() string {
+ return string(h)
+}
+
+// MarshalJSON returns the HexColor as JSON
+func (h HexColor) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ h.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the HexColor to a easyjson.Writer
+func (h HexColor) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(h))
+}
+
+// UnmarshalJSON sets the HexColor from JSON
+func (h *HexColor) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ h.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the HexColor from a easyjson.Lexer
+func (h *HexColor) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *h = HexColor(data)
+ }
+}
+
+// GetBSON returns the HexColor as a bson.M{} map.
+func (h *HexColor) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*h)}, nil
+}
+
+// SetBSON sets the HexColor from raw bson data
+func (h *HexColor) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *h = HexColor(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as HexColor")
+}
+
+// RGBColor represents a RGB color string format
+//
+// swagger:strfmt rgbcolor
+type RGBColor string
+
+// MarshalText turns this instance into text
+func (r RGBColor) MarshalText() ([]byte, error) {
+ return []byte(string(r)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (r *RGBColor) UnmarshalText(data []byte) error { // validation is performed later on
+ *r = RGBColor(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (r *RGBColor) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *r = RGBColor(string(v))
+ case string:
+ *r = RGBColor(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.RGBColor from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (r RGBColor) Value() (driver.Value, error) {
+ return driver.Value(string(r)), nil
+}
+
+func (r RGBColor) String() string {
+ return string(r)
+}
+
+// MarshalJSON returns the RGBColor as JSON
+func (r RGBColor) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ r.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the RGBColor to a easyjson.Writer
+func (r RGBColor) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(r))
+}
+
+// UnmarshalJSON sets the RGBColor from JSON
+func (r *RGBColor) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ r.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the RGBColor from a easyjson.Lexer
+func (r *RGBColor) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *r = RGBColor(data)
+ }
+}
+
+// GetBSON returns the RGBColor as a bson.M{} map.
+func (r *RGBColor) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*r)}, nil
+}
+
+// SetBSON sets the RGBColor from raw bson data
+func (r *RGBColor) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *r = RGBColor(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as RGBColor")
+}
+
+// Password represents a password.
+// This has no validations and is mainly used as a marker for UI components.
+//
+// swagger:strfmt password
+type Password string
+
+// MarshalText turns this instance into text
+func (r Password) MarshalText() ([]byte, error) {
+ return []byte(string(r)), nil
+}
+
+// UnmarshalText hydrates this instance from text
+func (r *Password) UnmarshalText(data []byte) error { // validation is performed later on
+ *r = Password(string(data))
+ return nil
+}
+
+// Scan read a value from a database driver
+func (r *Password) Scan(raw interface{}) error {
+ switch v := raw.(type) {
+ case []byte:
+ *r = Password(string(v))
+ case string:
+ *r = Password(v)
+ default:
+ return fmt.Errorf("cannot sql.Scan() strfmt.Password from: %#v", v)
+ }
+
+ return nil
+}
+
+// Value converts a value to a database driver value
+func (r Password) Value() (driver.Value, error) {
+ return driver.Value(string(r)), nil
+}
+
+func (r Password) String() string {
+ return string(r)
+}
+
+// MarshalJSON returns the Password as JSON
+func (r Password) MarshalJSON() ([]byte, error) {
+ var w jwriter.Writer
+ r.MarshalEasyJSON(&w)
+ return w.BuildBytes()
+}
+
+// MarshalEasyJSON writes the Password to a easyjson.Writer
+func (r Password) MarshalEasyJSON(w *jwriter.Writer) {
+ w.String(string(r))
+}
+
+// UnmarshalJSON sets the Password from JSON
+func (r *Password) UnmarshalJSON(data []byte) error {
+ l := jlexer.Lexer{Data: data}
+ r.UnmarshalEasyJSON(&l)
+ return l.Error()
+}
+
+// UnmarshalEasyJSON sets the Password from a easyjson.Lexer
+func (r *Password) UnmarshalEasyJSON(in *jlexer.Lexer) {
+ if data := in.String(); in.Ok() {
+ *r = Password(data)
+ }
+}
+
+// GetBSON returns the Password as a bson.M{} map.
+func (r *Password) GetBSON() (interface{}, error) {
+ return bson.M{"data": string(*r)}, nil
+}
+
+// SetBSON sets the Password from raw bson data
+func (r *Password) SetBSON(raw bson.Raw) error {
+ var m bson.M
+ if err := raw.Unmarshal(&m); err != nil {
+ return err
+ }
+
+ if data, ok := m["data"].(string); ok {
+ *r = Password(data)
+ return nil
+ }
+
+ return errors.New("couldn't unmarshal bson raw value as Password")
+}