Order functions by their first use

[onechat] / syncer.go

diff --git a/syncer.go b/syncer.go
index 196eb97a7da428935c0ce81eb9567c4d0c20d4bf..bf2a5ff98003d5a4155626ae1847ae3876df52c2 100644 (file)
--- a/syncer.go
+++ b/syncer.go
@@ -67,51 +67,6 @@ func (s *Syncer) Written() {
        s.start()
 }
 
-// Flush returns when every write before the call is durable.
-func (s *Syncer) Flush(ctx context.Context) error {
-       s.mutex.Lock()
-
-       target := s.written
-       s.mutex.Unlock()
-
-       for {
-               s.mutex.Lock()
-
-               reached := s.durable >= target
-               failure := s.failure
-               done := s.done
-               s.mutex.Unlock()
-
-               if reached {
-                       return nil
-               }
-
-               if failure != nil {
-                       return failure
-               }
-
-               select {
-               case <-done:
-               case <-ctx.Done():
-                       return ctx.Err()
-               }
-       }
-}
-
-// Close makes every write durable, waits for the syncs, and closes the
-// directory.
-func (s *Syncer) Close() error {
-       err := s.Flush(context.Background())
-       s.workers.Wait()
-
-       if s.file != nil {
-               err = errors.Join(err, s.file.Close())
-               s.file = nil
-       }
-
-       return err
-}
-
 // start starts a sync of the writes so far when none runs and a write is not
 // durable. The caller holds the mutex.
 func (s *Syncer) start() {
@@ -147,3 +102,48 @@ func (s *Syncer) run(target uint64) {
        s.done = make(chan struct{})
        s.start()
 }
+
+// Close makes every write durable, waits for the syncs, and closes the
+// directory.
+func (s *Syncer) Close() error {
+       err := s.Flush(context.Background())
+       s.workers.Wait()
+
+       if s.file != nil {
+               err = errors.Join(err, s.file.Close())
+               s.file = nil
+       }
+
+       return err
+}
+
+// Flush returns when every write before the call is durable.
+func (s *Syncer) Flush(ctx context.Context) error {
+       s.mutex.Lock()
+
+       target := s.written
+       s.mutex.Unlock()
+
+       for {
+               s.mutex.Lock()
+
+               reached := s.durable >= target
+               failure := s.failure
+               done := s.done
+               s.mutex.Unlock()
+
+               if reached {
+                       return nil
+               }
+
+               if failure != nil {
+                       return failure
+               }
+
+               select {
+               case <-done:
+               case <-ctx.Done():
+                       return ctx.Err()
+               }
+       }
+}