1 package pgtype
2
3 import (
4 "database/sql/driver"
5 "fmt"
6 "net"
7 )
8
9 type Macaddr struct {
10 Addr net.HardwareAddr
11 Status Status
12 }
13
14 func (dst *Macaddr) Set(src interface{}) error {
15 if src == nil {
16 *dst = Macaddr{Status: Null}
17 return nil
18 }
19
20 if value, ok := src.(interface{ Get() interface{} }); ok {
21 value2 := value.Get()
22 if value2 != value {
23 return dst.Set(value2)
24 }
25 }
26
27 switch value := src.(type) {
28 case net.HardwareAddr:
29 addr := make(net.HardwareAddr, len(value))
30 copy(addr, value)
31 *dst = Macaddr{Addr: addr, Status: Present}
32 case string:
33 addr, err := net.ParseMAC(value)
34 if err != nil {
35 return err
36 }
37 *dst = Macaddr{Addr: addr, Status: Present}
38 case *net.HardwareAddr:
39 if value == nil {
40 *dst = Macaddr{Status: Null}
41 } else {
42 return dst.Set(*value)
43 }
44 case *string:
45 if value == nil {
46 *dst = Macaddr{Status: Null}
47 } else {
48 return dst.Set(*value)
49 }
50 default:
51 if originalSrc, ok := underlyingPtrType(src); ok {
52 return dst.Set(originalSrc)
53 }
54 return fmt.Errorf("cannot convert %v to Macaddr", value)
55 }
56
57 return nil
58 }
59
60 func (dst Macaddr) Get() interface{} {
61 switch dst.Status {
62 case Present:
63 return dst.Addr
64 case Null:
65 return nil
66 default:
67 return dst.Status
68 }
69 }
70
71 func (src *Macaddr) AssignTo(dst interface{}) error {
72 switch src.Status {
73 case Present:
74 switch v := dst.(type) {
75 case *net.HardwareAddr:
76 *v = make(net.HardwareAddr, len(src.Addr))
77 copy(*v, src.Addr)
78 return nil
79 case *string:
80 *v = src.Addr.String()
81 return nil
82 default:
83 if nextDst, retry := GetAssignToDstType(dst); retry {
84 return src.AssignTo(nextDst)
85 }
86 return fmt.Errorf("unable to assign to %T", dst)
87 }
88 case Null:
89 return NullAssignTo(dst)
90 }
91
92 return fmt.Errorf("cannot decode %#v into %T", src, dst)
93 }
94
95 func (dst *Macaddr) DecodeText(ci *ConnInfo, src []byte) error {
96 if src == nil {
97 *dst = Macaddr{Status: Null}
98 return nil
99 }
100
101 addr, err := net.ParseMAC(string(src))
102 if err != nil {
103 return err
104 }
105
106 *dst = Macaddr{Addr: addr, Status: Present}
107 return nil
108 }
109
110 func (dst *Macaddr) DecodeBinary(ci *ConnInfo, src []byte) error {
111 if src == nil {
112 *dst = Macaddr{Status: Null}
113 return nil
114 }
115
116 if len(src) != 6 {
117 return fmt.Errorf("Received an invalid size for a macaddr: %d", len(src))
118 }
119
120 addr := make(net.HardwareAddr, 6)
121 copy(addr, src)
122
123 *dst = Macaddr{Addr: addr, Status: Present}
124
125 return nil
126 }
127
128 func (src Macaddr) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
129 switch src.Status {
130 case Null:
131 return nil, nil
132 case Undefined:
133 return nil, errUndefined
134 }
135
136 return append(buf, src.Addr.String()...), nil
137 }
138
139
140 func (src Macaddr) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
141 switch src.Status {
142 case Null:
143 return nil, nil
144 case Undefined:
145 return nil, errUndefined
146 }
147
148 return append(buf, src.Addr...), nil
149 }
150
151
152 func (dst *Macaddr) Scan(src interface{}) error {
153 if src == nil {
154 *dst = Macaddr{Status: Null}
155 return nil
156 }
157
158 switch src := src.(type) {
159 case string:
160 return dst.DecodeText(nil, []byte(src))
161 case []byte:
162 srcCopy := make([]byte, len(src))
163 copy(srcCopy, src)
164 return dst.DecodeText(nil, srcCopy)
165 }
166
167 return fmt.Errorf("cannot scan %T", src)
168 }
169
170
171 func (src Macaddr) Value() (driver.Value, error) {
172 return EncodeValueText(src)
173 }
174
View as plain text