localClearDistributedStatistics

@param logicalAddress the logical address
489318
public void localClearDistributedStatistics(Address logicalAddress)
   {
      if (trace)
         log.tracef("LOCAL_CLEAR_DISTRIBUTED_STATISTICS(%s)", logicalAddress);

      DistributedWorkManager dwm = workManagerCoordinator.resolveDistributedWorkManager(logicalAddress);

      if (dwm != null && dwm.isDistributedStatisticsEnabled())
      {
         DistributedWorkManagerStatisticsValues v =
            new DistributedWorkManagerStatisticsValues(0, 0, 0, 0, 0, 0, 0, 0);
         dwm.getDistributedStatistics().initialize(v);
      }
   }
357493
public static Collection<Comparable<?>> getDatabaseShardingValues(final String logicTable) {
        return null == HINT_MANAGER_HOLDER.get() ? Collections.<Comparable<?>>emptyList() : HINT_MANAGER_HOLDER.get().databaseShardingValues.get(logicTable);
    }
81490
private List<Member> getNonLocalReplicaAddresses() {
        final Collection<Member> dataMembers = nodeEngine.getClusterService().getMembers(DATA_MEMBER_SELECTOR);
        final ArrayList<Member> nonLocalDataMembers = new ArrayList<Member>(dataMembers);
        nonLocalDataMembers.remove(nodeEngine.getLocalMember());
        return nonLocalDataMembers;
    }
227148
@Override
  public synchronized void recordAllocatedEvaluator(final String id) {
    if (this.fileSystem != null && this.changeLogLocation != null) {
      final String entry = ADD_FLAG + id + System.lineSeparator();
      this.logContainerChange(entry);
    }
  }
1277976
public static DestinationAddressAttribute createDestinationAddressAttribute(
			TransportAddress address) {
		DestinationAddressAttribute attribute = new DestinationAddressAttribute();

		attribute.setAddress(address);

		return attribute;
	}
224799
@Override
	public String selectAlternateAddress(List<String> alternates) {
		String alternateAddress = null;
		if (alternates != null && !alternates.isEmpty()) {
			int index = random.nextInt(alternates.size());
			alternateAddress = alternates.remove(index);
		}
		LOG.log(Level.INFO, "selectAlternateAddress " + " alternates = "
				+ alternates + " alternateAddress = " + alternateAddress);

		return alternateAddress;
	}
444173
public boolean doLocalCriteria(StringBuffer strFilter, boolean bIncludeFileName, Vector<BaseField> vParamList)
    {   // Default BaseListener
        if (this.isTable())   // For tables, do the remote criteria now
            return this.getRecord().handleRemoteCriteria(strFilter, bIncludeFileName, vParamList);  // If can't handle remote
        else
            return true;    // Record okay, don't skip it
    }
261871
function(e) {
        e.preventDefault();
        var elem = $(e.target).parents(".bitcoin-address-container");
        this.prepareCopySelection(elem);
        return false;
    }
935849
public void setAddress(final String address) {
		// Do we have a subaddressing account?
		Preconditions.checkArgument(StringUtils.startsWith(this.address, accountId + "+"),
				"Mail address can only be changed when subaddressing is active");
		Preconditions.checkArgument(StringUtils.startsWith(address, accountId), "New mail address %s does not start with accountId=%s", address,
				accountId);
		log.info("Changing mail address from {} to {}", this.address, address);
		this.address = address;
	}
767388
private Address getReplicaAddress(int partitionId, int replicaNumber, int backupCount) {
        IPartition partition = partitionService.getPartition(partitionId);
        Address replicaAddress = partition.getReplicaAddress(replicaNumber);
        if (replicaAddress == null) {
            replicaAddress = waitForReplicaAddress(replicaNumber, partition, backupCount);
        }
        return replicaAddress;
    }
860594
@Override
    public final void setDefaultLocalAddresses(List<? extends SocketAddress> localAddresses) {
        if (localAddresses == null) {
            throw new NullPointerException("localAddresses");
        }
        setDefaultLocalAddresses((Iterable<? extends SocketAddress>) localAddresses);
    }
1316307
private void setAddress(Address address, RolodexContract rolodex) {
        if (rolodex != null) {
            address.setStreet1(rolodex.getAddressLine1());
            address.setStreet2(rolodex.getAddressLine2());
            address.setCity(checkNull(rolodex.getCity()));
            address.setCounty(rolodex.getCounty());
            address.setState(rolodex.getState());
            address.setZipCode(rolodex.getPostalCode());
            if (rolodex.getCountryCode() != null) {
                CountryCodeType.Enum country = CountryCodeType.Enum.forString(rolodex.getCountryCode());
                address.setCountry(country);
            }
        }else {
            address.setStreet1("");
            address.setCity("");
        }
    }
179849
@Override
	public void cacheResult(List<CommerceAddress> commerceAddresses) {
		for (CommerceAddress commerceAddress : commerceAddresses) {
			if (entityCache.getResult(
						CommerceAddressModelImpl.ENTITY_CACHE_ENABLED,
						CommerceAddressImpl.class,
						commerceAddress.getPrimaryKey()) == null) {
				cacheResult(commerceAddress);
			}
			else {
				commerceAddress.resetOriginalValues();
			}
		}
	}
177880
public DistributedWorkManager resolveDistributedWorkManager(Address address)
   {
      if (trace)
      {
         log.tracef("resolveDistributedWorkManager(%s)", address);
         log.tracef("  ActiveWorkManagers: %s", activeWorkmanagers);
      }

      WorkManager wm = activeWorkmanagers.get(address.getWorkManagerId());

      if (wm != null)
      {
         if (wm instanceof DistributedWorkManager)
         {
            if (trace)
               log.tracef(" WorkManager: %s", wm);

            return (DistributedWorkManager)wm;
         }
         else
         {
            if (trace)
               log.tracef(" WorkManager not distributable: %s", wm);

            return null;
         }
      }

      try
      {
         // Create a new instance
         WorkManager template = workmanagers.get(address.getWorkManagerName());

         if (template != null)
         {
            wm = template.clone();
            wm.setId(address.getWorkManagerId());

            if (wm instanceof DistributedWorkManager)
            {
               DistributedWorkManager dwm = (DistributedWorkManager)wm;
               dwm.initialize();

               activeWorkmanagers.put(address.getWorkManagerId(), dwm);
               refCountWorkmanagers.put(address.getWorkManagerId(), Integer.valueOf(0));
               
               if (trace)
                  log.tracef("Created WorkManager: %s", dwm);
               
               return dwm;
            }
         }
      }
      catch (Throwable t)
      {
         //throw new IllegalStateException("The WorkManager couldn't be created: " + name);
      }

      return null;
   }
237426
public void localDoWork(Address address, DistributableWork work) throws WorkException
   {
      if (trace)
         log.tracef("LOCAL_DO_WORK(%s, %s)", address, work);

      DistributedWorkManager dwm = workManagerCoordinator.resolveDistributedWorkManager(address);

      dwm.localDoWork(work);
   }
174070
private void fullScanLocalDataToClear(Indexes indexes) {
        InternalIndex[] indexesSnapshot = indexes.getIndexes();
        for (Record record : storage.values()) {
            Data key = record.getKey();
            Object value = Records.getValueOrCachedValue(record, serializationService);
            indexes.removeEntry(key, value, Index.OperationSource.SYSTEM);
        }
        Indexes.markPartitionAsUnindexed(partitionId, indexesSnapshot);
    }
1292655
@Override public void setupLocal( ) {
    // Init all the internal tree fields after shipping over the wire
    _tree.init_tree();
    // Allocate local shared memory histograms
    for( int l=_leaf; l<_tree._len; l++ ) {
      DTree.UndecidedNode udn = _tree.undecided(l);
      DHistogram hs[] = _hcs[l-_leaf];
      int sCols[] = udn._scoreCols;
      if( sCols != null ) { // Sub-selecting just some columns?
        for( int col : sCols ) // For tracked cols
          hs[col].init();
      } else {                 // Else all columns
        for( int j=0; j<_ncols; j++) // For all columns
          if( hs[j] != null )        // Tracking this column?
            hs[j].init();
      }
    }
  }