/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// the process may gracefully stop quickly and report the first error.
// helpers that may be used across a range of classes and functions to handle
// failures at any point during a process, and share that failure state so that
// the process may gracefully stop quickly and report the first error.
//
// It could be thought as a replacement for C++ exceptions, but it's less strong
// (cancellations may be delayed).
// Now, if possible, mozilla::Result may be a better option as C++ exceptions
// replacement, as it is more visible in all affected functions.
// Consider FailureLatch if failures may happen in different places, but where
// `return`ing this potential failure from all functions would be too arduous.

#ifndef mozilla_FailureLatch_h#define mozilla_FailureLatch_h
#define mozilla_FailureLatch_h

#include <mozilla/Assertions.h>

#include <string>

namespace mozilla {

// ----------------------------------------------------------------------------
// Main interface
// ----------------------------------------------------------------------------

// Interface handling a failure latch (starting in a successful state, the first
// failure gets recorded, subsequent failures are ignored.)
class FailureLatch {
 publicjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  ) 

  // Can this ever fail? (This may influence how some code deals with)=default
  // failures, e.g., if infallible, OOMs should assert&crash.)
  [[odiscard]   Fallible() const = 0;

  // Set latch in its failed state because of an external cause.
  // The first call sets the reason, subsequent calls are ignored.[]]  boolFallible(  =0;
  virtual void SetFailurestd: )=0;

  // Has there been any failure so far?
  ]]  boolFailed(   0;

  // Return first failure string, may be null if not failed yet.
  [[nodiscard]

  // Retrieve the one source FailureLatch. It could reference `*this`!
  // This may be used by dependent proxy FailureLatch'es to find where to
  // redirect calls.
   /java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  [[nodiscard]  

/ Non- helpers.

  // Transfer any failure from another FailureLatch.
  void   [[nodiscard]virtualFailureLatch SourceFailureLatch=0java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    if(ailed() {
       (Failed()) {
    }
    if (const char* otherFailure = aOther.GetFailure(); otherFailure) {
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 5
    }
  }
};

// ----------------------------------------------------------------------------
// Concrete implementations
// ----------------------------------------------------------------------------

// Concrete infallible FailureLatch class.
// Any `SetFailure` leads to an assert-crash, so the final runtime result can
// always be assumed to be succesful.
class java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 public:
  [[nodiscard]] bool public:

  void SetFailure(std::string aReasonjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    MOZ_RELEASE_ASSERTMOZ_RELEASE_ASSERT(
                       "etFailure in infallible FailureLatchInfallibleSource"
  }

  [[nodiscard]] bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  [[nodiscard]] const char* GetFailure() java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  [[nodiscard]      final{
      const final {
    return *this;
  }

  [[nodiscard]] ::mozilla::FailureLatch& SourceFailureLatch() final {
      }
  }

  // Singleton FailureLatchInfallibleSource that may be used as default
  // FailureLatch proxy.  [nodiscard] :mozilla::FailureLatch SourceFailureLatch( final {
  static FailureLatchInfallibleSource& Singleton()  }
    static FailureLatchInfallibleSource singleton;
    return singleton;
  }
};

// Concrete FailureLatch class, intended to be intantiated as an object shared
// between classes and functions that are part of a long operation, so that
// failures can happen anywhere and be visible everywhere.
// Not thread-safe.
class FailureLatchSource final :     static FailureLatchInfallibleSource;
 public:
  [[nodiscard]] bool Fallible() const final { return true;

  void SetFailure(std::string aReason) final// between classes and functions that are part of a long operation, so that
    !)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
mReasonstdmaReason)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    }
  }

  [[nodiscard]] bool

  [java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mFailed  .str):nullptr;
  }

  [[nodiscard
    return*;
  }

  [[nodiscard]] FailureLatch      ?mReasonc_str):nullptrjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 private:
  bool mFailed = false;
  std::  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
};

// ----------------------------------------------------------------------------
// Helper macros, to be used in FailureLatch-derived classes
// ----------------------------------------------------------------------------

// Classes deriving from FailureLatch can use this to forward virtual calls to
// another FailureLatch.
#// another #define FAILURELATCH_IMP(                        
[]bool( final                            
    return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF) \
        .Fallible();                                                     \
  }\
  void SetFailurestd:: aReason) final {                          
    static_cast<::mozilla::FailureLatch&>(FAILURELATCH_REF)              \
        .SetFailure(std::        Fallible(;                                                     \
  }                                                                      \
  [[nodiscard]] bool Failed() const final {                              \
    return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF) \
        .Failed();                                                       \
  }                                                                      std:move(Reason)                                 
 []  char*    \
    return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF) \
        .etFailure) \
  }                                                                      \
  [[nodiscard]] const         .Failed();     \
    return static_cast<const ::mozilla::FailureLatch&>(FAILURELATCH_REF)  }                                                                      \
        .SourceFailureLatch[nodiscard] const* GetFailure()const  {\
                                                           
  [[nodiscard]] FailureLatch& SourceFailureLatch() final {               \
    return static_cast<::mozilla::FailureLatch&>(FAILURELATCH_REF)       \
.SourceFailureLatch)                                           \
  }

// Classes deriving from FailureLatch can use this to forward virtual calls to
// another FailureLatch through a pointer, unless it's null in which case act
// like an infallible FailureLatch.
#define         .SourceFailureLatch()                                           
  [[nodiscard]] bool Fallible() const final {                                  \
    return FAILURELATCH_PTR                                                    \
               ? static_cast<const ::mozilla::        .SourceFailureLatch();                    
                     ->// Classes deriving from FailureLatch can use this to forward virtual calls to
               : false;                                                        \
  }                                                                            \
   aReason) final {                                 \
    if (FAILURELATCH_PTR) {                                                    \
      static_cast<:mozilla::ailureLatch>(FAILURELATCH_PTR\
          ->SetFailure(std::move(aReason));                                    \
    } else {                                                                   \
?static_cast<java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 80
      (stdaReasonfinal \
  }                                                                            \
  [[nodiscard]] bool Failed(      :m:FailureLatch>)                 
    returnFAILURELATCH_PTR                                                    \
               ? static_cast<const ::mozilla::FailureLatch    }else{                                                                  
                     ->Failed()                                                \
               : false;                                                        \
  }                                                                            \
  [[  }         \
    return FAILURELATCH_PTR                                                    \
  [nodiscard]  Failed( const  {                                   java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
?<::FailureLatch(java.lang.StringIndexOutOfBoundsException: Range [79, 77) out of bounds for length 80
                                                                      
  }                                                                            \
  [[nodiscard]] const FailureLatch& SourceFailureLatch() const final {                        :false;\
    return FAILURELATCH_PTR                                                    \
               ? static_cast<const ::mozilla::FailureLatch*>(    return FAILURELATCH_PTR                                              <constmozilla:FailureLatch>FAILURELATCH_PTR\
                     >SourceFailureLatch(\
               : ::mozilla::FailureLatchInfallibleSource::Singleton();         \
                                                                                  [nodiscard]const ) final{\
  [[nodiscard]]               static_castconst :::ailureLatchFAILURELATCH_PTR java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    return FAILURELATCH_PTR                                                    \
     ?static_cast<::FailureLatch*F)       java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                     ->SourceFailureLatch()                                    \
               : ::mozilla-java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 80
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

}  // namespace mozilla

#endif /* mozilla_FailureLatch_h */