package main

import (
	"Study/src/study/day8Method/common"
	"fmt"
	"image/color"
	"sync"
)

func main() {
	var red = color.RGBA{
		R: 255,
		G: 0,
		B: 0,
		A: 255,
	}
	var green = color.RGBA{
		R: 0,
		G: 255,
		B: 0,
		A: 255,
	}
	var blue = color.RGBA{
		R: 0,
		G: 0,
		B: 255,
		A: 255,
	}
	var cp common.ColoredPoint = common.ColoredPoint{
		common.Point{X: 0, Y: 0},
		red,
	}
	cp.X = 255
	cp.Y = 233

	var greenCP common.ColoredPoint
	greenCP.X = 0
	greenCP.Y = 0
	greenCP.Color = green

	// 由于ColoredPoint包含了Point，ColoredPoint也包含了Point的方法
	fmt.Println(cp.Distance(greenCP.Point))

	// 如果新的结构体包含的是一个另一个结构体指针类型

	var blueCP = common.ColoredPointPoint{
		P:    &common.Point{X: 233, Y: 123},
		RGBA: blue,
	}
	var blackCP = common.ColoredPointPoint{
		P: &common.Point{X: 0, Y: 0},
		RGBA: color.RGBA{
			R: 0,
			G: 0,
			B: 0,
			A: 255,
		},
	}
	// 这种情况下字段和方法会被间接地引入到当前的类型中
	// (译注：访问需要通过该指针指向的对象去取)。
	// 添加这一层间接关系让我们可以共享通用的结构并动态地改变对象之间的关系。
	fmt.Println(blueCP.P.Distance(*blackCP.P))
	// 注意 如果是显式的定义了变量名，
	// 你访问包含的其他结构体的方法也要带上变量名

	var (
		i   int    = 233
		www string = "123233"
	)
	fmt.Println(i, www)

}

var cache = struct {
	sync.Mutex
	mapping map[string]string
}{
	mapping: make(map[string]string),
}

func Lookup(key string) string {
	cache.Lock()
	v := cache.mapping[key]
	cache.Unlock()
	return v
}
