code: public CallStatus call() throws Exception {
          if (this instanceof BlockingOperation) {
              BlockingOperation blockingOperation = (BlockingOperation) this;
              if (blockingOperation.shouldWait()) {
                  return WAIT;
              }
          }
  
          run();
          return returnsResponse() ? DONE_RESPONSE : DONE_VOID;
      }
docs: Call the operation and returns the CallStatus.
  
  An Operation should either implement call or run; not both. If run is
  implemented, then the system remains backwards compatible to prevent
  making massive code changes while adding this feature.
  
  In the future all {@link #run()} methods will be replaced by call
  methods.
  
  The call method looks very much like the {@link #run()} method and it is
  very close to {@link Runnable#run()} and {@link Callable#call()}.
  
  The main difference between a run and call, is that the returned
  CallStatus from the call can tell something about the actual execution.
  For example it could tell that some waiting is required in case of a
  {@link BlockingOperation}. Or that the actual execution work is
  offloaded to some executor in case of an
  {@link com.hazelcast.core.Offloadable}
  {@link com.hazelcast.map.impl.operation.EntryOperation}.
  
  In the future new types of CallStatus are expected to be added, e.g. for
  interleaving.
  
  In the future it is very likely that for regular Operation that want to
  return a concrete response, the actual response can be returned directly.
  In this case we'll change the return type to {@link Object} to prevent
  forcing the response to be wrapped in a {@link CallStatus#DONE_RESPONSE}
  monad since that would force additional litter to be created.
  
  @return the CallStatus.
  @throws Exception if something failed while executing 'call'.
  @see #run()