Java Code Examples for java.util.concurrent.ConcurrentHashMap

public void test_concurrentMap() throws Exception {
  int featureValues=0;
  DefaultExtJSONParser parser=new DefaultExtJSONParser("{}",ParserConfig.getGlobalInstance(),featureValues);
  DefaultObjectDeserializer objectDeser=new DefaultObjectDeserializer();
  ConcurrentHashMap value=objectDeser.deserialze(parser,ConcurrentHashMap.class);
  Assert.assertEquals(0,value.size());
}
 

public ConverterGraph(ServiceReference[] converterRefs,BundleContext bContext,LogService log){
  this.bContext=bContext;
  this.log=log;
  this.converters=createConverters(converterRefs);
  inDataToConverters=new HashMap();
  outDataToConverters=new HashMap();
  dataFormats=new HashSet();
  fileExtensionTestConverters=new ConcurrentHashMap();
  fileExtensionCompareConverters=new ConcurrentHashMap();
  deriveDataFormats(this.converters,this.dataFormats);
  associateConverters(this.converters,this.inDataToConverters,this.outDataToConverters);
  createConverterPaths(this.inDataToConverters,this.fileExtensionTestConverters,this.fileExtensionCompareConverters);
}
 

/** 
 * lookup by name without type
 */
@Test public void simpleBeanLookupByNameWithoutType(){
{
    Object testBean=BeanProvider.getContextualReference("extraNameBean");
    Assert.assertNotNull(testBean);
    Assert.assertTrue(testBean instanceof TestBean);
    TestBean tb=(TestBean)testBean;
    Assert.assertEquals(4711,tb.getI());
  }
{
    Object testBean=BeanProvider.getContextualReference("extraNameBean",false);
    Assert.assertNotNull(testBean);
    Assert.assertTrue(testBean instanceof TestBean);
    TestBean tb=(TestBean)testBean;
    Assert.assertEquals(4711,tb.getI());
  }
{
    try {
      Object testBean=BeanProvider.getContextualReference("thisBeanDoesNotExist");
      Assert.fail("BeanProvider#getContextualReference should have blown up with a non-existing bean!");
    }
 catch (    IllegalStateException ise) {
    }
  }
{
    try {
      ConcurrentHashMap chm=BeanProvider.getContextualReference(ConcurrentHashMap.class);
      Assert.fail("BeanProvider#getContextualReference should have blown up with a non-existing bean!");
    }
 catch (    IllegalStateException ise) {
    }
  }
}
 

@SuppressWarnings("unchecked") private <T>void loadNonTranslatableData(final List<Class> clazzes_){
  if (_codeMap == null) {
    _codeMap=new ConcurrentHashMap();
  }
  if (_parentDependable == null) {
    _parentDependable=new ConcurrentHashMap();
  }
  for (  final Class clazz : clazzes_) {
    final Vector<T> list=new Vector<T>();
    list.addAll(dao.getAll(clazz));
    if (!list.isEmpty()) {
      final Object entity=list.get(0);
      if (entity instanceof ParentDependable) {
        final List converted=list;
        final ConcurrentMap<String,Vector<CodeValueEntity>> filtered=DomainUtil.filterDataByParent(converted);
        for (        Vector<CodeValueEntity> filteredValues : filtered.values()) {
          filteredValues=sortLoadedData(filteredValues);
        }
        _parentDependable.put(clazz.getSimpleName().toUpperCase(),filtered);
      }
      _codeMap.put(clazz.getSimpleName().toUpperCase(),sortLoadedData(DomainUtil.convertToCodeValues(list)));
    }
    _nativeObjects.put(clazz.getSimpleName().toUpperCase(),list);
  }
}
 

public static boolean monitor_nodes(EHandle caller,boolean on,int opts){
  if (on)   nodes_monitors.putIfAbsent(caller,new ConcurrentHashMap());
  ConcurrentHashMap<Integer,AtomicInteger> forHandle=nodes_monitors.get(caller);
  if (forHandle == null)   return false;
  if (on) {
    forHandle.putIfAbsent(opts,new AtomicInteger(0));
    AtomicInteger ami=forHandle.get(opts);
    if (ami == null)     return false;
    int old=ami.getAndIncrement();
    return old > 0;
  }
 else {
    AtomicInteger old=forHandle.remove(opts);
    return old != null && old.get() > 0;
  }
}
 

public FlakyHandler(int requiredRequests){
  this.requiredRequests=requiredRequests;
  madeRequests=new ConcurrentHashMap<String,Integer>();
  totalSize=1024 * 128;
  chunkSize=(requiredRequests > 1) ? totalSize / (requiredRequests - 1) - 1 : totalSize;
}
 

/** 
 * Each class has its own version of the PropertyMethodChain map.
 * @param clazz
 * @return PropertyMethodChain map for the passed class.
 */
protected ConcurrentMap<String,PropertyMethodChain> getMethodMap(Class<?> clazz){
  ConcurrentMap<String,PropertyMethodChain> propMap;
  if (!methodsMap.containsKey(clazz)) {
    propMap=new ConcurrentHashMap<String,PropertyMethodChain>();
    for (    String property : NotNullIterator.<String>newNotNullIterator(getPropertyNames())) {
      addPropertyMethodChainIfAbsent(clazz,propMap,property,false);
    }
    methodsMap.putIfAbsent(clazz,propMap);
  }
  propMap=methodsMap.get(clazz);
  return propMap;
}
 

public MultithreadedAnalyzer(Analyzer analyzer,int threads){
  if (analyzer == null) {
    throw new NullPointerException("analyzer can't be null");
  }
  if (threads < 1) {
    throw new IllegalArgumentException("thread count must be greater than or equal to 1");
  }
  this.analyzer=analyzer;
  exec=Executors.newFixedThreadPool(threads);
  results=new ConcurrentHashMap<Integer,Future<Report>>();
}
 

@Override protected <T>Map<Key<?>,Object> getScopedObjectMap(final Key<T> key){
  GitHubAccount account=currentAccount.get();
  if (account == null)   throw new OutOfScopeException("Cannot access " + key + " outside of a scoping block");
  Map<Key<?>,Object> scopeMap=repoScopeMaps.get(account);
  if (scopeMap == null) {
    scopeMap=new ConcurrentHashMap<Key<?>,Object>();
    scopeMap.put(GITHUB_ACCOUNT_KEY,account);
    repoScopeMaps.put(account,scopeMap);
  }
  return scopeMap;
}
 

/** 
 * Construct a persistent cookie store.
 */
public PersistentCookieStore(Context context){
  cookiePrefs=context.getSharedPreferences(COOKIE_PREFS,0);
  cookies=new ConcurrentHashMap<String,Cookie>();
  String storedCookieNames=cookiePrefs.getString(COOKIE_NAME_STORE,null);
  if (storedCookieNames != null) {
    String[] cookieNames=TextUtils.split(storedCookieNames,",");
    for (    String name : cookieNames) {
      String encodedCookie=cookiePrefs.getString(COOKIE_NAME_PREFIX + name,null);
      if (encodedCookie != null) {
        Cookie decodedCookie=decodeCookie(encodedCookie);
        if (decodedCookie != null) {
          cookies.put(name,decodedCookie);
        }
      }
    }
    clearExpired(new Date());
  }
}
 

/** 
 * @param on true to activate  {@link #getAPIUsageStats()}. false to switch stats off. false by default
 */
static public void setTrackAPIUsage(boolean on){
  if (!on) {
    usage=null;
    return;
  }
  if (usage != null)   return;
  usage=new ConcurrentHashMap<String,Long>();
}
 

public void hostChanged(long accountId) throws RemoteException {
  ExchangeService exchangeService=INSTANCE;
  if (exchangeService == null)   return;
  ConcurrentHashMap<Long,SyncError> syncErrorMap=exchangeService.mSyncErrorMap;
  for (  long mailboxId : syncErrorMap.keySet()) {
    SyncError error=syncErrorMap.get(mailboxId);
    Mailbox m=Mailbox.restoreMailboxWithId(exchangeService,mailboxId);
    if (m == null) {
      syncErrorMap.remove(mailboxId);
    }
 else     if (error != null && m.mAccountKey == accountId) {
      error.fatal=false;
      error.holdEndTime=0;
    }
  }
  exchangeService.stopAccountSyncs(accountId,true);
  kick("host changed");
}
 

/** 
 * Used for loading and decoding thumbnails from files.
 * @author PhilipHayes
 * @param context Current application context.
 */
public ThumbnailLoader(Context context){
  mContext=context;
  purger=new Runnable(){
    @Override public void run(){
      Log.d(TAG,"Purge Timer hit; Clearing Caches.");
      clearCaches();
    }
  }
;
  purgeHandler=new Handler();
  mExecutor=Executors.newFixedThreadPool(POOL_SIZE);
  mBlacklist=new ArrayList<String>();
  mSoftBitmapCache=new ConcurrentHashMap<String,SoftReference<Bitmap>>(MAX_CACHE_CAPACITY / 2);
  mHardBitmapCache=new LinkedHashMap<String,Bitmap>(MAX_CACHE_CAPACITY / 2,0.75f,true){
    /** 
 */
    private static final long serialVersionUID=1347795807259717646L;
    @Override protected boolean removeEldestEntry(    LinkedHashMap.Entry<String,Bitmap> eldest){
      if (size() > MAX_CACHE_CAPACITY) {
        mSoftBitmapCache.put(eldest.getKey(),new SoftReference<Bitmap>(eldest.getValue()));
        return true;
      }
 else {
        return false;
      }
    }
  }
;
}
 

public PersistentHash(String dirname) throws IOException {
  this.dirname=dirname;
  hash=new ConcurrentHashMap<String,Message>();
  File directory=new File(dirname);
  if (directory.isDirectory()) {
    refreshFromStore(this.dirname);
  }
 else {
    createEmptyStore(this.dirname);
  }
}
 

/** 
 * Create an instance with an empty map.
 */
public ConcurrentMapConfiguration(){
  map=new ConcurrentHashMap<String,Object>();
  for (int i=0; i < NUM_LOCKS; i++) {
    locks[i]=new ReentrantLock();
  }
}
 

@Inject public AgentDataCollectorManager(AgentConfig agentConfig,EventPublisher eventPublisher,ConfigInitializer initializer,DataSourceUtils dataSourceUtils){
  this.agentConfig=agentConfig;
  this.eventPublisher=eventPublisher;
  this.initializer=initializer;
  this.dataSourceUtils=dataSourceUtils;
  this.collectorMap=new ConcurrentHashMap<String,AgentDataCollector>();
  this.configMap=new ConcurrentHashMap<String,Config>();
  this.perHostSemaphoreMap=new ConcurrentHashMap<String,Semaphore>();
}
 

public JMXTestRunner(TestClassLoader classLoader){
  this.testClassLoader=classLoader;
  if (testClassLoader == null) {
    testClassLoader=new TestClassLoader(){
      public Class<?> loadTestClass(      String className) throws ClassNotFoundException {
        ClassLoader classLoader=JMXTestRunner.class.getClassLoader();
        return classLoader.loadClass(className);
      }
    }
;
  }
  events=new ConcurrentHashMap<String,Command<?>>();
  currentCall=new ThreadLocal<String>();
}
 

/** 
 * Creates a new ManagerReaderImpl.
 * @param dispatcher the dispatcher to use for dispatching events and responses.
 * @param source     the source to use when creating {@link ManagerEvent}s
 */
public ManagerReaderImpl(final Dispatcher dispatcher,Object source){
  this.dispatcher=dispatcher;
  this.source=source;
  this.eventBuilder=new EventBuilderImpl();
  this.responseBuilder=new ResponseBuilderImpl();
  this.expectedResponseClasses=new ConcurrentHashMap<String,Class<? extends ManagerResponse>>();
}
 

public AbstractEntity(IConfiguration config){
  this.configuration=config;
  this.properties=new ConcurrentHashMap<String,Object>();
  if (log.isTraceEnabled()) {
    log.trace("Entity instantiated: " + this.getNamespace());
  }
}
 

/** 
 * A reader object is created in AutobahnConnection.
 * @param calls         The call map created on master.
 * @param subs          The event subscription map created on master.
 * @param master        Message handler of master (used by us to notify the master).
 * @param socket        The TCP socket.
 * @param options       WebSockets connection options.
 * @param threadName    The thread name we announce.
 */
public WampReader(ConcurrentHashMap<String,CallMeta> calls,ConcurrentHashMap<String,SubMeta> subs,Handler master,SocketChannel socket,WebSocketOptions options,String threadName){
  super(master,socket,options,threadName);
  mCalls=calls;
  mSubs=subs;
  mJsonMapper=new ObjectMapper();
  mJsonMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,false);
  mJsonFactory=mJsonMapper.getJsonFactory();
  if (DEBUG)   Log.d(TAG,"created");
}
 

/** 
 * Gets the default value of the given field, if any.
 * @param field the field whose default value should be retrieved.
 * @return the default value associated with the given field, or null if none is specified in the schema.
 * @throws IOException 
 */
@SuppressWarnings({"rawtypes","unchecked"}) protected Object defaultValue(Field field) throws IOException {
  JsonNode defaultJsonValue=field.defaultValue();
  if (defaultJsonValue == null) {
    throw new AvroRuntimeException("Field " + field + " not set and has no default value");
  }
  if (defaultJsonValue.isNull() && (field.schema().getType() == Type.NULL || (field.schema().getType() == Type.UNION && field.schema().getTypes().get(0).getType() == Type.NULL))) {
    return null;
  }
  Object defaultValue=null;
  ConcurrentMap<Integer,Object> defaultSchemaValues=DEFAULT_VALUE_CACHE.get(schema.getFullName());
  if (defaultSchemaValues == null) {
    DEFAULT_VALUE_CACHE.putIfAbsent(schema.getFullName(),new ConcurrentHashMap<Integer,Object>(fields.length));
    defaultSchemaValues=DEFAULT_VALUE_CACHE.get(schema.getFullName());
  }
  defaultValue=defaultSchemaValues.get(field.pos());
  if (defaultValue == null) {
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    encoder=EncoderFactory.get().binaryEncoder(baos,encoder);
    ResolvingGrammarGenerator.encode(encoder,field.schema(),defaultJsonValue);
    encoder.flush();
    decoder=DecoderFactory.get().binaryDecoder(baos.toByteArray(),decoder);
    defaultValue=data.createDatumReader(field.schema()).read(null,decoder);
    defaultSchemaValues.putIfAbsent(field.pos(),defaultValue);
  }
  return data.deepCopy(field.schema(),defaultValue);
}
 

@SuppressWarnings("unchecked") public JobExecutorManager(FlowManager allKnownFlows,JobManager jobManager,Mailman mailman,String jobSuccessEmail,String jobFailureEmail,int maxThreads){
  this.jobManager=jobManager;
  this.mailman=mailman;
  this.jobSuccessEmail=jobSuccessEmail;
  this.jobFailureEmail=jobFailureEmail;
  this.allKnownFlows=allKnownFlows;
  Multimap<String,JobExecution> typedMultiMap=HashMultimap.create();
  this.completed=Multimaps.synchronizedMultimap(typedMultiMap);
  this.executing=new ConcurrentHashMap<String,ExecutingJobAndInstance>();
  this.executor=new ThreadPoolExecutor(0,maxThreads,10,TimeUnit.SECONDS,new LinkedBlockingQueue(),new ExecutorThreadFactory());
}
 

private void configureMetrics(){
  requests=Metrics.newMeter(new MetricName(DEFAULT_GROUP,DEFAULT_TYPE,this.id + ".requests"),"requests",TimeUnit.SECONDS);
  throughput=Metrics.newMeter(new MetricName(DEFAULT_GROUP,DEFAULT_TYPE,this.id + ".throughput"),"bytes",TimeUnit.SECONDS);
  methods=new ConcurrentHashMap<String,Meter>();
  responseCodeCounts=new ConcurrentHashMap<Integer,Counter>();
}
 

public static Class getMap(Class type){
  if (ReflectionUtils.hasDefaultConstructor(type)) {
    return type;
  }
 else   if (SortedMap.class.isAssignableFrom(type)) {
    return TreeMap.class;
  }
 else   if (ConcurrentMap.class.isAssignableFrom(type)) {
    return ConcurrentHashMap.class;
  }
 else {
    return LinkedHashMap.class;
  }
}
 

private static Object getMTO(Method method,ManyToOne mto,Object entity,EntityManagerProvider provider) throws Throwable {
  Object rel=method.invoke(entity);
  if (rel == null) {
    Class<?> ec=entity.getClass();
    String methodName=method.getName();
    Class<?> entityClass=method.getReturnType();
    Map<Class<?>,Method> map=getIdMapping.get(ec);
    if (map == null) {
      map=new ConcurrentHashMap<Class<?>,Method>();
      getIdMapping.put(ec,map);
    }
    Method idMethod=map.get(entityClass);
    if (idMethod == null) {
      String idName=mto.id();
      if (idName == null || idName.length() == 0) {
        idName=methodName + "Id";
      }
      idMethod=ec.getMethod(idName);
      map.put(entityClass,idMethod);
    }
    Object id=idMethod.invoke(entity);
    if (id == null) {
      return null;
    }
    EntityManager em=provider.getEntityManager();
    try {
      rel=em.find(entityClass,id);
    }
  finally {
      provider.close(em);
    }
    Method setter=ec.getMethod("s" + methodName.substring(1),entityClass);
    setter.invoke(entity,rel);
  }
  return rel;
}
 

public void init(){
  LOG.debug("init entry");
  if (initComplete) {
    LOG.debug("init exit; was already initialized");
    return;
  }
  permissionMap=new ConcurrentHashMap<String,Map>();
  ancestorMap=new ConcurrentHashMap<String,List<PID>>();
  if (tripleStoreQueryService == null) {
    LOG.error("tripleStoreQueryService is NULL");
  }
  collectionsPid=tripleStoreQueryService.fetchByRepositoryPath("/Collections");
  initComplete=true;
  LOG.debug("init exit");
}
 

private void load(){
  final ConcurrentHashMap<Long,RegisteredService> localServices=new ConcurrentHashMap<Long,RegisteredService>();
  for (  final RegisteredService r : this.serviceRegistryDao.load()) {
    log.debug("Adding registered service " + r.getServiceId());
    localServices.put(r.getId(),r);
  }
  this.services=localServices;
  log.info(String.format("Loaded %s services.",this.services.size()));
}
 

@SuppressWarnings("unchecked") private Map<Contextual<?>,Object> getComponentInstanceMap(){
  Map<String,Object> viewMap=getViewMap();
  Map<Contextual<?>,Object> map=(ConcurrentHashMap<Contextual<?>,Object>)viewMap.get(COMPONENT_MAP_NAME);
  if (map == null) {
    map=new ConcurrentHashMap<Contextual<?>,Object>();
    viewMap.put(COMPONENT_MAP_NAME,map);
  }
  return map;
}
 

@Override public Iterable<? extends Node> getChildren(){
  if (!children.containsKey(NODE_MARKER)) {
    children.put(NODE_MARKER,new MarkerNode());
    ConcurrentMap<String,OpenNode> tmp=new ConcurrentHashMap<String,OpenNode>();
    for (    OpenNode on : findService(StructureBuilder.class).find(this))     put(tmp,on.getLabel(),on);
    children.putAll(tmp);
    return tmp.values();
  }
 else {
    List<Node> nodes=new ArrayList<Node>();
    for (    Node on : children.values()) {
      if (on instanceof MarkerNode == false)       nodes.add(on);
    }
    return nodes;
  }
}
 

Node<T> addChild(String token,T value){
  if (children == null)   children=new ConcurrentHashMap<String,Node<T>>();
  Node<T> child=children.get(token);
  if (child == null) {
    child=new Node<T>(value);
    child.name=token;
    child.parent=this;
    children.put(token,child);
  }
  return child;
}
 

private Map<Check,Stockable> getStockables(int UID){
  Map<Check,Stockable> stockables=new ConcurrentHashMap<Check,Stockable>();
  int i=0;
  label:   for (  String s : profiles.getString(UID + stock).split(";")) {
    if (s.isEmpty()) {
      continue;
    }
    i=0;
    ItemStack stack=new ItemStack(37);
    ItemPrice price=new ItemPrice(0);
    boolean selling=false;
    for (    String main : s.split(",")) {
switch (i) {
case 0:
        String[] split=main.split("/");
      stack=new ItemStack(Integer.parseInt(split[0]),Integer.parseInt(split[1]),Short.parseShort(split[2]));
    break;
case 1:
  String[] parts=main.split("/");
if (parts.length == 1 || parts.length == 2) {
  price=new ItemPrice(Double.parseDouble(parts[0]));
}
 else {
  continue label;
}
break;
case 2:
selling=Boolean.parseBoolean(main);
break;
}
i+=1;
}
Stockable stock=new Stockable(stack,price,selling);
stockables.put(stock.createCheck(),stock);
}
return stockables;
}
 

static public <K,V>void clearCache(ReferenceQueue rq,ConcurrentHashMap<K,Reference<V>> cache){
  if (rq.poll() != null) {
    while (rq.poll() != null)     ;
    for (    Map.Entry<K,Reference<V>> e : cache.entrySet()) {
      Reference<V> val=e.getValue();
      if (val != null && val.get() == null)       cache.remove(e.getKey(),val);
    }
  }
}
 

public static Map<String,Integer> getDeltas(String archiveFile,Map<String,Long> oldCheckSums) throws IOException {
  Map<String,Integer> deltas=new HashMap<String,Integer>();
  Map<String,Long> newCheckSums=getCheckSums(archiveFile);
  ConcurrentHashMap<String,Long> checkSumsTmp=new ConcurrentHashMap<String,Long>(oldCheckSums);
  for (  Map.Entry<String,Long> entry : newCheckSums.entrySet()) {
    String key=entry.getKey();
    if (checkSumsTmp.get(key) == null) {
      deltas.put(key,ENTRY_ADDED);
    }
 else     if (entry.getValue().longValue() != checkSumsTmp.get(key).longValue()) {
      deltas.put(key,ENTRY_UPDATED);
      checkSumsTmp.remove(key);
    }
 else {
      checkSumsTmp.remove(key);
    }
  }
  for (  String key : checkSumsTmp.keySet()) {
    deltas.put(key,ENTRY_DELETED);
  }
  return deltas;
}
 

/** 
 * Creates a new window with the specified max window size.  This constructor enables automatic recurring tasks to be executed (such as expiration of requests).
 * @param size The maximum number of requests permitted tobe outstanding (unacknowledged) at a given time.  Must be > 0.
 * @param executor The scheduled executor service to executerecurring tasks (such as expiration of requests).
 * @param monitorInterval The number of milliseconds between executions ofmonitoring tasks.
 * @param listener A listener to send window events to
 * @param monitorThreadName The thread name we'll change to when a monitorrun is executed.  Null if no name change is required.
 */
public Window(int size,ScheduledExecutorService executor,long monitorInterval,WindowListener<K,R,P> listener,String monitorThreadName){
  if (size <= 0) {
    throw new IllegalArgumentException("size must be > 0");
  }
  this.maxSize=size;
  this.futures=new ConcurrentHashMap<K,DefaultWindowFuture<K,R,P>>(size * 2);
  this.lock=new ReentrantLock();
  this.completedCondition=this.lock.newCondition();
  this.pendingOffers=new AtomicInteger(0);
  this.pendingOffersAborted=new AtomicBoolean(false);
  this.executor=executor;
  this.monitorInterval=monitorInterval;
  this.listeners=new CopyOnWriteArrayList<UnwrappedWeakReference<WindowListener<K,R,P>>>();
  if (listener != null) {
    this.listeners.add(new UnwrappedWeakReference<WindowListener<K,R,P>>(listener));
  }
  if (this.executor != null) {
    this.monitor=new WindowMonitor(this,monitorThreadName);
    this.monitorHandle=this.executor.scheduleWithFixedDelay(this.monitor,this.monitorInterval,this.monitorInterval,TimeUnit.MILLISECONDS);
  }
 else {
    this.monitor=null;
    this.monitorHandle=null;
  }
}
 

public WorkEntry(Paul services,FileWatcherEvent event,File baseFile){
  this.facility=(Facility)event.getFacility();
  this.timestamp=new Date(event.getTimestamp());
  this.statusManager=services.getFacilityStatusManager();
  this.fileGrabber=statusManager.getStatus(facility).getFileGrabber();
  this.queueManager=services.getQueueManager();
  this.fileManager=queueManager.getFileManager();
  this.baseFile=baseFile;
  this.instrumentBasePath=mapToInstrumentPath(facility,baseFile);
  this.files=new ConcurrentHashMap<File,GrabbedFile>();
  this.holdDatasetsWithNoUser=services.getConfiguration().isHoldDatasetsWithNoUser();
  long timeout=services.getConfiguration().getGrabberTimeout();
  this.grabberTimeout=timeout == 0 ? DEFAULT_GRABBER_TIMEOUT : timeout;
  this.catchup=event.isCatchup();
  settling=facility.getFileSettlingTime();
  if (settling <= 0) {
    settling=FileGrabber.DEFAULT_FILE_SETTLING_TIME;
  }
  addEvent(event);
}
 

@SuppressWarnings("unchecked") protected Map<String,CMISHost> readPreferences(Context ctx){
  ConcurrentHashMap<String,CMISHost> prefs=new ConcurrentHashMap<String,CMISHost>();
  SharedPreferences sharedPrefs=PreferenceManager.getDefaultSharedPreferences(ctx);
  String encPrefs=null;
  if (sharedPrefs.contains(SERVERS_KEY)) {
    encPrefs=sharedPrefs.getString(SERVERS_KEY,null);
    if (encPrefs != null) {
      byte[] repr=Base64.decodeBase64(encPrefs.getBytes());
      Object obj=SerializationUtils.deserialize(repr);
      if (obj != null) {
        prefs=(ConcurrentHashMap<String,CMISHost>)obj;
      }
    }
  }
  return prefs;
}
 

private CCScheduler(){
  timeScale_=1.0f;
  updateSelector="update";
  updates0=new ArrayList<tListEntry>();
  updatesNeg=new ArrayList<tListEntry>();
  updatesPos=new ArrayList<tListEntry>();
  hashForUpdates=new ConcurrentHashMap<Object,tHashSelectorEntry>();
  hashForSelectors=new ConcurrentArrayHashMap<Object,tHashSelectorEntry>();
  currentTarget=null;
  currentTargetSalvaged=false;
}
 

/** 
 * Retrieves a matcher from the RegExp local cache.
 * @param expression
 * @param string
 * @return
 */
public static Matcher getMatcher(String expression,String string){
  if (patternCache == null)   patternCache=new ConcurrentHashMap<String,Pattern>();
  Pattern pattern=patternCache.get(expression);
  if (pattern == null) {
    pattern=Pattern.compile(expression);
    patternCache.put(expression,pattern);
  }
  return pattern.matcher(string);
}
 

@Listener("/service/members") public void handleMembership(ServerSession client,ServerMessage message){
  Map<String,Object> data=message.getDataAsMap();
  final String room=((String)data.get("room")).substring("/chat/".length());
  Map<String,String> roomMembers=_members.get(room);
  if (roomMembers == null) {
    Map<String,String> new_room=new ConcurrentHashMap<String,String>();
    roomMembers=_members.putIfAbsent(room,new_room);
    if (roomMembers == null)     roomMembers=new_room;
  }
  final Map<String,String> members=roomMembers;
  String userName=(String)data.get("user");
  members.put(userName,client.getId());
  client.addListener(new ServerSession.RemoveListener(){
    public void removed(    ServerSession session,    boolean timeout){
      members.values().remove(session.getId());
      broadcastMembers(room,members.keySet());
    }
  }
);
  broadcastMembers(room,members.keySet());
}
 

public ManifestBuilder addEntryAttributes(@Nonnull String entryName,@Nonnull Map<String,String> attributes){
  Collection<String> attributeErrors=getAttributeErrors(attributes);
  if (!attributeErrors.isEmpty()) {
    throw new IllegalArgumentException(attributeErrors.toString());
  }
  entryAttributes.putIfAbsent(entryName,new ConcurrentHashMap<String,String>(checkNotNull(attributes).size()));
  entryAttributes.get(entryName).putAll(attributes);
  return this;
}
 

@SuppressWarnings("unchecked") private Map<Contextual<?>,Object> getComponentInstanceMap(){
  ConcurrentHashMap<Contextual<?>,Object> map=(ConcurrentHashMap<Contextual<?>,Object>)getCurrentProject().getAttribute(COMPONENT_MAP_NAME);
  if (map == null) {
    map=new ConcurrentHashMap<Contextual<?>,Object>();
    getCurrentProject().setAttribute(COMPONENT_MAP_NAME,map);
  }
  return map;
}
 

public static boolean startDB(String folder,Map<String,String> config){
  if (graphDb != null) {
    return false;
  }
  System.gc();
  activeTx=Collections.synchronizedList(new LinkedList<Transaction>());
  debugActiveTx=new ConcurrentHashMap<Transaction,Throwable>();
  STORAGE=folder;
  Executor.init();
  graphDb=new EmbeddedGraphDatabase(STORAGE,config);
  BIN=new File(STORAGE,BIN_STORAGE);
  BIN.mkdir();
  TMP=new File(STORAGE,TMP_STORAGE);
  TMP.mkdir();
  initDB();
  Runtime.getRuntime().addShutdownHook(new Thread(){
    public void run(){
      shutdownDB();
    }
  }
);
  return true;
}
 

public void init(){
  cache=new ConcurrentHashMap<String,CacheEntry>(this.getStartCapacity());
  if (selfClean) {
    Runnable r=new Runnable(){
      public void run(){
        while (!Thread.interrupted()) {
          int cleanCount=ConMapPersister.this.cleanOutGarbage();
          Logger.getLogger(loggerName).info("Cleaned out " + cleanCount + " entries; Persister has "+ cache.size()+ " entries");
          try {
            Thread.sleep(cleanWaitTime * 1000);
          }
 catch (          InterruptedException ie) {
            Thread.currentThread().interrupt();
          }
        }
      }
    }
;
    Thread t=new Thread(r);
    t.start();
    t.setPriority(Thread.MIN_PRIORITY);
  }
}
 

public Long getProjectKey(String projectId) throws IOException, CovRemoteServiceException_Exception {
  if (projectKeys == null) {
    projectKeys=new ConcurrentHashMap<String,Long>();
  }
  Long result=projectKeys.get(projectId);
  if (result == null) {
    result=getProject(projectId).getProjectKey();
    projectKeys.put(projectId,result);
  }
  return result;
}
 

private static Field getField(Class c,String name){
  Map<String,Field> fields=FIELD_CACHE.get(c);
  if (fields == null) {
    fields=new ConcurrentHashMap<String,Field>();
    FIELD_CACHE.put(c,fields);
  }
  Field f=fields.get(name);
  if (f == null) {
    f=findField(c,name);
    fields.put(name,f);
  }
  return f;
}
 

public MockTangoConnection(String hardwareURI,String attributeName){
  super(hardwareURI,attributeName);
  if (commandMap == null)   createCommandMap();
  this.hardwareName=hardwareURI.substring(hardwareURI.lastIndexOf("/") + 1);
  if (attributeName != null) {
    if (mockListeners == null)     mockListeners=new ConcurrentHashMap<String,AbstractTangoConnection>();
    mockListeners.put(getHardwareName(),this);
    if (mockValues.get(getHardwareName()) == null) {
      mockValues.put(getHardwareName(),0d);
    }
  }
}
 

public void setRecordPorts(boolean recordPorts){
  this.recordPorts=recordPorts;
  if (recordPorts) {
    portRecord=new ConcurrentHashMap<Integer,Object>(7);
  }
 else {
    portRecord=null;
  }
}
 

public void stop(){
  try {
    if (mpClusterSession != null)     mpClusterSession.stop();
  }
 catch (  Throwable th) {
    logger.error("Stopping the cluster session " + SafeString.objectDescription(mpClusterSession) + " caused an exception:",th);
  }
  ConcurrentHashMap<Class<?>,Set<ClusterRouter>> map=routerMap;
  routerMap=null;
  Set<ClusterRouter> routers=new HashSet<ClusterRouter>();
  for (  Collection<ClusterRouter> curRouters : map.values())   routers.addAll(curRouters);
  for (  ClusterRouter router : routers)   router.stop();
  for (  RoutingStrategy.Outbound ob : outbounds)   ob.stop();
}
 

@Test public void cloneTest() throws CloneNotSupportedException {
  WordRankMP clone=mp.clone();
  Assert.assertNotNull(clone);
  Assert.assertNotSame(mp,clone);
  clone.map=new ConcurrentHashMap<Word,WordCount>();
  Assert.assertNull(mp.map);
  Assert.assertNotNull(clone.map);
}
 

/** 
 * Create an instance of JmDNS and bind it to a specific network interface given its IP-address.
 * @param address IP address to bind to.
 * @param name name of the newly created JmDNS
 * @exception IOException
 */
public JmDNSImpl(InetAddress address,String name) throws IOException {
  super();
  if (logger.isLoggable(Level.FINER)) {
    logger.finer("JmDNS instance created");
  }
  _cache=new DNSCache(100);
  _listeners=Collections.synchronizedList(new ArrayList<DNSListener>());
  _serviceListeners=new ConcurrentHashMap<String,List<ServiceListenerStatus>>();
  _typeListeners=Collections.synchronizedSet(new HashSet<ServiceTypeListenerStatus>());
  _serviceCollectors=new ConcurrentHashMap<String,ServiceCollector>();
  _services=new ConcurrentHashMap<String,ServiceInfo>(20);
  _serviceTypes=new ConcurrentHashMap<String,ServiceTypeEntry>(20);
  _localHost=HostInfo.newHostInfo(address,this,name);
  _name=(name != null ? name : _localHost.getName());
  this.openMulticastSocket(this.getLocalHost());
  this.start(this.getServices().values());
  this.startReaper();
}
 

@PostConstruct public void init(){
  if (url == null) {
    throw new IllegalStateException("Parameter 'url' is required");
  }
  if (searchBase == null) {
    throw new IllegalStateException("Parameter 'searchBase' is required");
  }
  cache=new ConcurrentHashMap<String,Object>();
  attributeMap.put(uidAttribute,null);
  if (memberOfAttribute != null) {
    attributeMap.put(memberOfAttribute,null);
  }
  userReturnedAttributes=attributeMap.keySet().toArray(new String[attributeMap.size()]);
  ouMap=new HashMap<Pattern,String>();
  env=new Hashtable<String,String>();
  env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.ldap.LdapCtxFactory");
  env.put(Context.PROVIDER_URL,url);
  env.put(Context.SECURITY_AUTHENTICATION,"simple");
  if (principal != null) {
    env.put(Context.SECURITY_PRINCIPAL,principal);
    env.put(Context.SECURITY_CREDENTIALS,credentials);
  }
  if (log.isInfoEnabled()) {
    log.info("Initialized");
  }
}
 

private void initCounters(){
  if (this.counters != null) {
    return;
  }
  CounterGroupProtoOrBuilder p=viaProto ? proto : builder;
  List<StringCounterMapProto> list=p.getCountersList();
  this.counters=new ConcurrentHashMap<String,Counter>();
  for (  StringCounterMapProto c : list) {
    this.counters.put(c.getKey(),convertFromProtoFormat(c.getValue()));
  }
}
 

public GridImpl(Map<String,Object> services){
  if (services == null) {
    this.services=new ConcurrentHashMap<String,Object>();
  }
 else {
    this.services=services;
  }
  this.id=UUID.randomUUID().toString();
  init();
}
 

@SuppressWarnings("unchecked") private L1World(){
  _allPlayers=new ConcurrentHashMap<String,L1PcInstance>();
  _allPets=new ConcurrentHashMap<Integer,L1PetInstance>();
  _allSummons=new ConcurrentHashMap<Integer,L1SummonInstance>();
  _allObjects=new ConcurrentHashMap<Integer,L1Object>();
  _visibleObjects=new ConcurrentHashMap[MAX_MAP_ID + 1];
  _allWars=new CopyOnWriteArrayList<L1War>();
  _allClans=new ConcurrentHashMap<String,L1Clan>();
  for (int i=0; i <= MAX_MAP_ID; i++) {
    _visibleObjects[i]=new ConcurrentHashMap<Integer,L1Object>();
  }
}
 

private static Map<RecordType,ConcurrentMap<Long,DynamicOwner>> initialize(DynamicStore[] stores){
  EnumMap<RecordType,ConcurrentMap<Long,DynamicOwner>> map=new EnumMap<RecordType,ConcurrentMap<Long,DynamicOwner>>(RecordType.class);
  for (  DynamicStore store : stores) {
    map.put(store.type,new ConcurrentHashMap<Long,DynamicOwner>(16,0.75f,4));
  }
  return unmodifiableMap(map);
}
 

public CaseInsensitiveMap(Map m){
  map=new ConcurrentHashMap<String,String>();
  Iterator iterator=m.keySet().iterator();
  while (iterator.hasNext()) {
    Object key=iterator.next();
    map.put(key.toString().toLowerCase(),(String)m.get(key));
  }
}
 

/** 
 * Copy everything from the given provider.
 * @param other - the given provider.
 */
public ServiceProvider(ServiceProvider<TService> other){
  this.defaultName=other.defaultName;
  this.nameLookup=new ConcurrentHashMap<String,TService>(other.nameLookup);
  this.disabledLookup=Sets.newSetFromMap(new ConcurrentHashMap<String,Boolean>());
  for (  String disabled : other.disabledLookup) {
    this.disabledLookup.add(disabled);
  }
}
 

private Map<String,Portlet> _getPortletsPool(long companyId) throws SystemException {
  String key=_encodeKey(companyId);
  Map<String,Portlet> portletsPool=(Map<String,Portlet>)_companyPortletsPool.get(key);
  if (portletsPool == null) {
    portletsPool=new ConcurrentHashMap<String,Portlet>();
    Map<String,Portlet> parentPortletsPool=_getPortletsPool();
    if (parentPortletsPool == null) {
      return portletsPool;
    }
    for (    Portlet portlet : parentPortletsPool.values()) {
      portlet=(Portlet)portlet.clone();
      portlet.setCompanyId(companyId);
      portletsPool.put(portlet.getPortletId(),portlet);
    }
    List<Portlet> portlets=portletPersistence.findByCompanyId(companyId);
    for (    Portlet portlet : portlets) {
      Portlet portletModel=portletsPool.get(portlet.getPortletId());
      if (portletModel != null) {
        portletModel.setPluginPackage(portlet.getPluginPackage());
        portletModel.setDefaultPluginSetting(portlet.getDefaultPluginSetting());
        portletModel.setRoles(portlet.getRoles());
        portletModel.setActive(portlet.getActive());
      }
    }
    _companyPortletsPool.put(key,portletsPool);
  }
  return portletsPool;
}
 

@SuppressWarnings("unchecked") private Map<Contextual<?>,Object> getComponentInstanceMap(){
  ConcurrentHashMap<Contextual<?>,Object> map=(ConcurrentHashMap<Contextual<?>,Object>)getCurrentRenderContext().get(COMPONENT_MAP_NAME);
  if (map == null) {
    map=new ConcurrentHashMap<Contextual<?>,Object>();
    getCurrentRenderContext().put(COMPONENT_MAP_NAME,map);
  }
  return map;
}
 

/** 
 * A reader object is created in AutobahnConnection.
 * @param calls         The call map created on master.
 * @param subs          The event subscription map created on master.
 * @param master        Message handler of master (used by us to notify the master).
 * @param socket        The TCP socket.
 * @param options       WebSockets connection options.
 * @param threadName    The thread name we announce.
 */
public WampReader(ConcurrentHashMap<String,CallMeta> calls,ConcurrentHashMap<String,SubMeta> subs,Handler master,SocketChannel socket,WebSocketOptions options,String threadName){
  super(master,socket,options,threadName);
  mCalls=calls;
  mSubs=subs;
  mJsonMapper=new ObjectMapper();
  mJsonMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,false);
  mJsonFactory=mJsonMapper.getJsonFactory();
  if (DEBUG)   Log.d(TAG,"created");
}
 

/** 
 * Used for loading and decoding thumbnails from files.
 * @author PhilipHayes
 * @param context Current application context.
 */
public ThumbnailLoader(Context context){
  mContext=context;
  purger=new Runnable(){
    @Override public void run(){
      Log.d(TAG,"Purge Timer hit; Clearing Caches.");
      clearCaches();
    }
  }
;
  purgeHandler=new Handler();
  mExecutor=Executors.newFixedThreadPool(POOL_SIZE);
  mBlacklist=new ArrayList<String>();
  mSoftBitmapCache=new ConcurrentHashMap<String,SoftReference<Bitmap>>(MAX_CACHE_CAPACITY / 2);
  mHardBitmapCache=new LinkedHashMap<String,Bitmap>(MAX_CACHE_CAPACITY / 2,0.75f,true){
    /** 
 */
    private static final long serialVersionUID=1347795807259717646L;
    @Override protected boolean removeEldestEntry(    LinkedHashMap.Entry<String,Bitmap> eldest){
      if (size() > MAX_CACHE_CAPACITY) {
        mSoftBitmapCache.put(eldest.getKey(),new SoftReference<Bitmap>(eldest.getValue()));
        return true;
      }
 else {
        return false;
      }
    }
  }
;
}
 

protected Map<Object,Object> eSort(List<?> list,int col){
  TypeAdapter a=columnBindings[col].adapter;
  Map<Object,Object> result=new ConcurrentHashMap<Object,Object>(list.size());
  for (Iterator<?> i=list.iterator(); i.hasNext(); ) {
    Parse row=(Parse)i.next();
    Parse cell=row.parts.at(col);
    try {
      Object key=a.parse(cell.text());
      bin(result,key,row);
    }
 catch (    Exception e) {
      exception(cell,e);
      for (Parse rest=cell.more; rest != null; rest=rest.more) {
        ignore(rest);
      }
    }
  }
  return result;
}
 

/** 
 * Initialize internal data structures
 */
public void init(Map<String,String> configParams){
  this.messageListeners=new ConcurrentHashMap<OFType,ListenerDispatcher<OFType,IOFMessageListener>>();
  this.switchListeners=new CopyOnWriteArraySet<IOFSwitchListener>();
  this.haListeners=new CopyOnWriteArraySet<IHAListener>();
  this.activeSwitches=new ConcurrentHashMap<Long,IOFSwitch>();
  this.connectedSwitches=new HashSet<OFSwitchImpl>();
  this.controllerNodeIPsCache=new HashMap<String,String>();
  this.updates=new LinkedBlockingQueue<IUpdate>();
  this.factory=new BasicFactory();
  this.providerMap=new HashMap<String,List<IInfoProvider>>();
  setConfigParams(configParams);
  this.role=getInitialRole(configParams);
  this.roleChanger=new RoleChanger();
  initVendorMessages();
  this.systemStartTime=System.currentTimeMillis();
}
 

/** 
 * Test the reassembly of a single line across multiple packets.
 */
@Test public void testFragmented() throws CharacterCodingException {
  final int maxLen=100;
  IoBuffer savedBuf=IoBuffer.allocate(maxLen);
  String origMsg="<1>- - blah blam foo\n";
  IoBuffer buf1=IoBuffer.wrap(origMsg.substring(0,11).getBytes(Charsets.UTF_8));
  IoBuffer buf2=IoBuffer.wrap(origMsg.substring(11,16).getBytes(Charsets.UTF_8));
  IoBuffer buf3=IoBuffer.wrap(origMsg.substring(16,21).getBytes(Charsets.UTF_8));
  LineSplitter lineSplitter=new LineSplitter(maxLen);
  ParsedBuffer parsedLine=new ParsedBuffer();
  Assert.assertFalse("Incomplete line should not be parsed",lineSplitter.parseLine(buf1,savedBuf,parsedLine));
  Assert.assertFalse("Incomplete line should not be parsed",lineSplitter.parseLine(buf2,savedBuf,parsedLine));
  Assert.assertTrue("Completed line should be parsed",lineSplitter.parseLine(buf3,savedBuf,parsedLine));
  Assert.assertEquals(origMsg.trim(),parsedLine.buffer.getString(Charsets.UTF_8.newDecoder()));
  parsedLine.buffer.rewind();
  MultiportSyslogTCPSource.MultiportSyslogHandler handler=new MultiportSyslogTCPSource.MultiportSyslogHandler(maxLen,100,null,null,SyslogSourceConfigurationConstants.DEFAULT_PORT_HEADER,new ThreadSafeDecoder(Charsets.UTF_8),new ConcurrentHashMap<Integer,ThreadSafeDecoder>());
  Event event=handler.parseEvent(parsedLine,Charsets.UTF_8.newDecoder());
  String body=new String(event.getBody(),Charsets.UTF_8);
  Assert.assertEquals("Event body incorrect",origMsg.trim().substring(7),body);
}
 

/** 
 * Must be synchronized to isolate watcher
 */
@Override synchronized public void open() throws IOException {
  Preconditions.checkState(watcher == null,"Attempting to open an already open TailDirSource (" + dir + ", \""+ regex+ "\")");
  subdirWatcherMap=new ConcurrentHashMap<String,DirWatcher>();
  watcher=createWatcher(dir,regex,recurseDepth);
  dirChecked=true;
  watcher.start();
  tail.open();
}
 

public void init(){
  cache=new ConcurrentHashMap<String,CacheEntry>(this.getStartCapacity());
  if (selfClean) {
    Runnable r=new Runnable(){
      public void run(){
        while (!Thread.interrupted()) {
          int cleanCount=ConMapPersister.this.cleanOutGarbage();
          Logger.getLogger(loggerName).info("Cleaned out " + cleanCount + " entries; Persister has "+ cache.size()+ " entries");
          try {
            Thread.sleep(cleanWaitTime * 1000);
          }
 catch (          InterruptedException ie) {
            Thread.currentThread().interrupt();
          }
        }
      }
    }
;
    Thread t=new Thread(r);
    t.start();
    t.setPriority(Thread.MIN_PRIORITY);
  }
}
 

/** 
 * @param delegate the delegate when the cache value has not been found
 * @throws IllegalArgumentException if the delegate object provided is null
 */
public CachingLocaleFormat(LocaleFormat delegate) throws IllegalArgumentException {
  if (delegate == null) {
    throw new IllegalArgumentException("No null delegate is possible");
  }
  this.delegate=delegate;
  this.localeCache=new ConcurrentHashMap<String,Locale>();
  this.stringCache=new ConcurrentHashMap<Locale,String>();
}
 

ConcurrentMap<Integer,Statistic> buildMap(){
  ConcurrentMap<Integer,Statistic> map=new ConcurrentHashMap<Integer,Statistic>();
  for (int i=0; i < pkgs.length; i++) {
    map.put(i,new Statistic());
  }
  map.put(-1,new Statistic());
  return map;
}
 

/** 
 * You can add a field associated with a bean (even if it is viewing a property and not actually  editing one). All editing fields are added through reflection with setBeanFields(...) however some are not fields and still can be listened to.
 * @param beanClazz
 * @param fieldName
 * @param box
 */
public static void addBeanField(Class<? extends Object> beanClazz,String fieldName,final IFieldWidget box){
  fieldName=fieldName.substring(0,1).toLowerCase(Locale.US) + fieldName.substring(1);
  if (cachedWidgets == null)   cachedWidgets=new ConcurrentHashMap<String,IFieldWidget>(89);
  final String id=beanClazz.getName() + ":" + fieldName;
  cachedWidgets.put(id,box);
  if (waitingListeners != null) {
    final Collection<ValueListener> listeners=waitingListeners.get(id);
    if (listeners != null) {
      for (      ValueListener valueListener : listeners)       box.addValueListener(valueListener);
      waitingListeners.remove(id);
    }
  }
}
 

private String getId(final String name,final String idPrefix){
  ConcurrentHashMap<String,AtomicLong> subMap=this.idMap.get(name);
  if (null == subMap) {
    this.lock.lock();
    try {
      subMap=this.idMap.get(name);
      if (null == subMap) {
        subMap=new ConcurrentHashMap<String,AtomicLong>();
        this.idMap.put(name,subMap);
      }
    }
  finally {
      this.lock.unlock();
    }
  }
  AtomicLong indexValue=subMap.get(idPrefix);
  if (null == indexValue) {
    this.lock.lock();
    try {
      indexValue=subMap.get(idPrefix);
      if (null == indexValue) {
        indexValue=new AtomicLong(0);
        subMap.put(idPrefix,indexValue);
      }
    }
  finally {
      this.lock.unlock();
    }
  }
  final long value=indexValue.incrementAndGet();
  final String result=idPrefix + "-" + value;
  return result;
}
 

public void registerCustomEditors(PropertyEditorRegistry registry){
  registry.registerCustomEditor(Date.class,new DateEditor());
  registry.registerCustomEditor(Stack.class,new BlueprintCustomCollectionEditor(Stack.class));
  registry.registerCustomEditor(Vector.class,new BlueprintCustomCollectionEditor(Vector.class));
  registry.registerCustomEditor(Collection.class,new BlueprintCustomCollectionEditor(Collection.class));
  registry.registerCustomEditor(Set.class,new BlueprintCustomCollectionEditor(Set.class));
  registry.registerCustomEditor(SortedSet.class,new BlueprintCustomCollectionEditor(SortedSet.class));
  registry.registerCustomEditor(List.class,new BlueprintCustomCollectionEditor(List.class));
  registry.registerCustomEditor(SortedMap.class,new CustomMapEditor(SortedMap.class));
  registry.registerCustomEditor(HashSet.class,new BlueprintCustomCollectionEditor(HashSet.class));
  registry.registerCustomEditor(LinkedHashSet.class,new BlueprintCustomCollectionEditor(LinkedHashSet.class));
  registry.registerCustomEditor(TreeSet.class,new BlueprintCustomCollectionEditor(TreeSet.class));
  registry.registerCustomEditor(ArrayList.class,new BlueprintCustomCollectionEditor(ArrayList.class));
  registry.registerCustomEditor(LinkedList.class,new BlueprintCustomCollectionEditor(LinkedList.class));
  registry.registerCustomEditor(HashMap.class,new CustomMapEditor(HashMap.class));
  registry.registerCustomEditor(LinkedHashMap.class,new CustomMapEditor(LinkedHashMap.class));
  registry.registerCustomEditor(Hashtable.class,new CustomMapEditor(Hashtable.class));
  registry.registerCustomEditor(TreeMap.class,new CustomMapEditor(TreeMap.class));
  registry.registerCustomEditor(Properties.class,new PropertiesEditor());
  registry.registerCustomEditor(ConcurrentMap.class,new CustomMapEditor(ConcurrentHashMap.class));
  registry.registerCustomEditor(ConcurrentHashMap.class,new CustomMapEditor(ConcurrentHashMap.class));
  registry.registerCustomEditor(Queue.class,new BlueprintCustomCollectionEditor(LinkedList.class));
  registry.registerCustomEditor(Dictionary.class,new CustomMapEditor(Hashtable.class));
}
 

public MapRecipe(Map<?,?> map){
  if (map == null)   throw new NullPointerException("map is null");
  entries=new ArrayList<Object[]>(map.size());
  if (RecipeHelper.hasDefaultConstructor(map.getClass())) {
    this.typeClass=map.getClass();
  }
 else   if (map instanceof SortedMap) {
    this.typeClass=TreeMap.class;
  }
 else   if (map instanceof ConcurrentMap) {
    this.typeClass=ConcurrentHashMap.class;
  }
 else {
    this.typeClass=LinkedHashMap.class;
  }
  putAll(map);
}
 

@Override public void doRequest(ServerData<I,V,E,M> serverData){
  ConcurrentHashMap<I,VertexMutations<I,V,E,M>> vertexMutations=serverData.getVertexMutations();
  for (  Entry<I,VertexMutations<I,V,E,M>> entry : vertexIdMutations.entrySet()) {
    VertexMutations<I,V,E,M> mutations=vertexMutations.get(entry.getKey());
    if (mutations == null) {
      mutations=vertexMutations.putIfAbsent(entry.getKey(),entry.getValue());
      if (mutations == null) {
        continue;
      }
    }
synchronized (mutations) {
      mutations.addVertexMutations(entry.getValue());
    }
  }
}
 

public void setAttribute(Object entity,String attributeName,Object value){
  if (entity == null) {
    return;
  }
  int id=System.identityHashCode(entity);
  Map<String,Object> attrs=attributes.get(id);
  if (attrs == null) {
    attrs=new ConcurrentHashMap<String,Object>();
    attributes.put(id,attrs);
  }
  if (attributeName != null && value != null) {
    attrs.put(attributeName,value);
  }
}
 

protected ControlBroadcaster(ControlP5 theControlP5){
  cp5=theControlP5;
  _myControlListeners=new ArrayList<ControlListener>();
  _myControllerCallbackListeners=new ConcurrentHashMap<CallbackListener,Controller>();
  _myControlEventPlug=checkObject(cp5.papplet,getEventMethod(),new Class[]{ControlEvent.class});
  _myControllerCallbackEventPlug=checkObject(cp5.papplet,_myControllerCallbackEventMethod,new Class[]{CallbackEvent.class});
  if (_myControlEventPlug != null) {
    _myControlEventType=ControlP5Constants.METHOD;
  }
}
 

private static Class getMap(Class type){
  if (hasDefaultConstructor(type)) {
    return type;
  }
 else   if (SortedMap.class.isAssignableFrom(type)) {
    return TreeMap.class;
  }
 else   if (ConcurrentMap.class.isAssignableFrom(type)) {
    return ConcurrentHashMap.class;
  }
 else {
    return LinkedHashMap.class;
  }
}
 

private RandomAccessFile getOrCreateRaf(Thread thread,Integer file) throws IOException {
  ConcurrentMap<Integer,RandomAccessFile> rafs=perThreadDataFileRafs.get(thread);
  if (rafs == null) {
    rafs=new ConcurrentHashMap<Integer,RandomAccessFile>();
    perThreadDataFileRafs.put(thread,rafs);
  }
  RandomAccessFile raf=rafs.get(file);
  if (raf == null) {
    raf=journal.getDataFiles().get(file).openRandomAccessFile();
    rafs.put(file,raf);
  }
  return raf;
}
 

private static Map<Instance.InstanceType,InstanceType> fillMatchMap(){
  Map<Instance.InstanceType,InstanceType> map=new ConcurrentHashMap<Instance.InstanceType,InstanceType>();
  map.put(Instance.InstanceType.MAP,InstanceType.MAP);
  map.put(Instance.InstanceType.SET,InstanceType.SET);
  map.put(Instance.InstanceType.LIST,InstanceType.LIST);
  map.put(Instance.InstanceType.QUEUE,InstanceType.QUEUE);
  map.put(Instance.InstanceType.MULTIMAP,InstanceType.MULTIMAP);
  map.put(Instance.InstanceType.TOPIC,InstanceType.TOPIC);
  map.put(Instance.InstanceType.LOCK,InstanceType.LOCK);
  map.put(Instance.InstanceType.ID_GENERATOR,InstanceType.ID_GENERATOR);
  return map;
}
 

/** 
 * @return a shared map for arbitrary use during a crawl; for example, couldbe used for state persisting for the duration of the crawl, shared among ScriptedProcessor, scripting console, etc scripts
 */
public ConcurrentHashMap<Object,Object> getData(){
  if (data == null) {
    data=new ConcurrentHashMap<Object,Object>();
  }
  return data;
}
 

public <T>void register(Class<T> clazz,String regionName,CacheCallback<T> handler){
  ConcurrentMap<String,QueryListenerEntry> values=map.get(clazz);
  if (values == null) {
    values=new ConcurrentHashMap<String,QueryListenerEntry>();
    ConcurrentMap<String,QueryListenerEntry> oldValues=map.putIfAbsent(clazz,values);
    if (oldValues != null) {
      values=oldValues;
    }
  }
  QueryListenerEntry entry=values.get(regionName);
  if (entry == null) {
    entry=new QueryListenerEntry(regionName,handler);
    values.putIfAbsent(regionName,entry);
  }
}
 

/** 
 * Need to make sure all needed caches are started before state transfer happens. This prevents this node to return undefined cache errors during replication when other nodes join this one.
 * @param cacheManager
 */
private void eagerlyInitializeCaches(EmbeddedCacheManager cacheManager){
  caches=new ConcurrentHashMap<String,Cache>(3);
  putInLocalCache(cacheManager,DefaultDatastoreNames.ASSOCIATION_STORE);
  putInLocalCache(cacheManager,DefaultDatastoreNames.ENTITY_STORE);
  putInLocalCache(cacheManager,DefaultDatastoreNames.IDENTIFIER_STORE);
}
 

@Override @SuppressWarnings("unchecked") public void init() throws ServiceException {
  timersSize=getServiceConfig().getInt(CONF_TIMERS_SIZE,10);
  counterLock=new ReentrantLock();
  timerLock=new ReentrantLock();
  variableLock=new ReentrantLock();
  samplerLock=new ReentrantLock();
  jvmVariables=new ConcurrentHashMap<String,VariableHolder>();
  counters=new ConcurrentHashMap<String,Map<String,AtomicLong>>();
  timers=new ConcurrentHashMap<String,Map<String,Timer>>();
  variables=new ConcurrentHashMap<String,Map<String,VariableHolder>>();
  samplers=new ConcurrentHashMap<String,Map<String,Sampler>>();
  samplersList=new ArrayList<Sampler>();
  all=new LinkedHashMap<String,Map<String,?>>();
  all.put("os-env",System.getenv());
  all.put("sys-props",(Map<String,?>)(Map)System.getProperties());
  all.put("jvm",jvmVariables);
  all.put("counters",(Map)counters);
  all.put("timers",(Map)timers);
  all.put("variables",(Map)variables);
  all.put("samplers",(Map)samplers);
  jvmVariables.put("free.memory",new VariableHolder<Long>(new Instrumentation.Variable<Long>(){
    public Long getValue(){
      return Runtime.getRuntime().freeMemory();
    }
  }
));
  jvmVariables.put("max.memory",new VariableHolder<Long>(new Instrumentation.Variable<Long>(){
    public Long getValue(){
      return Runtime.getRuntime().maxMemory();
    }
  }
));
  jvmVariables.put("total.memory",new VariableHolder<Long>(new Instrumentation.Variable<Long>(){
    public Long getValue(){
      return Runtime.getRuntime().totalMemory();
    }
  }
));
}
 

public DefaultHttpSession(HttpClient client,HttpClient httpsClient){
  if (client.isHttps()) {
    throw new IllegalArgumentException("HTTP client must not have SSL (HTTPS) support active");
  }
  if ((httpsClient != null) && !httpsClient.isHttps()) {
    throw new IllegalArgumentException("HTTPS client must have SSL (HTTPS) support active");
  }
  this.maxRedirects=MAX_REDIRECTS;
  this.client=client;
  this.httpsClient=httpsClient;
  ReentrantReadWriteLock rwLock=new ReentrantReadWriteLock();
  this.headerReadLock=rwLock.readLock();
  this.headerWriteLock=rwLock.writeLock();
  this.headers=new ArrayList<Map.Entry<String,String>>();
  this.handlers=new ConcurrentHashMap<Integer,ResponseCodeHandler>();
  this.addHandler(new AuthenticationResponseHandler());
  this.addHandler(new RedirectResponseHandler());
}
 

/** 
 * Default constructor
 */
public StandardHttpRequestRetryHandler(int retryCount,boolean requestSentRetryEnabled){
  super(retryCount,requestSentRetryEnabled);
  this.idempotentMethods=new ConcurrentHashMap<String,Boolean>();
  this.idempotentMethods.put("GET",Boolean.TRUE);
  this.idempotentMethods.put("HEAD",Boolean.TRUE);
  this.idempotentMethods.put("PUT",Boolean.TRUE);
  this.idempotentMethods.put("DELETE",Boolean.TRUE);
  this.idempotentMethods.put("OPTIONS",Boolean.TRUE);
  this.idempotentMethods.put("TRACE",Boolean.TRUE);
}
 

protected HttpTunnelServerChannel(ChannelFactory factory,ChannelPipeline pipeline,ChannelSink sink,ServerSocketChannelFactory inboundFactory,ChannelGroup realConnections){
  super(factory,pipeline,sink);
  tunnelIdPrefix=Long.toHexString(random.nextLong());
  tunnels=new ConcurrentHashMap<String,HttpTunnelAcceptedChannel>();
  config=new HttpTunnelServerChannelConfig();
  realChannel=inboundFactory.newChannel(this.createRealPipeline(realConnections));
  config.setRealChannel(realChannel);
  opened=new AtomicBoolean(true);
  bindState=new AtomicReference<BindState>(BindState.UNBOUND);
  realConnections.add(realChannel);
  Channels.fireChannelOpen(this);
}
 

/** 
 * Constructor. Creates an empty Promoter.
 * @param backupDir the directory to wich the data stored in this Scorer shall be
 * @param load if true, the promoter is generated from it's serialized version.persisted.
 */
@SuppressWarnings("unchecked") public BasicPromoter(File backupDir,boolean load) throws IOException {
  checkDirArgument(backupDir);
  this.backupDir=backupDir;
  if (!load) {
    storage=new ConcurrentHashMap<String,String>();
  }
 else {
    File f=new File(this.backupDir,MAIN_FILE_NAME);
    ObjectInputStream is=null;
    try {
      is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(f)));
      try {
        storage=(ConcurrentMap<String,String>)is.readObject();
      }
 catch (      ClassNotFoundException e) {
        throw new IllegalStateException(e);
      }
    }
  finally {
      Execute.close(is);
    }
  }
}
 

/** 
 * Create an instance of JmDNS and bind it to a specific network interface given its IP-address.
 * @param address IP address to bind to.
 * @param name name of the newly created JmDNS
 * @exception IOException
 */
public JmDNSImpl(InetAddress address,String name) throws IOException {
  super();
  if (logger.isLoggable(Level.FINER)) {
    logger.finer("JmDNS instance created");
  }
  _cache=new DNSCache(100);
  _listeners=Collections.synchronizedList(new ArrayList<DNSListener>());
  _serviceListeners=new ConcurrentHashMap<String,List<ServiceListenerStatus>>();
  _typeListeners=Collections.synchronizedSet(new HashSet<ServiceTypeListenerStatus>());
  _serviceCollectors=new ConcurrentHashMap<String,ServiceCollector>();
  _services=new ConcurrentHashMap<String,ServiceInfo>(20);
  _serviceTypes=new ConcurrentHashMap<String,ServiceTypeEntry>(20);
  _localHost=HostInfo.newHostInfo(address,this,name);
  _name=(name != null ? name : _localHost.getName());
  this.openMulticastSocket(this.getLocalHost());
  this.start(this.getServices().values());
  this.startReaper();
}