// sge.setLength(data.remaining());
            // sge.setLkey(disniRegion.getLocalKey());
            // sgeList.add(sge);
            //
            // sendWR.setSg_list(sgeList);
            // endpoint.postSend(Arrays.asList(sendWR)).execute().free();

            log.debug("DiSNI RDMA send completed, {} bytes", data.remaining());

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;

            sge.setLength(data.remaining());
            sge.setLkey(disniRegion.getLocalKey());
            sgeList.add(sge);
            
            sendWR.setSg_list(sgeList);
            endpoint.postSend(Arrays.asList(sendWR)).execute().free();
            
        } catch (Exception e) {
            throw new IOException("RDMA send failed", e);
        }
    }
    
    @Override

 *
 * @author Colin Decker
 */
abstract class Dispatcher {

  /**
   * Returns a dispatcher that queues events that are posted reentrantly on a thread that is already
   * dispatching an event, guaranteeing that all events posted on a single thread are dispatched to
   * all subscribers in the order they are posted.
   *
   * <p>When all subscribers are dispatched to using a <i>direct</i> executor (which dispatches on

   *
   * @param identifier short name for the bus, for logging purposes.
   * @param executor Executor to use to dispatch events. It is the caller's responsibility to shut
   *     down the executor after the last event has been posted to this event bus.
   */
  public AsyncEventBus(String identifier, Executor executor) {
    super(identifier, executor, Dispatcher.legacyAsync(), LoggingHandler.INSTANCE);
  }

  /**

 * the License.
 */

package com.google.common.eventbus;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.base.MoreObjects;

/**
 * Wraps an event that was posted, but which had no subscribers and thus could not be delivered.
 *
 * <p>Registering a DeadEvent subscriber is useful for debugging or logging, as it can detect
 * misconfigurations in a system's event distribution.
 *

appropriate to the circumstances. The project team is obligated to maintain
confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.

## Attribution

   * mutated by the call thread only. If is accessed by background connect threads.
   */
  private val tcpConnectsInFlight = CopyOnWriteArrayList<Plan>()

  /**
   * Results are posted here as they occur. The find job is done when either one plan completes
   * successfully or all plans fail.
   */
  private val connectResults = taskRunner.backend.decorate(LinkedBlockingDeque<ConnectResult>())

Documentation
-------------

More information can be found on [Apache Maven Homepage][maven-home].
Questions related to the usage of Maven should be posted on
the [Maven User List][users-list].


Where can I get the latest release?
-----------------------------------
You can download the release source from our [download page][maven-download].

Contributing

 * worry about being reentrant, unless also called from outside the EventBus.
 *
 * <h2>Dead Events</h2>
 *
 * <p>If an event is posted, but no registered subscribers can accept it, it is considered "dead."
 * To give the system a second chance to handle dead events, they are wrapped in an instance of
 * {@link DeadEvent} and reposted.
 *

    /** No flags set */
    int FLAGS_NONE = 0x00;
    /** Lock and read write and unlock flag */
    int FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK = 0x01;
    /** Receive buffer posted flag */
    int FLAGS_RECEIVE_BUFFER_POSTED = 0x02;
    /** Path names are caseless flag */
    int FLAGS_PATH_NAMES_CASELESS = 0x08;
    /** Path names canonicalized flag */
    int FLAGS_PATH_NAMES_CANONICALIZED = 0x10;