gaspersic/learngo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

embed: timestamp iface

Browse Source
This commit is contained in:
Inanc Gumus
2019-10-15 13:30:43 +03:00
parent 29501c566c
commit 34cf7f7de2
7 changed files with 131 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
interfaces/09-stringer/list.go
View File

@ -24,7 +24,7 @@ type item interface {
//
// same as this:
// String() string
fmt.Stringer
// fmt.Stringer
}
type list []item
@ -42,11 +42,12 @@ func (l list) String() string {
// the builder.WriteString doesn't know about the stringer interface.
// because it takes a string argument.
// so, you need to call the String method yourself.
str.WriteString(it.String())
str.WriteRune('\n')
// str.WriteString(it.String())
// str.WriteRune('\n')
// or slower way:
// fmt.Fprintln(&str, it)
// Print funcs can detect fmt.Stringer automatically.
fmt.Fprintln(&str, it)
}
return str.String()

61
interfaces/11-decode-toiface/timestamp.go
View File

@ -12,66 +12,53 @@ import (
"time"
)
// unknown is the zero value of a timestamp.
var unknown = timestamp(time.Time{})
// timestamp prints timestamps, it's a stringer.
// It is useful even if it's zero.
type timestamp time.Time
// MarshalJSON from timestamp.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
u := time.Time(ts).Unix()
return strconv.AppendInt(out, u, 10), nil
type timestamp struct {
time.Time
}
// UnmarshalJSON data to timestamp.
// timestamp knows how to decode itself from json.
//
// UnmarshalJSON is an implementation of the json.Unmarshaler interface.
// json.Unmarshal and json.Decode call this method.
func (ts *timestamp) UnmarshalJSON(data []byte) error {
s := string(data)
// Let the ParseInt parse quoted strings.
us, err := strconv.Unquote(s)
if err == nil {
s = us
}
// Always overwrite the timestamp when decoding.
*ts = unknown
// Handle the numeric case.
if n, err := strconv.ParseInt(s, 10, 64); err == nil {
*ts = timestamp(time.Unix(n, 0))
}
*ts = toTimestamp(string(data))
return nil
}
// String representation of the timestamp.
func (ts timestamp) String() string {
t := time.Time(ts)
// timestamp knows how to encode itself to json.
//
// MarshalJSON is an implementation of the json.Marshaler interface.
// json.Marshal and json.Encode call this method.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
return strconv.AppendInt(out, ts.Unix(), 10), nil
}
if t.IsZero() {
func (ts timestamp) String() string {
if ts.IsZero() {
return "unknown"
}
// Mon Jan 2 15:04:05 -0700 MST 2006
const layout = "2006/01"
return t.Format(layout)
return ts.Format(layout)
}
// toTimestamp from an unknown value.
func toTimestamp(v interface{}) timestamp {
var t int
switch v := v.(type) {
case int:
// book{title: "moby dick", price: 10, published: 118281600},
t = v
case string:
// book{title: "odyssey", price: 15, published: "733622400"},
t, _ = strconv.Atoi(v)
default:
return unknown
// book{title: "hobbit", price: 25},
return timestamp{}
}
return timestamp(time.Unix(int64(t), 0))
return timestamp{
Time: time.Unix(int64(t), 0),
}
}

6
interfaces/12-reflection/database.go
View File

@ -31,6 +31,12 @@ func (db *database) MarshalJSON() ([]byte, error) {
// Name -> returns the type name as string
t := reflect.TypeOf(it).Elem().Name()
e = append(e, encodable{t, it})
// Another way:
//
// t := fmt.Sprintf("%T", it)
//
// Uses: reflect.TypeOf(arg).String()
}
return json.Marshal(e)

61
interfaces/12-reflection/timestamp.go
View File

@ -12,66 +12,53 @@ import (
"time"
)
// unknown is the zero value of a timestamp.
var unknown = timestamp(time.Time{})
// timestamp prints timestamps, it's a stringer.
// It is useful even if it's zero.
type timestamp time.Time
// MarshalJSON from timestamp.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
u := time.Time(ts).Unix()
return strconv.AppendInt(out, u, 10), nil
type timestamp struct {
time.Time
}
// UnmarshalJSON data to timestamp.
// timestamp knows how to decode itself from json.
//
// UnmarshalJSON is an implementation of the json.Unmarshaler interface.
// json.Unmarshal and json.Decode call this method.
func (ts *timestamp) UnmarshalJSON(data []byte) error {
s := string(data)
// Let the ParseInt parse quoted strings.
us, err := strconv.Unquote(s)
if err == nil {
s = us
}
// Always overwrite the timestamp when decoding.
*ts = unknown
// Handle the numeric case.
if n, err := strconv.ParseInt(s, 10, 64); err == nil {
*ts = timestamp(time.Unix(n, 0))
}
*ts = toTimestamp(string(data))
return nil
}
// String representation of the timestamp.
func (ts timestamp) String() string {
t := time.Time(ts)
// timestamp knows how to encode itself to json.
//
// MarshalJSON is an implementation of the json.Marshaler interface.
// json.Marshal and json.Encode call this method.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
return strconv.AppendInt(out, ts.Unix(), 10), nil
}
if t.IsZero() {
func (ts timestamp) String() string {
if ts.IsZero() {
return "unknown"
}
// Mon Jan 2 15:04:05 -0700 MST 2006
const layout = "2006/01"
return t.Format(layout)
return ts.Format(layout)
}
// toTimestamp from an unknown value.
func toTimestamp(v interface{}) timestamp {
var t int
switch v := v.(type) {
case int:
// book{title: "moby dick", price: 10, published: 118281600},
t = v
case string:
// book{title: "odyssey", price: 15, published: "733622400"},
t, _ = strconv.Atoi(v)
default:
return unknown
// book{title: "hobbit", price: 25},
return timestamp{}
}
return timestamp(time.Unix(int64(t), 0))
return timestamp{
Time: time.Unix(int64(t), 0),
}
}

61
interfaces/13-reflection-2/timestamp.go
View File

@ -12,66 +12,53 @@ import (
"time"
)
// unknown is the zero value of a timestamp.
var unknown = timestamp(time.Time{})
// timestamp prints timestamps, it's a stringer.
// It is useful even if it's zero.
type timestamp time.Time
// MarshalJSON from timestamp.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
u := time.Time(ts).Unix()
return strconv.AppendInt(out, u, 10), nil
type timestamp struct {
time.Time
}
// UnmarshalJSON data to timestamp.
// timestamp knows how to decode itself from json.
//
// UnmarshalJSON is an implementation of the json.Unmarshaler interface.
// json.Unmarshal and json.Decode call this method.
func (ts *timestamp) UnmarshalJSON(data []byte) error {
s := string(data)
// Let the ParseInt parse quoted strings.
us, err := strconv.Unquote(s)
if err == nil {
s = us
}
// Always overwrite the timestamp when decoding.
*ts = unknown
// Handle the numeric case.
if n, err := strconv.ParseInt(s, 10, 64); err == nil {
*ts = timestamp(time.Unix(n, 0))
}
*ts = toTimestamp(string(data))
return nil
}
// String representation of the timestamp.
func (ts timestamp) String() string {
t := time.Time(ts)
// timestamp knows how to encode itself to json.
//
// MarshalJSON is an implementation of the json.Marshaler interface.
// json.Marshal and json.Encode call this method.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
return strconv.AppendInt(out, ts.Unix(), 10), nil
}
if t.IsZero() {
func (ts timestamp) String() string {
if ts.IsZero() {
return "unknown"
}
// Mon Jan 2 15:04:05 -0700 MST 2006
const layout = "2006/01"
return t.Format(layout)
return ts.Format(layout)
}
// toTimestamp from an unknown value.
func toTimestamp(v interface{}) timestamp {
var t int
switch v := v.(type) {
case int:
// book{title: "moby dick", price: 10, published: 118281600},
t = v
case string:
// book{title: "odyssey", price: 15, published: "733622400"},
t, _ = strconv.Atoi(v)
default:
return unknown
// book{title: "hobbit", price: 25},
return timestamp{}
}
return timestamp(time.Unix(int64(t), 0))
return timestamp{
Time: time.Unix(int64(t), 0),
}
}

61
interfaces/14-io-reader/timestamp.go
View File

@ -12,66 +12,53 @@ import (
"time"
)
// unknown is the zero value of a timestamp.
var unknown = timestamp(time.Time{})
// timestamp prints timestamps, it's a stringer.
// It is useful even if it's zero.
type timestamp time.Time
// MarshalJSON from timestamp.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
u := time.Time(ts).Unix()
return strconv.AppendInt(out, u, 10), nil
type timestamp struct {
time.Time
}
// UnmarshalJSON data to timestamp.
// timestamp knows how to decode itself from json.
//
// UnmarshalJSON is an implementation of the json.Unmarshaler interface.
// json.Unmarshal and json.Decode call this method.
func (ts *timestamp) UnmarshalJSON(data []byte) error {
s := string(data)
// Let the ParseInt parse quoted strings.
us, err := strconv.Unquote(s)
if err == nil {
s = us
}
// Always overwrite the timestamp when decoding.
*ts = unknown
// Handle the numeric case.
if n, err := strconv.ParseInt(s, 10, 64); err == nil {
*ts = timestamp(time.Unix(n, 0))
}
*ts = toTimestamp(string(data))
return nil
}
// String representation of the timestamp.
func (ts timestamp) String() string {
t := time.Time(ts)
// timestamp knows how to encode itself to json.
//
// MarshalJSON is an implementation of the json.Marshaler interface.
// json.Marshal and json.Encode call this method.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
return strconv.AppendInt(out, ts.Unix(), 10), nil
}
if t.IsZero() {
func (ts timestamp) String() string {
if ts.IsZero() {
return "unknown"
}
// Mon Jan 2 15:04:05 -0700 MST 2006
const layout = "2006/01"
return t.Format(layout)
return ts.Format(layout)
}
// toTimestamp from an unknown value.
func toTimestamp(v interface{}) timestamp {
var t int
switch v := v.(type) {
case int:
// book{title: "moby dick", price: 10, published: 118281600},
t = v
case string:
// book{title: "odyssey", price: 15, published: "733622400"},
t, _ = strconv.Atoi(v)
default:
return unknown
// book{title: "hobbit", price: 25},
return timestamp{}
}
return timestamp(time.Unix(int64(t), 0))
return timestamp{
Time: time.Unix(int64(t), 0),
}
}

61
interfaces/15-io-reader-composition/timestamp.go
View File

@ -12,66 +12,53 @@ import (
"time"
)
// unknown is the zero value of a timestamp.
var unknown = timestamp(time.Time{})
// timestamp prints timestamps, it's a stringer.
// It is useful even if it's zero.
type timestamp time.Time
// MarshalJSON from timestamp.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
u := time.Time(ts).Unix()
return strconv.AppendInt(out, u, 10), nil
type timestamp struct {
time.Time
}
// UnmarshalJSON data to timestamp.
// timestamp knows how to decode itself from json.
//
// UnmarshalJSON is an implementation of the json.Unmarshaler interface.
// json.Unmarshal and json.Decode call this method.
func (ts *timestamp) UnmarshalJSON(data []byte) error {
s := string(data)
// Let the ParseInt parse quoted strings.
us, err := strconv.Unquote(s)
if err == nil {
s = us
}
// Always overwrite the timestamp when decoding.
*ts = unknown
// Handle the numeric case.
if n, err := strconv.ParseInt(s, 10, 64); err == nil {
*ts = timestamp(time.Unix(n, 0))
}
*ts = toTimestamp(string(data))
return nil
}
// String representation of the timestamp.
func (ts timestamp) String() string {
t := time.Time(ts)
// timestamp knows how to encode itself to json.
//
// MarshalJSON is an implementation of the json.Marshaler interface.
// json.Marshal and json.Encode call this method.
func (ts timestamp) MarshalJSON() (out []byte, err error) {
return strconv.AppendInt(out, ts.Unix(), 10), nil
}
if t.IsZero() {
func (ts timestamp) String() string {
if ts.IsZero() {
return "unknown"
}
// Mon Jan 2 15:04:05 -0700 MST 2006
const layout = "2006/01"
return t.Format(layout)
return ts.Format(layout)
}
// toTimestamp from an unknown value.
func toTimestamp(v interface{}) timestamp {
var t int
switch v := v.(type) {
case int:
// book{title: "moby dick", price: 10, published: 118281600},
t = v
case string:
// book{title: "odyssey", price: 15, published: "733622400"},
t, _ = strconv.Atoi(v)
default:
return unknown
// book{title: "hobbit", price: 25},
return timestamp{}
}
return timestamp(time.Unix(int64(t), 0))
return timestamp{
Time: time.Unix(int64(t), 0),
}
}