design pattern

Author: phuhao00

abstract_factory.go

@@ -0,0 +1,8 @@
+package sugar
+
+type Product interface {
+}
+
+type AbstractFactory interface {
+	Create() Product
+}

adapter.go

@@ -0,0 +1,28 @@
+package sugar
+
+type Adapter struct {
+	Adapt
+}
+
+func (a *Adapter) Do() {
+	a.SpecifyDo()
+}
+
+type Adapt interface {
+	SpecifyDo()
+}
+
+type AdaptImpl struct {
+}
+
+func (a AdaptImpl) SpecifyDo() {
+
+}
+
+type Target interface {
+	Do()
+}
+
+func NewAdapter() Target {
+	return &Adapter{AdaptImpl{}}
+}

composite.go

@@ -0,0 +1,91 @@
+package sugar
+
+import "fmt"
+
+type Component interface {
+	Parent() Component
+	SetParent(Component)
+	Name() string
+	SetName(string)
+	AddChild(Component)
+	Print(string)
+}
+
+const (
+	LeafNode = iota
+	CompositeNode
+)
+
+func NewComponent(kind int, name string) Component {
+	var c Component
+	switch kind {
+	case LeafNode:
+		c = NewLeaf()
+	case CompositeNode:
+		c = NewComposite()
+	}
+
+	c.SetName(name)
+	return c
+}
+
+type component struct {
+	parent Component
+	name   string
+}
+
+func (c *component) Parent() Component {
+	return c.parent
+}
+
+func (c *component) SetParent(parent Component) {
+	c.parent = parent
+}
+
+func (c *component) Name() string {
+	return c.name
+}
+
+func (c *component) SetName(name string) {
+	c.name = name
+}
+
+func (c *component) AddChild(Component) {}
+
+func (c *component) Print(string) {}
+
+type Leaf struct {
+	component
+}
+
+func NewLeaf() *Leaf {
+	return &Leaf{}
+}
+
+func (c *Leaf) Print(pre string) {
+	fmt.Printf("%s-%s\n", pre, c.Name())
+}
+
+type Composite struct {
+	component
+	childs []Component
+}
+
+func NewComposite() *Composite {
+	return &Composite{
+		childs: make([]Component, 0),
+	}
+}
+
+func (c *Composite) AddChild(child Component) {
+	child.SetParent(c)
+	c.childs = append(c.childs, child)
+}
+
+func (c *Composite) Print(pre string) {
+	fmt.Printf("%s+%s\n", pre, c.Name())
+	pre += " "
+	for _, comp := range c.childs {
+		comp.Print(pre)
+	}
+}

composite_test.go

@@ -0,0 +1,32 @@
+//go:build ignore
+// +build ignore
+
+package sugar
+
+func ExampleComposite() {
+	root := NewComponent(CompositeNode, "root")
+	c1 := NewComponent(CompositeNode, "c1")
+	c2 := NewComponent(CompositeNode, "c2")
+	c3 := NewComponent(CompositeNode, "c3")
+
+	l1 := NewComponent(LeafNode, "l1")
+	l2 := NewComponent(LeafNode, "l2")
+	l3 := NewComponent(LeafNode, "l3")
+
+	root.AddChild(c1)
+	root.AddChild(c2)
+	c1.AddChild(c3)
+	c1.AddChild(l1)
+	c2.AddChild(l2)
+	c2.AddChild(l3)
+
+	root.Print("")
+	// Output:
+	// +root
+	//  +c1
+	//   +c3
+	//   -l1
+	//  +c2
+	//   -l2
+	//   -l3
+}

concurrency.go

@@ -43,3 +43,33 @@ func FanIn(in ...chan any) <-chan any {
 	}
 	return out
 }
+
+func FanOut(ch <-chan any, n int) []chan any {
+	cs := make([]chan any, 0, n)
+	for i := 0; i < n; i++ {
+		cs = append(cs, make(chan any))
+	}
+	distributeToChannels := func(ch <-chan any, cs []chan any) {
+		defer func(cs []chan any) {
+			for _, c := range cs {
+				close(c)
+			}
+		}(cs)
+
+		for {
+			for _, c := range cs {
+				select {
+				case val, ok := <-ch:
+					if !ok {
+						return
+					}
+
+					c <- val
+				}
+			}
+		}
+	}
+	go distributeToChannels(ch, cs)
+
+	return cs
+}

creational.go

@@ -0,0 +1,6 @@
+package sugar
+
+type Builder interface {
+	Build(m any) Builder
+	CompletedCheck() bool
+}

creational_test.go

@@ -0,0 +1,33 @@
+//go:build ignore
+// +build ignore
+
+package sugar
+
+import (
+	"fmt"
+	"testing"
+)
+
+type BuilderImplCase struct {
+	M1 any
+}
+
+func (b *BuilderImplCase) Build(m any) Builder {
+	b.M1 = m
+	return b
+}
+
+func (b *BuilderImplCase) CompletedCheck() bool {
+	if !IsNil1(b.M1) {
+		return true
+	}
+	return false
+}
+
+func TestBuilderImplCase(t *testing.T) {
+	v := &BuilderImplCase{}
+	completedCheck := v.Build("m").CompletedCheck()
+	if completedCheck {
+		fmt.Println("complete!")
+	}
+}

decorate.go

@@ -0,0 +1,9 @@
+package sugar
+
+func DecorateFn(before, fn, after func()) func() {
+	return func() {
+		before()
+		fn()
+		after()
+	}
+}

idiom.go

@@ -0,0 +1,7 @@
+package sugar
+
+func Idiom(member any) func(obj any) {
+	return func(obj any) {
+
+	}
+}

judge_nil.go

@@ -0,0 +1,29 @@
+package sugar
+
+import "reflect"
+
+// IsNil1 ...
+func IsNil1(i interface{}) bool {
+	ret := i == nil
+	if !ret {
+		defer func() {
+			recover()
+		}()
+		ret = reflect.ValueOf(i).IsNil()
+	}
+	return ret
+}
+
+// IsNil2 ...
+func IsNil2(i interface{}) bool {
+	if i == nil {
+		return true
+	}
+	v := reflect.ValueOf(i)
+	switch v.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Map, reflect.Pointer, reflect.UnsafePointer, reflect.Interface, reflect.Slice:
+		return v.IsNil()
+	default:
+		return false
+	}
+}

mediator.go

@@ -0,0 +1,36 @@
+package sugar
+
+//Mediator  a FSM implement
+
+type Mediator struct {
+	transitions map[Member][]Member
+}
+
+var (
+	gMediator *Mediator
+)
+
+func GetMediator() *Mediator {
+	if gMediator == nil {
+		gMediator = &Mediator{make(map[Member][]Member)}
+	}
+	return gMediator
+}
+
+func (m *Mediator) Changed(i Member) {
+	for _, member := range m.transitions[i] {
+		member.Process(i.GetTransData())
+	}
+}
+
+func (m *Mediator) RegisterMember(from, to Member) {
+	if m.transitions[from] == nil {
+		m.transitions[from] = make([]Member, 0)
+	}
+	m.transitions[from] = append(m.transitions[from], to)
+}
+
+type Member interface {
+	Process(a any)
+	GetTransData() any
+}