mirror/goirc
1
0
Fork 0
mirror of https://github.com/fluffle/goirc synced 2025-05-12 18:44:50 +00:00
Code Issues Releases Wiki Activity

Remove state.StateTracker stutter, hide it in Conn.

Browse source
This commit is contained in:
Alex Bramley 2013-02-16 11:29:56 +00:00
parent a88b866b63
commit 45d7b3317f
7 changed files with 107 additions and 107 deletions
Download patch file Download diff file Expand all files Collapse all files

72
state/mock_tracker.go
View file

@ -7,144 +7,144 @@ import (
gomock "code.google.com/p/gomock/gomock"
)
// Mock of StateTracker interface
type MockStateTracker struct {
// Mock of Tracker interface
type MockTracker struct {
ctrl *gomock.Controller
recorder *_MockStateTrackerRecorder
recorder *_MockTrackerRecorder
}
// Recorder for MockStateTracker (not exported)
type _MockStateTrackerRecorder struct {
mock *MockStateTracker
// Recorder for MockTracker (not exported)
type _MockTrackerRecorder struct {
mock *MockTracker
}
func NewMockStateTracker(ctrl *gomock.Controller) *MockStateTracker {
mock := &MockStateTracker{ctrl: ctrl}
mock.recorder = &_MockStateTrackerRecorder{mock}
func NewMockTracker(ctrl *gomock.Controller) *MockTracker {
mock := &MockTracker{ctrl: ctrl}
mock.recorder = &_MockTrackerRecorder{mock}
return mock
}
func (_m *MockStateTracker) EXPECT() *_MockStateTrackerRecorder {
func (_m *MockTracker) EXPECT() *_MockTrackerRecorder {
return _m.recorder
}
func (_m *MockStateTracker) NewNick(nick string) *Nick {
func (_m *MockTracker) NewNick(nick string) *Nick {
ret := _m.ctrl.Call(_m, "NewNick", nick)
ret0, _ := ret[0].(*Nick)
return ret0
}
func (_mr *_MockStateTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "NewNick", arg0)
}
func (_m *MockStateTracker) GetNick(nick string) *Nick {
func (_m *MockTracker) GetNick(nick string) *Nick {
ret := _m.ctrl.Call(_m, "GetNick", nick)
ret0, _ := ret[0].(*Nick)
return ret0
}
func (_mr *_MockStateTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNick", arg0)
}
func (_m *MockStateTracker) ReNick(old string, neu string) {
func (_m *MockTracker) ReNick(old string, neu string) {
_m.ctrl.Call(_m, "ReNick", old, neu)
}
func (_mr *_MockStateTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "ReNick", arg0, arg1)
}
func (_m *MockStateTracker) DelNick(nick string) {
func (_m *MockTracker) DelNick(nick string) {
_m.ctrl.Call(_m, "DelNick", nick)
}
func (_mr *_MockStateTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNick", arg0)
}
func (_m *MockStateTracker) NewChannel(channel string) *Channel {
func (_m *MockTracker) NewChannel(channel string) *Channel {
ret := _m.ctrl.Call(_m, "NewChannel", channel)
ret0, _ := ret[0].(*Channel)
return ret0
}
func (_mr *_MockStateTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "NewChannel", arg0)
}
func (_m *MockStateTracker) GetChannel(channel string) *Channel {
func (_m *MockTracker) GetChannel(channel string) *Channel {
ret := _m.ctrl.Call(_m, "GetChannel", channel)
ret0, _ := ret[0].(*Channel)
return ret0
}
func (_mr *_MockStateTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "GetChannel", arg0)
}
func (_m *MockStateTracker) DelChannel(channel string) {
func (_m *MockTracker) DelChannel(channel string) {
_m.ctrl.Call(_m, "DelChannel", channel)
}
func (_mr *_MockStateTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "DelChannel", arg0)
}
func (_m *MockStateTracker) Me() *Nick {
func (_m *MockTracker) Me() *Nick {
ret := _m.ctrl.Call(_m, "Me")
ret0, _ := ret[0].(*Nick)
return ret0
}
func (_mr *_MockStateTrackerRecorder) Me() *gomock.Call {
func (_mr *_MockTrackerRecorder) Me() *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Me")
}
func (_m *MockStateTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) {
func (_m *MockTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) {
ret := _m.ctrl.Call(_m, "IsOn", channel, nick)
ret0, _ := ret[0].(*ChanPrivs)
ret1, _ := ret[1].(bool)
return ret0, ret1
}
func (_mr *_MockStateTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "IsOn", arg0, arg1)
}
func (_m *MockStateTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs {
func (_m *MockTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs {
ret := _m.ctrl.Call(_m, "Associate", channel, nick)
ret0, _ := ret[0].(*ChanPrivs)
return ret0
}
func (_mr *_MockStateTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Associate", arg0, arg1)
}
func (_m *MockStateTracker) Dissociate(channel *Channel, nick *Nick) {
func (_m *MockTracker) Dissociate(channel *Channel, nick *Nick) {
_m.ctrl.Call(_m, "Dissociate", channel, nick)
}
func (_mr *_MockStateTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call {
func (_mr *_MockTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Dissociate", arg0, arg1)
}
func (_m *MockStateTracker) Wipe() {
func (_m *MockTracker) Wipe() {
_m.ctrl.Call(_m, "Wipe")
}
func (_mr *_MockStateTrackerRecorder) Wipe() *gomock.Call {
func (_mr *_MockTrackerRecorder) Wipe() *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "Wipe")
}
func (_m *MockStateTracker) String() string {
func (_m *MockTracker) String() string {
ret := _m.ctrl.Call(_m, "String")
ret0, _ := ret[0].(string)
return ret0
}
func (_mr *_MockStateTrackerRecorder) String() *gomock.Call {
func (_mr *_MockTrackerRecorder) String() *gomock.Call {
return _mr.mock.ctrl.RecordCall(_mr.mock, "String")
}

36
state/tracker.go
View file

@ -5,7 +5,7 @@ import (
)
// The state manager interface
type StateTracker interface {
type Tracker interface {
// Nick methods
NewNick(nick string) *Nick
GetNick(nick string) *Nick
@ -63,7 +63,7 @@ func (st *stateTracker) Wipe() {
// can be properly tracked for state management purposes.
func (st *stateTracker) NewNick(n string) *Nick {
if _, ok := st.nicks[n]; ok {
logging.Warn("StateTracker.NewNick(): %s already tracked.", n)
logging.Warn("Tracker.NewNick(): %s already tracked.", n)
return nil
}
st.nicks[n] = NewNick(n)
@ -93,10 +93,10 @@ func (st *stateTracker) ReNick(old, neu string) {
ch.lookup[neu] = nk
}
} else {
logging.Warn("StateTracker.ReNick(): %s already exists.", neu)
logging.Warn("Tracker.ReNick(): %s already exists.", neu)
}
} else {
logging.Warn("StateTracker.ReNick(): %s not tracked.", old)
logging.Warn("Tracker.ReNick(): %s not tracked.", old)
}
}
@ -106,17 +106,17 @@ func (st *stateTracker) DelNick(n string) {
if nk != st.me {
st.delNick(nk)
} else {
logging.Warn("StateTracker.DelNick(): won't delete myself.")
logging.Warn("Tracker.DelNick(): won't delete myself.")
}
} else {
logging.Warn("StateTracker.DelNick(): %s not tracked.", n)
logging.Warn("Tracker.DelNick(): %s not tracked.", n)
}
}
func (st *stateTracker) delNick(nk *Nick) {
if nk == st.me {
// Shouldn't get here => internal state tracking code is fubar.
logging.Error("StateTracker.DelNick(): TRYING TO DELETE ME :-(")
logging.Error("Tracker.DelNick(): TRYING TO DELETE ME :-(")
return
}
delete(st.nicks, nk.Nick)
@ -126,7 +126,7 @@ func (st *stateTracker) delNick(nk *Nick) {
if len(ch.nicks) == 0 {
// Deleting a nick from tracking shouldn't empty any channels as
// *we* should be on the channel with them to be tracking them.
logging.Error("StateTracker.delNick(): deleting nick %s emptied "+
logging.Error("Tracker.delNick(): deleting nick %s emptied "+
"channel %s, this shouldn't happen!", nk.Nick, ch.Name)
}
}
@ -136,7 +136,7 @@ func (st *stateTracker) delNick(nk *Nick) {
// can be properly tracked for state management purposes.
func (st *stateTracker) NewChannel(c string) *Channel {
if _, ok := st.chans[c]; ok {
logging.Warn("StateTracker.NewChannel(): %s already tracked.", c)
logging.Warn("Tracker.NewChannel(): %s already tracked.", c)
return nil
}
st.chans[c] = NewChannel(c)
@ -156,7 +156,7 @@ func (st *stateTracker) DelChannel(c string) {
if ch, ok := st.chans[c]; ok {
st.delChannel(ch)
} else {
logging.Warn("StateTracker.DelChannel(): %s not tracked.", c)
logging.Warn("Tracker.DelChannel(): %s not tracked.", c)
}
}
@ -191,21 +191,21 @@ func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) {
// Associates an already known nick with an already known channel.
func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs {
if ch == nil || nk == nil {
logging.Error("StateTracker.Associate(): passed nil values :-(")
logging.Error("Tracker.Associate(): passed nil values :-(")
return nil
} else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch {
// As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel.
logging.Error("StateTracker.Associate(): channel %s not found in "+
logging.Error("Tracker.Associate(): channel %s not found in "+
"(or differs from) internal state.", ch.Name)
return nil
} else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk {
logging.Error("StateTracker.Associate(): nick %s not found in "+
logging.Error("Tracker.Associate(): nick %s not found in "+
"(or differs from) internal state.", nk.Nick)
return nil
} else if _, ok := nk.IsOn(ch); ok {
logging.Warn("StateTracker.Associate(): %s already on %s.",
logging.Warn("Tracker.Associate(): %s already on %s.",
nk.Nick, ch.Name)
return nil
}
@ -220,18 +220,18 @@ func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs {
// any common channels with, and channels we're no longer on.
func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) {
if ch == nil || nk == nil {
logging.Error("StateTracker.Dissociate(): passed nil values :-(")
logging.Error("Tracker.Dissociate(): passed nil values :-(")
} else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch {
// As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel.
logging.Error("StateTracker.Dissociate(): channel %s not found in "+
logging.Error("Tracker.Dissociate(): channel %s not found in "+
"(or differs from) internal state.", ch.Name)
} else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk {
logging.Error("StateTracker.Dissociate(): nick %s not found in "+
logging.Error("Tracker.Dissociate(): nick %s not found in "+
"(or differs from) internal state.", nk.Nick)
} else if _, ok := nk.IsOn(ch); !ok {
logging.Warn("StateTracker.Dissociate(): %s not on %s.",
logging.Warn("Tracker.Dissociate(): %s not on %s.",
nk.Nick, ch.Name)
} else if nk == st.me {
// I'm leaving the channel for some reason, so it won't be tracked.