public default void guard(Runnable guarded)
   {
      lock();
      
      try
      {
         guarded.run();
      }
      finally
      {
         unlock();
      }
   }
   
   public default <T> T guard(Callable<T> guarded) throws Exception
   {
      T result;
      
      lock();
      
      try
      {
         result = guarded.call();
      }
      finally
      {
         unlock();
      }
      
      return(result);
   }
   
   public default void guardInterruptibly(Runnable guarded) throws InterruptedException
   {
      lockInterruptibly();
      
      try
      {
         guarded.run();
      }
      finally
      {
         unlock();
      }
   }
   
   public default <T> T guardInterruptibly(Callable<T> guarded) throws Exception, InterruptedException
   {
      T result;
      
      lockInterruptibly();
      
      try
      {
         result = guarded.call();
      }
      finally
      {
         unlock();
      }
      
      return(result);
   }
   
   public default boolean tryGuard(Runnable guarded)
   {
      if (!tryLock())
         return(false);
      
      try
      {
         guarded.run();
      }
      finally
      {
         unlock();
      }
      
      return(true);
   }
   
   public default <T> Optional<T> tryGuard(Callable<T> guarded) throws Exception
   {
      T result;
      
      if (!tryLock())
         return(Optional.empty());
      
      try
      {
         result = guarded.call();
      }
      finally
      {
         unlock();
      }
      
      return(Optional.of(result));
   }
   
   public default boolean tryGuard(Runnable guarded, long time, TimeUnit unit) throws InterruptedException
   {
      if (!tryLock(time, unit))
         return(false);
      
      try
      {
         guarded.run();
      }
      finally
      {
         unlock();
      }
      
      return(true);
   }
   
   public default <T> Optional<T> tryGuard(Callable<T> guarded, long time, TimeUnit unit) throws Exception, InterruptedException
   {
      T result;
      
      if (!tryLock(time, unit))
         return(Optional.empty());
      
      try
      {
         result = guarded.call();
      }
      finally
      {
         unlock();
      }
      
      return(Optional.of(result));
   }