type StructA struct {
	Name string
}

// 초기화 시에 하고 싶은 처리
func (self *StructA) SomeInitialize() {
	// Some initialize
}

// 생성자 함수를 정의
func NewStructA(name string) *StructA {
	structA := &StructA{Name: name}
	structA.SomeInitialize()
	return structA
}

func main() {
	_ = NewStructA("name")
}

package singleton

// 구조체의 이름을 소문자로 해서 패키지 밖으로 export 하지 않는다
type singleton struct {
}

// 인스턴스를 저장하는 변수도 소문자로 하여 export 하지 않는다
var instance *singleton

// 인스턴스 취득용 함수만 export 해 두고, 여기에서 인스턴스를 접근할 수 있게 해준다.
func GetInstance() *singleton {
	if instance == nil {
	     instance = &singleton{}
	}
	return instance
}

singleton := singleton.GetInstance()

// 인터페이스 정의
type SomeBehivor interface {
	DoSomething(arg string) string
}

// 구조체 정의
type StructA struct {
}

// 인터페이스 구현
func (self *StructA) DoSomething(arg string) string {
	return arg
}

// 다형성
func main() {
	// 인터페이스 타입 변수에 저장할 수 있다
	var behivor SomeBehivor
	behivor = &StructA{}
	behivor.DoSomething("A")
}

type ConnCallback interface {
	// OnConnect is called when the connection was accepted,
	// If the return value of false is closed
	OnConnect(*Conn) bool

	// OnMessage is called when the connection receives a packet,
	// If the return value of false is closed
	OnMessage(*Conn, Packet) bool

	// OnClose is called when the connection closed
	OnClose(*Conn)
}

type Server struct {
	config    *Config         // server configuration
	callback  ConnCallback    // message callbacks in connection
	protocol  Protocol        // customize packet protocol
	exitChan  chan struct{}   // notify all goroutines to shutdown
	waitGroup *sync.WaitGroup // wait for all goroutines
}

type Callback struct{}

func (this *Callback) OnConnect(c *gotcp.Conn) bool {
	// todo
	return true
}

func (this *Callback) OnMessage(c *gotcp.Conn, p gotcp.Packet) bool {
	// todo
	return true
}

func (this *Callback) OnClose(c *gotcp.Conn) {
	// todo
}


// NewServer creates a server
func NewServer(config *Config, callback ConnCallback, protocol Protocol) *Server {
	return &Server{
		config:    config,
		callback:  callback,
		protocol:  protocol,
		exitChan:  make(chan struct{}),
		waitGroup: &sync.WaitGroup{},
	}
}


srv := gotcp.NewServer(config, &Callback{}, &echo.EchoProtocol{})

// 인터페이스 정의
type SomeBehivor interface {
	DoSomething() string
}

// 공통 구조체 정의
type DefaultStruct struct {
	// 공통 멤버
	Name string
}

// 공통 구조체에 인터페이스를 구현
func (self *DefaultStruct) DoSomething() string {
	return self.Name
}

// 공통 구조체를 포함
type StructA struct {
	*DefaultStruct
}

func main() {
	// 인터페이스 타입의 변수에 저장할 수 있다
	behivor := &StructA{&DefaultStruct{"A"}}

	// 곹옹 구현과 멤버를 사용할 수 있다
	behivor.DoSomething()
}

// 생성자 함수
func NewStructA(name string) *StructA {
	return &StructA{&DefaultStruct{"A"}}
}
// 이용 측은 포함 구조체의 존재를 의식하지 않는다
behivor := NewStructA("A")

type Behivor interface {
	DoSomethingByOther()
}

type Abstract struct {
}

// 내부에서 원 구조체의 구현을 이용하는 메소드
func (self *Abstract) DoSomething(behivor Behivor) {
	behivor.DoSomethingByOther()

	// 여기에서 Abstract에 Behivor를 포함하는 등 메소드가 있는 상태에서 컴파일을 통과하도록 
	// self.DoSomethingByOther() 로도 panic: runtime error: invalid memory address or nil pointer dereference가
	// 발생하고、Dispatch back 되지 않는 것을 알 수 있다
}

// 위에서 정의한 구조체를 포함
type Concrete struct {
	*Abstract
}

// 인터페이스 를 구현
func (self *Concrete) DoSomethingByOther() {
	// Do something
}

func main() {
	concrete := &Concrete{}
	// 레시버가 되는 자기 자신을 넘긴다
	concrete.DoSomething(concrete)
}

type Strategy interface {
	DoSomething()
}

type ConcreteStrategy struct {
}

func (self *ConcreteStrategy) DoSomething() {
	// Do something
}

type StructA struct {
	// 이양처를 멤버로 가진다
	strategy Strategy
}

func (self *StructA) Operation() {
	// 포함한 구조체에 처리를 이양
	self.strategy.DoSomething()
}

// 함수 탕비을 정의
type DoSomething func()


type StructA struct {
}

// 함수 타입을 인수로 받아들이는 메소드를 정의
func (self *StructA) Operation(strategy DoSomething) {
	// 받아들인 함수 타입에 처리를 이양
	strategy()
}

func main() {
	structA := &StructA{}

	// 함수 리터럴에서 인수로서 넘긴다
	structA.Operation(func(){
	     // Do something
	})
}