How to use compare method of gop Package

1// Package atomic provide Go+ "sync/atomic" package, as "sync/atomic" package in Go.2package atomic3import (4	atomic "sync/atomic"5	unsafe "unsafe"6	gop "github.com/qiniu/goplus/gop"7)8func execAddInt32(_ int, p *gop.Context) {9	args := p.GetArgs(2)10	ret0 := atomic.AddInt32(args[0].(*int32), args[1].(int32))11	p.Ret(2, ret0)12}13func execAddInt64(_ int, p *gop.Context) {14	args := p.GetArgs(2)15	ret0 := atomic.AddInt64(args[0].(*int64), args[1].(int64))16	p.Ret(2, ret0)17}18func execAddUint32(_ int, p *gop.Context) {19	args := p.GetArgs(2)20	ret0 := atomic.AddUint32(args[0].(*uint32), args[1].(uint32))21	p.Ret(2, ret0)22}23func execAddUint64(_ int, p *gop.Context) {24	args := p.GetArgs(2)25	ret0 := atomic.AddUint64(args[0].(*uint64), args[1].(uint64))26	p.Ret(2, ret0)27}28func execAddUintptr(_ int, p *gop.Context) {29	args := p.GetArgs(2)30	ret0 := atomic.AddUintptr(args[0].(*uintptr), args[1].(uintptr))31	p.Ret(2, ret0)32}33func execCompareAndSwapInt32(_ int, p *gop.Context) {34	args := p.GetArgs(3)35	ret0 := atomic.CompareAndSwapInt32(args[0].(*int32), args[1].(int32), args[2].(int32))36	p.Ret(3, ret0)37}38func execCompareAndSwapInt64(_ int, p *gop.Context) {39	args := p.GetArgs(3)40	ret0 := atomic.CompareAndSwapInt64(args[0].(*int64), args[1].(int64), args[2].(int64))41	p.Ret(3, ret0)42}43func execCompareAndSwapPointer(_ int, p *gop.Context) {44	args := p.GetArgs(3)45	ret0 := atomic.CompareAndSwapPointer(args[0].(*unsafe.Pointer), args[1].(unsafe.Pointer), args[2].(unsafe.Pointer))46	p.Ret(3, ret0)47}48func execCompareAndSwapUint32(_ int, p *gop.Context) {49	args := p.GetArgs(3)50	ret0 := atomic.CompareAndSwapUint32(args[0].(*uint32), args[1].(uint32), args[2].(uint32))51	p.Ret(3, ret0)52}53func execCompareAndSwapUint64(_ int, p *gop.Context) {54	args := p.GetArgs(3)55	ret0 := atomic.CompareAndSwapUint64(args[0].(*uint64), args[1].(uint64), args[2].(uint64))56	p.Ret(3, ret0)57}58func execCompareAndSwapUintptr(_ int, p *gop.Context) {59	args := p.GetArgs(3)60	ret0 := atomic.CompareAndSwapUintptr(args[0].(*uintptr), args[1].(uintptr), args[2].(uintptr))61	p.Ret(3, ret0)62}63func execLoadInt32(_ int, p *gop.Context) {64	args := p.GetArgs(1)65	ret0 := atomic.LoadInt32(args[0].(*int32))66	p.Ret(1, ret0)67}68func execLoadInt64(_ int, p *gop.Context) {69	args := p.GetArgs(1)70	ret0 := atomic.LoadInt64(args[0].(*int64))71	p.Ret(1, ret0)72}73func execLoadPointer(_ int, p *gop.Context) {74	args := p.GetArgs(1)75	ret0 := atomic.LoadPointer(args[0].(*unsafe.Pointer))76	p.Ret(1, ret0)77}78func execLoadUint32(_ int, p *gop.Context) {79	args := p.GetArgs(1)80	ret0 := atomic.LoadUint32(args[0].(*uint32))81	p.Ret(1, ret0)82}83func execLoadUint64(_ int, p *gop.Context) {84	args := p.GetArgs(1)85	ret0 := atomic.LoadUint64(args[0].(*uint64))86	p.Ret(1, ret0)87}88func execLoadUintptr(_ int, p *gop.Context) {89	args := p.GetArgs(1)90	ret0 := atomic.LoadUintptr(args[0].(*uintptr))91	p.Ret(1, ret0)92}93func execStoreInt32(_ int, p *gop.Context) {94	args := p.GetArgs(2)95	atomic.StoreInt32(args[0].(*int32), args[1].(int32))96	p.PopN(2)97}98func execStoreInt64(_ int, p *gop.Context) {99	args := p.GetArgs(2)100	atomic.StoreInt64(args[0].(*int64), args[1].(int64))101	p.PopN(2)102}103func execStorePointer(_ int, p *gop.Context) {104	args := p.GetArgs(2)105	atomic.StorePointer(args[0].(*unsafe.Pointer), args[1].(unsafe.Pointer))106	p.PopN(2)107}108func execStoreUint32(_ int, p *gop.Context) {109	args := p.GetArgs(2)110	atomic.StoreUint32(args[0].(*uint32), args[1].(uint32))111	p.PopN(2)112}113func execStoreUint64(_ int, p *gop.Context) {114	args := p.GetArgs(2)115	atomic.StoreUint64(args[0].(*uint64), args[1].(uint64))116	p.PopN(2)117}118func execStoreUintptr(_ int, p *gop.Context) {119	args := p.GetArgs(2)120	atomic.StoreUintptr(args[0].(*uintptr), args[1].(uintptr))121	p.PopN(2)122}123func execSwapInt32(_ int, p *gop.Context) {124	args := p.GetArgs(2)125	ret0 := atomic.SwapInt32(args[0].(*int32), args[1].(int32))126	p.Ret(2, ret0)127}128func execSwapInt64(_ int, p *gop.Context) {129	args := p.GetArgs(2)130	ret0 := atomic.SwapInt64(args[0].(*int64), args[1].(int64))131	p.Ret(2, ret0)132}133func execSwapPointer(_ int, p *gop.Context) {134	args := p.GetArgs(2)135	ret0 := atomic.SwapPointer(args[0].(*unsafe.Pointer), args[1].(unsafe.Pointer))136	p.Ret(2, ret0)137}138func execSwapUint32(_ int, p *gop.Context) {139	args := p.GetArgs(2)140	ret0 := atomic.SwapUint32(args[0].(*uint32), args[1].(uint32))141	p.Ret(2, ret0)142}143func execSwapUint64(_ int, p *gop.Context) {144	args := p.GetArgs(2)145	ret0 := atomic.SwapUint64(args[0].(*uint64), args[1].(uint64))146	p.Ret(2, ret0)147}148func execSwapUintptr(_ int, p *gop.Context) {149	args := p.GetArgs(2)150	ret0 := atomic.SwapUintptr(args[0].(*uintptr), args[1].(uintptr))151	p.Ret(2, ret0)152}153func execValueLoad(_ int, p *gop.Context) {154	args := p.GetArgs(1)155	ret0 := args[0].(*atomic.Value).Load()156	p.Ret(1, ret0)157}158func execValueStore(_ int, p *gop.Context) {159	args := p.GetArgs(2)160	args[0].(*atomic.Value).Store(args[1])161	p.PopN(2)162}163// I is a Go package instance.164var I = gop.NewGoPackage("sync/atomic")165func init() {166	I.RegisterFuncs(167		I.Func("AddInt32", atomic.AddInt32, execAddInt32),168		I.Func("AddInt64", atomic.AddInt64, execAddInt64),169		I.Func("AddUint32", atomic.AddUint32, execAddUint32),170		I.Func("AddUint64", atomic.AddUint64, execAddUint64),171		I.Func("AddUintptr", atomic.AddUintptr, execAddUintptr),172		I.Func("CompareAndSwapInt32", atomic.CompareAndSwapInt32, execCompareAndSwapInt32),173		I.Func("CompareAndSwapInt64", atomic.CompareAndSwapInt64, execCompareAndSwapInt64),174		I.Func("CompareAndSwapPointer", atomic.CompareAndSwapPointer, execCompareAndSwapPointer),175		I.Func("CompareAndSwapUint32", atomic.CompareAndSwapUint32, execCompareAndSwapUint32),176		I.Func("CompareAndSwapUint64", atomic.CompareAndSwapUint64, execCompareAndSwapUint64),177		I.Func("CompareAndSwapUintptr", atomic.CompareAndSwapUintptr, execCompareAndSwapUintptr),178		I.Func("LoadInt32", atomic.LoadInt32, execLoadInt32),179		I.Func("LoadInt64", atomic.LoadInt64, execLoadInt64),180		I.Func("LoadPointer", atomic.LoadPointer, execLoadPointer),181		I.Func("LoadUint32", atomic.LoadUint32, execLoadUint32),182		I.Func("LoadUint64", atomic.LoadUint64, execLoadUint64),183		I.Func("LoadUintptr", atomic.LoadUintptr, execLoadUintptr),184		I.Func("StoreInt32", atomic.StoreInt32, execStoreInt32),185		I.Func("StoreInt64", atomic.StoreInt64, execStoreInt64),186		I.Func("StorePointer", atomic.StorePointer, execStorePointer),187		I.Func("StoreUint32", atomic.StoreUint32, execStoreUint32),188		I.Func("StoreUint64", atomic.StoreUint64, execStoreUint64),189		I.Func("StoreUintptr", atomic.StoreUintptr, execStoreUintptr),190		I.Func("SwapInt32", atomic.SwapInt32, execSwapInt32),191		I.Func("SwapInt64", atomic.SwapInt64, execSwapInt64),192		I.Func("SwapPointer", atomic.SwapPointer, execSwapPointer),193		I.Func("SwapUint32", atomic.SwapUint32, execSwapUint32),194		I.Func("SwapUint64", atomic.SwapUint64, execSwapUint64),195		I.Func("SwapUintptr", atomic.SwapUintptr, execSwapUintptr),196		I.Func("(*Value).Load", (*atomic.Value).Load, execValueLoad),197		I.Func("(*Value).Store", (*atomic.Value).Store, execValueStore),198	)199}...

1package mpts2import (3	"bytes"4	"encoding/json"5	"errors"6	"fmt"7	"os"8	"path/filepath"9	"strconv"10	"strings"11)12type Mp2vUserData struct {13	Pos     int6414	AFD     *int15	Caption bool16	Bar     bool17}18type Mp2vTimeCode struct {19	DropFrameFlag int20	Hours         int21	Minutes       int22	Seconds       int23	Pictures      int24}25type Mp2vHeaders struct {26	*Mp2vGopHeader27	*Mp2vPicHeader28	UserData []*Mp2vUserData29}30type Mp2vGopHeader struct {31	Mp2vTimeCode32	ClosedGop int33}34type Mp2vPicHeader struct {35	TemporalReference int36	PictureCodingType int37}38func ParseATSC(data []byte) (cc bool, bar bool) {39	code := data[0]40	if code == 0x03 {41		cc = true42	} else if code == 0x06 {43		bar = true44	}45	return46}47func ParseAFD(data []byte) (int, error) {48	if data[0] == 0x41 {49		format := data[1] & 0x0F50		return int(format), nil51	}52	return 0, errors.New("Active format does not exist")53}54func ParseMp2vUserData(data []byte) *Mp2vUserData {55	var result = &Mp2vUserData{}56	var idATSC = []byte("GA94") // 0x4741393457	var idAFD = []byte("DTG1")  // 0x4454473158	if bytes.Compare(idATSC, data[0:4]) == 0 {59		result.Caption, result.Bar = ParseATSC(data[4:])60	} else if bytes.Compare(idAFD, data[0:4]) == 0 {61		afd, err := ParseAFD(data[4:])62		if err == nil {63			result.AFD = &afd64		}65	}66	return result67}68func ParseMp2vHeaders(data []byte) Mp2vHeaders {69	var result Mp2vHeaders70	var pos int71	var startcode = []byte{0, 0, 1}72	var startlen = len(startcode)73	for pos+startlen+1 < len(data) {74		if bytes.Compare(startcode, data[pos:pos+startlen]) == 0 {75			pos += startlen76			code := int(data[pos])77			elem := data[pos+1:]78			if code == 0xB2 {79				userData := ParseMp2vUserData(elem)80				result.UserData = append(result.UserData, userData)81			} else if code == 0x00 {82				result.Mp2vPicHeader = ParseMp2vPicHeader(elem)83			} else if code == 0xB8 {84				result.Mp2vGopHeader = ParseMp2vGopHeader(elem)85			}86		}87		pos += 188	}89	return result90}91func ParseMp2vPicHeader(data []byte) *Mp2vPicHeader {92	r := &Reader{Data: data}93	h := &Mp2vPicHeader{}94	h.TemporalReference = r.ReadBit(10)95	h.PictureCodingType = r.ReadBit(3)96	return h97}98func ParseMp2vGopHeader(data []byte) *Mp2vGopHeader {99	r := &Reader{Data: data}100	h := &Mp2vGopHeader{}101	h.Mp2vTimeCode.DropFrameFlag = r.ReadBit(1)102	h.Mp2vTimeCode.Hours = r.ReadBit(5)103	h.Mp2vTimeCode.Minutes = r.ReadBit(6)104	r.ReadBit(1)105	h.Mp2vTimeCode.Seconds = r.ReadBit(6)106	h.Mp2vTimeCode.Pictures = r.ReadBit(6)107	h.ClosedGop = r.ReadBit(1)108	return h109}110type Mp2vRecord struct {111	BaseRecord112	curpkt   *PesPkt113	Pkts     []*PesPkt114	UserData []*Mp2vUserData115}116func (s *Mp2vRecord) Process(pkt *TsPkt) {117	s.LogAdaptFieldPrivData(pkt)118	if pkt.PUSI == 1 {119		if s.curpkt != nil {120			headers := ParseMp2vHeaders(s.curpkt.Data)121			if headers.Mp2vPicHeader != nil && headers.Mp2vPicHeader.PictureCodingType == 1 {122				i := IFrameInfo{}123				i.Pos = s.curpkt.Pos124				i.Pts = s.curpkt.Pts125				if headers.Mp2vGopHeader != nil {126					i.Key = headers.Mp2vGopHeader.ClosedGop == 1127				}128				s.LogIFrame(i)129			}130			userData := headers.UserData131			for _, u := range userData {132				u.Pos = s.curpkt.Pos133			}134			s.UserData = append(s.UserData, userData...)135			s.Pkts = append(s.Pkts, s.curpkt)136		}137		s.curpkt = &PesPkt{}138		s.curpkt.Pos = pkt.Pos139		s.curpkt.Pcr = s.BaseRecord.PcrTime140		var startcode = []byte{0, 0, 1}141		if 0 == bytes.Compare(startcode, pkt.Data[0:3]) {142			hlen := s.curpkt.Read(pkt.Data)143			pkt.Data = pkt.Data[hlen:]144		}145	}146	if s.curpkt != nil {147		s.curpkt.Size += int64(len(pkt.Data))148		s.curpkt.Data = append(s.curpkt.Data, pkt.Data...)149	}150}151func (s *Mp2vRecord) Flush() {152	if s.curpkt != nil {153		s.Pkts = append(s.Pkts, s.curpkt)154	}155}156func (s *Mp2vRecord) Report(root string) {157	var fname string158	var w *os.File159	var err error160	var pid string = strconv.Itoa(s.Pid)161	var header string162	fname = filepath.Join(root, pid+".csv")163	w, err = os.Create(fname)164	if err != nil {165		panic(err)166	}167	header = "Pos, Size, PCR, PTS, DTS, (DTS-PCR)"168	fmt.Fprintln(w, header)169	for _, p := range s.Pkts {170		pcr := p.Pcr / 300171		dts := p.Dts172		if dts == 0 {173			dts = p.Pts174		}175		cols := []string{176			strconv.FormatInt(p.Pos, 10),177			strconv.FormatInt(p.Size, 10),178			strconv.FormatInt(pcr, 10),179			strconv.FormatInt(p.Pts, 10),180			strconv.FormatInt(dts, 10),181			strconv.FormatInt(dts-pcr, 10),182		}183		fmt.Fprintln(w, strings.Join(cols, ", "))184	}185	w.Close()186	fname = filepath.Join(root, pid+"-userdata"+".csv")187	w, err = os.Create(fname)188	if err != nil {189		panic(err)190	}191	header = "User Data"192	fmt.Fprintln(w, header)193	for _, userData := range s.UserData {194		c, _ := json.Marshal(userData)195		fmt.Fprintln(w, string(c))196	}197	w.Close()198}...

1package pubsub2import (3	"bytes"4	"context"5	"github.com/notedit/rtmp/av"6	"sync"7	"sync/atomic"8	"unsafe"9)10type gopCacheSnapshot struct {11	pkts []av.Packet12	idx  int13}14type gopCache struct {15	pkts  []av.Packet16	idx   int17	curst unsafe.Pointer18}19func (gc *gopCache) put(pkt av.Packet) {20	if pkt.IsKeyFrame {21		gc.pkts = []av.Packet{}22	}23	gc.pkts = append(gc.pkts, pkt)24	gc.idx++25	st := &gopCacheSnapshot{26		pkts: gc.pkts,27		idx:  gc.idx,28	}29	atomic.StorePointer(&gc.curst, unsafe.Pointer(st))30}31func (gc *gopCache) curSnapshot() *gopCacheSnapshot {32	return (*gopCacheSnapshot)(atomic.LoadPointer(&gc.curst))33}34type gopCacheReadCursor struct {35	lastidx int36}37func (rc *gopCacheReadCursor) advance(cur *gopCacheSnapshot) []av.Packet {38	lastidx := rc.lastidx39	rc.lastidx = cur.idx40	if diff := cur.idx - lastidx; diff <= len(cur.pkts) {41		return cur.pkts[len(cur.pkts)-diff:]42	} else {43		return cur.pkts44	}45}46type mergeSeqhdr struct {47	cb     func(av.Packet)48	hdrpkt av.Packet49}50func (m *mergeSeqhdr) do(pkt av.Packet) {51	switch pkt.Type {52	case av.H264DecoderConfig:53		m.hdrpkt.VSeqHdr = append([]byte(nil), pkt.Data...)54	case av.H264:55		pkt.Metadata = m.hdrpkt.Metadata56		if pkt.IsKeyFrame {57			pkt.VSeqHdr = m.hdrpkt.VSeqHdr58		}59		m.cb(pkt)60	case av.AACDecoderConfig:61		m.hdrpkt.ASeqHdr = append([]byte(nil), pkt.Data...)62	case av.AAC:63		pkt.Metadata = m.hdrpkt.Metadata64		pkt.ASeqHdr = m.hdrpkt.ASeqHdr65		m.cb(pkt)66	case av.Metadata:67		m.hdrpkt.Metadata = pkt.Data68	}69}70type splitSeqhdr struct {71	cb     func(av.Packet) error72	hdrpkt av.Packet73}74func (s *splitSeqhdr) sendmeta(pkt av.Packet) error {75	if bytes.Compare(s.hdrpkt.Metadata, pkt.Metadata) != 0 {76		if err := s.cb(av.Packet{77			Type: av.Metadata,78			Data: pkt.Metadata,79		}); err != nil {80			return err81		}82		s.hdrpkt.Metadata = pkt.Metadata83	}84	return nil85}86func (s *splitSeqhdr) do(pkt av.Packet) error {87	switch pkt.Type {88	case av.H264:89		if err := s.sendmeta(pkt); err != nil {90			return err91		}92		if pkt.IsKeyFrame {93			if bytes.Compare(s.hdrpkt.VSeqHdr, pkt.VSeqHdr) != 0 {94				if err := s.cb(av.Packet{95					Type: av.H264DecoderConfig,96					Data: pkt.VSeqHdr,97				}); err != nil {98					return err99				}100				s.hdrpkt.VSeqHdr = pkt.VSeqHdr101			}102		}103		return s.cb(pkt)104	case av.AAC:105		if err := s.sendmeta(pkt); err != nil {106			return err107		}108		if bytes.Compare(s.hdrpkt.ASeqHdr, pkt.ASeqHdr) != 0 {109			if err := s.cb(av.Packet{110				Type: av.AACDecoderConfig,111				Data: pkt.ASeqHdr,112			}); err != nil {113				return err114			}115			s.hdrpkt.ASeqHdr = pkt.ASeqHdr116		}117		return s.cb(pkt)118	}119	return nil120}121type streamSub struct {122	notify chan struct{}123}124type streamPub struct {125	cancel func()126	gc     *gopCache127}128type PubSub struct {129	n   int64130	sub sync.Map131	pub unsafe.Pointer132}133func (s *PubSub) curGopCacheSnapshot() *gopCacheSnapshot {134	sp := (*streamPub)(atomic.LoadPointer(&s.pub))135	if sp == nil {136		return nil137	}138	return sp.gc.curSnapshot()139}140func (s *PubSub) AddSub(close <-chan bool, w av.PacketWriter) {141	ss := &streamSub{142		notify: make(chan struct{}, 1),143	}144	s.sub.Store(ss, nil)145	defer s.sub.Delete(ss)146	var cursor *gopCacheReadCursor147	var lastsp *streamPub148	seqsplit := splitSeqhdr{149		cb: func(pkt av.Packet) error {150			return w.WritePacket(pkt)151		},152	}153	for {154		var pkts []av.Packet155		sp := (*streamPub)(atomic.LoadPointer(&s.pub))156		if sp != lastsp {157			cursor = &gopCacheReadCursor{}158			lastsp = sp159		}160		if sp != nil {161			cur := sp.gc.curSnapshot()162			if cur != nil {163				pkts = cursor.advance(cur)164			}165		}166		if len(pkts) == 0 {167			select {168			case <-close:169				return170			case <-ss.notify:171			}172		} else {173			for _, pkt := range pkts {174				if err := seqsplit.do(pkt); err != nil {175					return176				}177			}178		}179	}180}181func (s *PubSub) notifySub() {182	s.sub.Range(func(key, value interface{}) bool {183		ss := key.(*streamSub)184		select {185		case ss.notify <- struct{}{}:186		default:187		}188		return true189	})190}191func (s *PubSub) SetPub(r av.PacketReader) {192	ctx, cancel := context.WithCancel(context.Background())193	defer cancel()194	sp := &streamPub{195		cancel: cancel,196		gc:     &gopCache{},197	}198	oldsp := (*streamPub)(atomic.SwapPointer(&s.pub, unsafe.Pointer(sp)))199	if oldsp != nil {200		oldsp.cancel()201	}202	seqmerge := mergeSeqhdr{203		cb: func(pkt av.Packet) {204			sp.gc.put(pkt)205			s.notifySub()206		},207	}208	for {209		select {210		case <-ctx.Done():211			return212		default:213		}214		pkt, err := r.ReadPacket()215		if err != nil {216			return217		}218		seqmerge.do(pkt)219	}220}...

1import "fmt"2type gop struct {3}4func (g gop) compare(g1 gop) bool {5    if g.name == g1.name && g.age == g1.age {6    }7}8func main() {9    g := gop{"gop", 20}10    g1 := gop{"gop", 20}11    fmt.Println(g.compare(g1))12}13import "fmt"14type gop struct {15}16func (g *gop) compare(g1 *gop) bool {17    if g.name == g1.name && g.age == g1.age {18    }19}20func main() {21    g := gop{"gop", 20}22    g1 := gop{"gop", 20}23    fmt.Println(g.compare(&g1))24}25import "fmt"26type gop struct {27}28func (g *gop) compare(g1 gop) bool {29    if g.name == g1.name && g.age == g1.age {30    }31}32func main() {33    g := gop{"gop", 20}34    g1 := gop{"gop", 20}35    fmt.Println(g.compare(g1))36}37import "fmt"38type gop struct {39}40func (g gop) compare(g1 *gop) bool {41    if g.name == g1.name && g.age == g1.age {42    }43}44func main() {45    g := gop{"gop", 20}46    g1 := gop{"gop", 20}47    fmt.Println(g.compare(&g1))48}

1import "fmt"2type gop struct {3}4func (g gop) compare(g1 gop) bool {5   if g.name == g1.name && g.age == g1.age {6   }7}8func main() {9   g1 := gop{"gopinath", 34}10   g2 := gop{"gopinath", 34}11   fmt.Println(g1.compare(g2))12}13import "fmt"14type gop struct {15}16func (g *gop) changeName(n string) {17}18func main() {19   g1 := gop{"gopinath", 34}20   g1.changeName("gopinath k")21   fmt.Println(g1.name)22}23import "fmt"24type gop struct {25}26func (g *gop) changeName(n string) {27}28func main() {29   g1 := &gop{"gopinath", 34}30   g1.changeName("gopinath k")31   fmt.Println(g1.name)32}

1import (2func main() {3	a := gop.Gop{1, 2, 3}4	b := gop.Gop{1, 2, 3}5	c := gop.Gop{1, 2, 4}6	fmt.Println(a.Compare(b))7	fmt.Println(a.Compare(c))8}9import (10func main() {11	a := gop.Gop{1, 2, 3}12	b := gop.Gop{1, 2, 3}13	c := gop.Gop{1, 2, 4}14	fmt.Println(a.Compare(b))15	fmt.Println(a.Compare(c))16}17import (18func main() {19	a := gop.Gop{1, 2, 3}20	b := gop.Gop{1, 2, 3}21	c := gop.Gop{1, 2, 4}22	fmt.Println(a.Compare(b))23	fmt.Println(a.Compare(c))24}25import (26func main() {27	a := gop.Gop{1, 2, 3}28	b := gop.Gop{1, 2, 3}29	c := gop.Gop{1, 2, 4}30	fmt.Println(a.Compare(b))31	fmt.Println(a.Compare(c))32}33import (34func main() {35	a := gop.Gop{1, 2, 3}36	b := gop.Gop{1, 2, 3}37	c := gop.Gop{1, 2, 4}38	fmt.Println(a.Compare(b))39	fmt.Println(a.Compare(c))40}41import (42func main() {43	a := gop.Gop{1, 2, 3}

1import "fmt"2func main() {3    g := gop{1, 2}4    fmt.Println(g.compare())5}6import "fmt"7func main() {8    g := gop{1, 2}9    fmt.Println(g.compare())10}11import "fmt"12func main() {13    g := gop{1, 2}14    fmt.Println(g.compare())15}16import "fmt"17func main() {18    g := gop{1, 2}19    fmt.Println(g.compare())20}21import "fmt"22func main() {23    g := gop{1, 2}24    fmt.Println(g.compare())25}26import "fmt"27func main() {28    g := gop{1, 2}29    fmt.Println(g.compare())30}31import "fmt"32func main() {33    g := gop{1, 2}34    fmt.Println(g.compare())35}36import "fmt"37func main() {38    g := gop{1, 2}39    fmt.Println(g.compare())40}41import "fmt"42func main() {43    g := gop{1, 2}44    fmt.Println(g.compare())45}46import "fmt"47func main() {48    g := gop{1, 2}49    fmt.Println(g.compare())50}51import "fmt"52func main() {53    g := gop{1, 2}54    fmt.Println(g.compare())

1import (2func main() {3	g := gop{1, 2}4	g.compare()5}6import (7func main() {8	g := gop{1, 2}9	g.compare()10}

1import "fmt"2func main() {3    gop := Gop{Age: 10}4    gop2 := Gop{Age: 20}5    fmt.Println(gop.compare(gop2))6}7import "fmt"8func main() {9    gop := Gop{Age: 10}10    gop2 := Gop{Age: 20}11    fmt.Println(gop.compare(gop2))12}13This is how I have been using the code. I have 2 files in the same directory. One is the main file, and the other is a file that I have to import. I am using the code from the imported file in the main file. The code is working fine. But the problem is, when I run the code, I get the following error:14import "fmt"15type Gop struct {16}17func (gop *Gop) compare(gop2 Gop) bool {18}19func main() {20    gop := Gop{Age: 10}21    gop2 := Gop{Age: 20}22    fmt.Println(gop.compare(gop2))23}24import "fmt"25func main() {26    gop := Gop{Age: 10}27    gop2 := Gop{Age: 20}28    fmt.Println(gop.compare(gop2))29}

1import (2type Config struct {3	General struct {4	}5}6func main() {7	var (8		configFile = getopt.StringLong("config", 'c', "config.gcfg", "configuration file")9	getopt.Parse()10	err := gcfg.ReadFileInto(&config, *configFile)11	if err != nil {12		fmt.Println(err)13	}14	if len(getopt.Args()) != 2 {15		fmt.Println("Usage: gop <dir1> <dir2>")16	}17	dir1 := getopt.Args()[0]18	dir2 := getopt.Args()[1]19	gop := new(Gop)20	gop.Compare()21}22import (23type Config struct {24	General struct {25	}26}27func main() {28	var (29		configFile = getopt.StringLong("config", 'c', "config.gcfg", "configuration file")30	getopt.Parse()31	err := gcfg.ReadFileInto(&config, *configFile)32	if err != nil {33		fmt.Println(err)34	}35	if len(getopt.Args()) != 2 {36		fmt.Println("Usage: gop <dir1> <dir2>")37	}38	dir1 := getopt.Args()[0]39	dir2 := getopt.Args()[1]40	gop := new(Gop)

1func main() {2	fmt.Println("Enter two numbers")3	fmt.Scanln(&a)4	fmt.Scanln(&b)5	g.compare(a, b)6}7func main() {8	fmt.Println("Enter two numbers")9	fmt.Scanln(&a)10	fmt.Scanln(&b)11	g.compare(a, b)12}