Delegator
@param logicalAddress The logical address
@param address The address
976741
public void join(org.ironjacamar.core.spi.workmanager.Address logicalAddress, org.jgroups.Address address)
   {
      super.join(logicalAddress, address);
   }
593683
public long executeStartWork(org.ironjacamar.core.spi.workmanager.Address logicalAddress,
                                ClassBundle classBundle, byte[] b)
      throws WorkException
   {
      ByteArrayInputStream bias = new ByteArrayInputStream(b);
      WorkObjectInputStream wois = null;
      try
      {
         WorkClassLoader wcl = SecurityActions.createWorkClassLoader(classBundle);
         
         wois = new WorkObjectInputStream(bias, wcl);

         DistributableWork dw = (DistributableWork)wois.readObject();

         return localStartWork(logicalAddress, dw);
      }
      catch (WorkException we)
      {
         throw we;
      }
      catch (Throwable t)
      {
         throw new WorkException("Error during doWork: " + t.getMessage(), t);
      }
      finally
      {
         if (wois != null)
         {
            try
            {
               wois.close();
            }
            catch (IOException ioe)
            {
               // Ignore
            }
         }
      }
   }
767467
public void localUpdateLongRunningFree(Address logicalAddress, Long freeCount)
   {
      if (trace)
         log.tracef("LOCAL_UPDATE_LONGRUNNING_FREE(%s, %d)", logicalAddress, freeCount);

      DistributedWorkManager dwm = workManagerCoordinator.resolveDistributedWorkManager(logicalAddress);

      if (dwm != null)
      {
         Collection<NotificationListener> copy =
            new ArrayList<NotificationListener>(dwm.getNotificationListeners());
         for (NotificationListener nl : copy)
         {
            nl.updateLongRunningFree(logicalAddress, freeCount);
         }
      }
      else
      {
         WorkManagerEventQueue wmeq = WorkManagerEventQueue.getInstance();
         wmeq.addEvent(new WorkManagerEvent(WorkManagerEvent.TYPE_UPDATE_LONG_RUNNING, logicalAddress, freeCount));
      }
   }
914959
public void call(Long nid, Event event, final Callback callback) {
        delegate.call(convertToAddress(nid), event, callback);
    }
520998
public void setInetAddress(final String address) {
        try {
            this.inetAddress = InetAddress.getByName(address);
        } catch (final UnknownHostException e) {
            throw new RuntimeException("Invalid address " + address);
        }
    }
901555
function detatchDelegatedLogic({
    delegatedEventName,
    pathStr,
    allEvents
}) {
    const retain = [];
    const events = allEvents[delegatedEventName];

    nofn.forEach(events, (event) => {
        // pathStr is assigned to info in delegateListener
        if (event.info.pathStr !== pathStr) {
            retain.push(event);
        }
    });

    if (retain.length) {
        allEvents[delegatedEventName] = retain;
    } else {
        delete allEvents[delegatedEventName];
    }
}
598983
public static ModelNode createReadAttributeOperation(PathAddress address, String name) {
        return createAttributeOperation(ModelDescriptionConstants.READ_ATTRIBUTE_OPERATION, address, name);
    }
1127810
public GeoLocationResponse addAddress(final String address) {
        if (StringUtils.isNotBlank(address)) {
            this.addresses.add(address);
        }
        return this;
    }
584604
public void setCcAddresses(java.util.Collection<String> ccAddresses) {
        if (ccAddresses == null) {
            this.ccAddresses = null;
            return;
        }

        this.ccAddresses = new java.util.ArrayList<String>(ccAddresses);
    }
1076497
public void localDeltaDoWorkAccepted(Address address)
   {
      if (trace)
         log.tracef("LOCAL_DELTA_DOWORK_ACCEPTED(%s)", address);

      DistributedWorkManager dwm = workManagerCoordinator.resolveDistributedWorkManager(address);

      if (dwm != null)
      {
         Collection<NotificationListener> copy =
            new ArrayList<NotificationListener>(dwm.getNotificationListeners());
         for (NotificationListener nl : copy)
         {
            nl.deltaDoWorkAccepted();
         }
      }
   }
1349965
public static ModelNode createRemoveOperation(final ModelNode address, final boolean recursive) {
        final ModelNode op = createRemoveOperation(address);
        op.get(RECURSIVE).set(recursive);
        return op;
    }
797431
@SuppressWarnings("unchecked")
	public void setClusterNodeAddress(ClusteredCacheData cacheData, Address clusterNodeAddress) {
		cacheData.getNode().put(CLUSTER_NODE_ADDRESS_NODE_KEY,clusterNodeAddress);
	}
1329712
private void addAddressHelper(InternetAddressSet set, String address) {
    if (address.contains(",") || address.contains(";")) {
      String[] addresses = address.split("[,;]");
      
      for (String a : addresses) {
        set.add(a);
      }
    }
    else {
      set.add(address);
    }
  }
493410
public void setAddresses(java.util.Collection<Address> addresses) {
        if (addresses == null) {
            this.addresses = null;
            return;
        }

        this.addresses = new java.util.ArrayList<Address>(addresses);
    }
401606
public void addAddress(PeerAddress peerAddress) {
        int newMax;
        lock.lock();
        try {
            if (addInactive(peerAddress)) {
                newMax = getMaxConnections() + 1;
                setMaxConnections(newMax);
            }
        } finally {
            lock.unlock();
        }
    }
804861
private <T> T internalActorOf(final Class<T> protocol, final Address address) {
    final Actor actor = directory.actorOf(address);

    try {
      if (actor != null) {
        return stage().actorAs(actor, protocol);
      } else {
        logger().log("Actor with address: " + address + " not found; protocol is: " + protocol.getName());
      }
    } catch (Exception e) {
      logger().log("Error providing protocol: " + protocol.getName() + " for actor with address: " + address, e);
    }
    return null;
  }
727751
@Nullable
  public static InetSocketAddress parseInetSocketAddress(String address) throws IOException {
    if (address == null) {
      return null;
    }
    String[] strArr = address.split(":");
    if (strArr.length != 2) {
      throw new IOException("Invalid InetSocketAddress " + address);
    }
    return new InetSocketAddress(strArr[0], Integer.parseInt(strArr[1]));
  }