유니버설 구조체를 사용하는 방법

Question

주문 목록을 구조화했습니다. map을 주문하고 방법을 찾으십시오. 그러나 나는 모든 타입을 위해 이것을 생성하고 싶지 않습니다. 다른 코드가 필요한가요? 또는 보편적으로 다시 쓰려면 어떻게해야합니까? Prev 및 Next이있는 모든 유형에서 사용할 수 있습니다.

type Post struct { //for example 
    P string 
    O int 
    Prev, Next *Post 
} 
type Act struct { 
    I int 
    Prev, Next *Act 
}  

type Map struct { 
    Act   map[int]*Act 
    First, Last *Act 
} 

func (m *Map) New(a *Act) int { 
    Ida++ 
    f := Ida 
    a.Id = Ida 
    m.Act[Ida] = a 
    if m.First == nil { 
     m.First = a 
    } else { 
     m.Last.Next = a 
     a.Prev = m.Last 
    } 
    m.Last = a 
    return f 
} 

func (m *Map) Del(s int) { 
    if _, ok := m.Act[s]; ok { 
     if m.Last == m.First { 
      m.Last = nil 
      m.First = nil 
      delete(m.Act, s) 
      return 
     } 
     if m.Last == m.Act[s] { 
      m.Last = m.Act[s].Prev 
      m.Act[s].Prev.Next = nil 
      delete(m.Act, s) 
      return 
     } 
     if m.First == m.Act[s] { 
      m.First = m.Act[s].Next 
      m.Act[s].Next.Prev = nil 
      delete(m.Act, s) 
      return 
     } 
     m.Act[s].Prev.Next = m.Act[s].Next 
     m.Act[s].Next.Prev = m.Act[s].Prev 
     delete(m.Act, s) 
     return 
    } 
} 

Answer 1

당신은 Prev() 및 Next() 방법을 구현하는 모든 종류의 작업을 할 함수를 정의 할 수 있습니다. 예를 들면 다음과 같습니다.

type List interface{ 
    Next() List 
    Prev() List 
    First() List 
    Last() List 
    Value() interface{} 
    SetNext(List) 
    SetPrev(List) 
} 
func Del(l List, elem_to_delete interface{}){ 
    for e:=l.First(); e != l.Last(); e = l.Next() 
     if l.Value() == elem_to_delete{ 
      l.Prev().SetNext(l.Next()) 
      l.Next().SetPrev(l.Prev()) 
      break 
     } 
    } 
} 
//and implement those methods for your types 
type Post struct { //for example 
    P string 
    O int 
    Prev, Next *Post 
} 
func (p Post) Next() List{ 
    return p.Next 
} 
... 
//and then you can call Del() with any of this types 
Del(post, 5) 

또한 stdlib에 정의 된 목록 데이터 구조가 있습니다.

Answer 2

경우 방법으로 Next 및 Prev 작업을 정의합니다 :

type PrevNext interface { 
    GetNext() *Act 
    GetPrev() *Act 
    // ... and all other required actions 
} 

그래서 당신이없는 방법으로하지만, 일반적인 함수로 Del()을 정의 할 수의 객체를 기대 :

type Act struct { 
    I int 
    Prev, Next *Act 
} 

func (a *Act) GetNext(){ 
    return a.Next 
}  

당신이 인터페이스를 가질 수있다 PrevNext 유형은 모든 필수 조작이 메소드로 정의되어 있습니다.

func Del(m *PrevNext, s int) { 
    if _, ok := m.Act[s]; ok { 
     if m.GetLast() == m.GetFirst() { 
      m.SetLast(nil) 
      m.SetFirst(nil) 
      delete(m.Act, s) 
      return 
     } 
    // .... 
    } 
}