tevino / abool Goto Github PK

The command go mod download github.com/tevino/abool/v2 fails with the following error :

go: github.com/tevino/abool/[email protected]: go.mod has non-.../v2 module path "github.com/tevino/abool" (and .../v2/go.mod does not exist) at revision v2.0.0

Would it be possible to cut a release tag, so that everyone has a clear version number to point to in their go.mod?

can we have an additional operation to change the value from true->false and vice versa, atomically?

The following piece of code demonstrates the bug.
I initially added this as a test, but was then unable to solve the bug, using only one atomic function.

func TestSetToIfAfterMultipleToggles(t *testing.T) {
	v := New() // false

	v.Toggle() // true
	v.Toggle() // false
	v.Toggle() // true

	// As v is true, it should now be flipped to false
	v.SetToIf(true, false)
	expected := false

	if v.IsSet() != expected {
		t.Fatalf("Toggling the value atleast 3 times, until it's true, `SetToIf(true, false)` should flip v to false, expected: %v, got %v", expected, v.IsSet())
	}
}

This happens, as Toggle just increases the int32 by +1 every time, but SetToIf only compares the int32 against 1 and 0 (instead of odd and even).

Hey, I've been using something similar to your atomicbool - adapted from https://gist.github.com/mahan/6256149

Why I think this is a valid use case

sync.Mutex doesn't allow us to examine state. There are cases where we want to examine a lock and if we cannot acquire it, just return.
Consider the scenario where multiple goroutines call a function, and only one of them needs to proceed. The others can return out immediately (like a http handler that needs to do admin work, what if the request was called multiple times, something to say "already in progress" . this atomic bool is perfect for it ).

func (s *Server) DoSomethingImportant(w http.ResponseWriter, r *http.Request) {
     // check if we can set it to true and proceed
      canProceed := s.DoSomethingImportantInProgress.TestAndSet()
      if !canProceed {
             // message that we cannot proceed
             return
      }

      defer s.DoSomethingImportantInProgress.UnSet()

      // do the rest...
}

Essentially its just the following code. Would you like me to send it as a PR instead ?

func (ab *AtomicBool) TestAndSet() bool {
      return atomic.CompareAndSwapInt32((*int32)(ab), 0, 1)
}