Ejemplo n.º 1
1
 public T instance() {
   T singletonInstancePerThread = null;
   // use weak reference to prevent cyclic reference during GC
   WeakReference<T> ref = (WeakReference<T>) perThreadCache.get();
   // singletonInstancePerThread=perThreadCache.get();
   // if (singletonInstancePerThread==null) {
   if (ref == null || ref.get() == null) {
     Class<T> clazz = null;
     try {
       clazz =
           (Class<T>) Thread.currentThread().getContextClassLoader().loadClass(singletonClassName);
       singletonInstancePerThread = clazz.newInstance();
     } catch (Exception ignore) {
       try {
         clazz = (Class<T>) Class.forName(singletonClassName);
         singletonInstancePerThread = clazz.newInstance();
       } catch (Exception ignore2) {
       }
     }
     perThreadCache.set(new WeakReference<T>(singletonInstancePerThread));
   } else {
     singletonInstancePerThread = ref.get();
   }
   return singletonInstancePerThread;
 }
Ejemplo n.º 2
1
  @Override
  public void addSources(List<TaskSource> sources) {
    checkNotNull(sources, "sources is null");
    checkState(
        !Thread.holdsLock(this),
        "Can not add sources while holding a lock on the %s",
        getClass().getSimpleName());

    try (SetThreadName setThreadName = new SetThreadName("Task-%s", taskId)) {
      // update our record of sources and schedule drivers for new partitioned splits
      Map<PlanNodeId, TaskSource> updatedUnpartitionedSources = updateSources(sources);

      // tell existing drivers about the new splits; it is safe to update drivers
      // multiple times and out of order because sources contain full record of
      // the unpartitioned splits
      for (TaskSource source : updatedUnpartitionedSources.values()) {
        // tell all the existing drivers this source is finished
        for (WeakReference<Driver> driverReference : drivers) {
          Driver driver = driverReference.get();
          // the driver can be GCed due to a failure or a limit
          if (driver != null) {
            driver.updateSource(source);
          } else {
            // remove the weak reference from the list to avoid a memory leak
            // NOTE: this is a concurrent safe operation on a CopyOnWriteArrayList
            drivers.remove(driverReference);
          }
        }
      }
    }
  }
  /**
   * Called after an operation executing in the background is completed. It sets the bitmap image to
   * an image view and dismisses the progress dialog.
   *
   * @param image The bitmap image
   */
  protected void onPostExecute(Bitmap image) {
    // Dismiss the progress dialog.
    mActivity.get().dismissDialog();

    // Display the downloaded image to the user.
    mActivity.get().displayBitmap(image);
  }
Ejemplo n.º 4
0
  public static ArrayList<Object[]> findClosestNodes(
      TileVisNode target, TileVisNode root, ArrayList<Object[]> in) {
    TileVisNode closestChild = null;

    for (WeakReference<TileVisNode> child : root.getChildren()) {
      TileVisNode n = child.get();

      if (n != null
          && !n.equals(target)
          && !n.equals(root)
          && (target.getAttunement() == -1
              || n.getAttunement() == -1
              || n.getAttunement() == target.getAttunement())) {

        float r2 =
            inRange(n.getWorldObj(), n.getLocation(), target.getLocation(), target.getRange());
        if (r2 > 0) {
          in.add(new Object[] {n, r2});
        }

        in = findClosestNodes(target, n, in);
      }
    }
    return in;
  }
Ejemplo n.º 5
0
  public static DomainInfo getInstance(String tld) {
    if (tld != null) {
      String lcaseTld = tld.toLowerCase(Locale.ENGLISH);
      int index = lcaseTld.indexOf(" ");
      if (index > 0) {
        // for examle recaptcha.com (google)
        lcaseTld = lcaseTld.substring(0, index);
      }

      index = lcaseTld.indexOf("/");
      if (index > 0) {
        // for examle recaptcha.com/bla
        lcaseTld = lcaseTld.substring(0, index);
      }
      synchronized (CACHE) {
        DomainInfo ret = null;
        WeakReference<DomainInfo> domainInfo = CACHE.get(lcaseTld);
        if (domainInfo == null || (ret = domainInfo.get()) == null) {
          ret = new DomainInfo(lcaseTld);
          CACHE.put(lcaseTld, new WeakReference<DomainInfo>(ret));
        }
        return ret;
      }
    }
    return null;
  }
Ejemplo n.º 6
0
 XPathSupport getXPathSupport() {
   if (jaxenXPathSupport != null) {
     return jaxenXPathSupport;
   }
   XPathSupport xps = null;
   Document doc = node.getOwnerDocument();
   if (doc == null) {
     doc = (Document) node;
   }
   synchronized (doc) {
     WeakReference ref = (WeakReference) xpathSupportMap.get(doc);
     if (ref != null) {
       xps = (XPathSupport) ref.get();
     }
     if (xps == null) {
       try {
         xps = (XPathSupport) xpathSupportClass.newInstance();
         xpathSupportMap.put(doc, new WeakReference(xps));
       } catch (Exception e) {
         logger.error("Error instantiating xpathSupport class", e);
       }
     }
   }
   return xps;
 }
Ejemplo n.º 7
0
  @Override
  protected void notifyUpdate(Iterable<PicItem> entities) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();

    for (PicItem entity : entities) {
      Long key = getKey(entity);
      if (key != null) {
        notifyExtraOb(key);

        ops.add(
            ContentProviderOperation.newUpdate(ContentUris.withAppendedId(CONTENT_URI, key))
                .withValue(null, null)
                .build());
      }
    }

    try {
      if (contextWeakReference.get() != null)
        contextWeakReference.get().getContentResolver().applyBatch(AUTHORITY, ops);
    } catch (RemoteException e) {
      e.printStackTrace();
    } catch (OperationApplicationException e) {
      e.printStackTrace();
    }
  }
Ejemplo n.º 8
0
  private boolean cleanupRequestor(long now) {
    boolean empty = true;
    int x = 0;
    for (int i = 0; i < requestorNodes.length; i++) {
      WeakReference<? extends PeerNodeUnlocked> ref = requestorNodes[i];
      if (ref == null) continue;
      PeerNodeUnlocked pn = ref.get();
      if (pn == null) continue;
      long bootID = pn.getBootID();
      if (bootID != requestorBootIDs[i]) continue;
      if (!pn.isConnected()) continue;
      if (now - requestorTimes[i] > MAX_TIME_BETWEEN_REQUEST_AND_OFFER) continue;
      empty = false;
      requestorNodes[x] = requestorNodes[i];
      requestorTimes[x] = requestorTimes[i];
      requestorBootIDs[x] = requestorBootIDs[i];
      requestorHTLs[x] = requestorHTLs[i];
      x++;
    }
    if (x < requestorNodes.length) {
      requestorNodes = Arrays.copyOf(requestorNodes, x);
      ;
      requestorTimes = Arrays.copyOf(requestorTimes, x);
      ;
      requestorBootIDs = Arrays.copyOf(requestorBootIDs, x);
      ;
      requestorHTLs = Arrays.copyOf(requestorHTLs, x);
      ;
    }

    return empty;
  }
Ejemplo n.º 9
0
 public static synchronized Activity getActivity() {
   Activity result = null;
   if (instanceRef != null && instanceRef.get() != null) {
     result = instanceRef.get();
   }
   return result;
 }
Ejemplo n.º 10
0
  @Override
  public void handleMessage(Message msg) {
    super.handleMessage(msg);

    switch (msg.what) {
      case 0:
        Activity activity = mActivity.get();
        BaseLoopView loopView = mLoopView.get();
        if (activity != null && loopView != null) {
          if (!loopView.isAutoScroll()) return;
          int change = (loopView.getDirection() == BaseLoopView.LEFT) ? -1 : 1;
          loopView
              .getViewPager()
              .setCurrentItem(loopView.getViewPager().getCurrentItem() + change, true);
          loopView.sendScrollMessage(loopView.getInterval());
        } else {
          removeMessages(0);
          if (loopView != null) {
            loopView.releaseResources();
          }
        }
      default:
        break;
    }
  }
Ejemplo n.º 11
0
 /*     */ public synchronized void close() /*     */ throws IOException /*     */ {
   /* 399 */ boolean bool1 = logger.traceOn();
   /* 400 */ boolean bool2 = logger.debugOn();
   /*     */
   /* 402 */ if (bool1) logger.trace("close", "closing");
   /*     */
   /* 404 */ Object localObject1 = null;
   /*     */ try {
     /* 406 */ if (bool2) logger.debug("close", "closing Server");
     /* 407 */ closeServer();
     /*     */ } catch (IOException localIOException1) {
     /* 409 */ if (bool1) logger.trace("close", "Failed to close server: " + localIOException1);
     /* 410 */ if (bool2) logger.debug("close", localIOException1);
     /* 411 */ localObject1 = localIOException1;
     /*     */ }
   /*     */
   /* 414 */ if (bool2) logger.debug("close", "closing Clients");
   /*     */ while (true)
   /*     */ {
     /* 417 */ synchronized (this.clientList) {
       /* 418 */ if (bool2) logger.debug("close", "droping dead references");
       /* 419 */ dropDeadReferences();
       /*     */
       /* 421 */ if (bool2) logger.debug("close", "client count: " + this.clientList.size());
       /* 422 */ if (this.clientList.size() == 0)
       /*     */ {
         /*     */ break;
         /*     */ }
       /*     */
       /* 428 */ Iterator localIterator = this.clientList.iterator();
       /* 429 */ if (localIterator.hasNext()) {
         /* 430 */ WeakReference localWeakReference = (WeakReference) localIterator.next();
         /* 431 */ RMIConnection localRMIConnection = (RMIConnection) localWeakReference.get();
         /* 432 */ localIterator.remove();
         /* 433 */ if (localRMIConnection != null) {
           /*     */ try {
             /* 435 */ localRMIConnection.close();
             /*     */ } catch (IOException localIOException2) {
             /* 437 */ if (bool1)
               /* 438 */ logger.trace("close", "Failed to close client: " + localIOException2);
             /* 439 */ if (bool2) logger.debug("close", localIOException2);
             /* 440 */ if (localObject1 == null) {
               /* 441 */ localObject1 = localIOException2;
               /*     */ }
             /*     */ }
           /*     */ }
         /*     */ }
       /*     */ }
     /*     */ }
   /*     */
   /* 449 */ if (this.notifBuffer != null) {
     /* 450 */ this.notifBuffer.dispose();
     /*     */ }
   /* 452 */ if (localObject1 != null) {
     /* 453 */ if (bool1) logger.trace("close", "close failed.");
     /* 454 */ throw localObject1;
     /*     */ }
   /*     */
   /* 457 */ if (bool1) logger.trace("close", "closed.");
   /*     */ }
Ejemplo n.º 12
0
 /*     */ protected void clientClosed(RMIConnection paramRMIConnection)
     /*     */ throws IOException
       /*     */ {
   /* 338 */ boolean bool = logger.debugOn();
   /*     */
   /* 340 */ if (bool) logger.trace("clientClosed", "client=" + paramRMIConnection);
   /*     */
   /* 342 */ if (paramRMIConnection == null) {
     /* 343 */ throw new NullPointerException("Null client");
     /*     */ }
   /* 345 */ synchronized (this.clientList) {
     /* 346 */ dropDeadReferences();
     /* 347 */ Iterator localIterator = this.clientList.iterator();
     /* 348 */ while (localIterator.hasNext()) {
       /* 349 */ WeakReference localWeakReference = (WeakReference) localIterator.next();
       /* 350 */ if (localWeakReference.get() == paramRMIConnection) {
         /* 351 */ localIterator.remove();
         /* 352 */ break;
         /*     */ }
       /*     */
       /*     */ }
     /*     */
     /*     */ }
   /*     */
   /* 360 */ if (bool) logger.trace("clientClosed", "closing client.");
   /* 361 */ closeClient(paramRMIConnection);
   /*     */
   /* 363 */ if (bool) logger.trace("clientClosed", "sending notif");
   /* 364 */ this.connServer.connectionClosed(
       paramRMIConnection.getConnectionId(), "Client connection closed", null);
   /*     */
   /* 367 */ if (bool) logger.trace("clientClosed", "done");
   /*     */ }
  @Override
  public void deliverError(VolleyError error) {
    super.deliverError(error);
    if (mListenerReference != null && mListenerReference.get() != null) {
      NetworkListener listener = mListenerReference.get();
      BaseError response = new BaseError();

      if (error.networkResponse != null) {
        response.mStatusCode = error.networkResponse.statusCode;
        response.mErrorMessage = new String(error.networkResponse.data);
      } else if (error instanceof NetworkError || error instanceof NoConnectionError) {
        response.mErrorMessage = "Please check the internet connection";
      } else if (error instanceof TimeoutError) {
        response.mErrorMessage = "Server is busy try again later";
      } else if (error instanceof AuthFailureError) {
        response.mErrorMessage = "Auth Failure";
      } else if (error instanceof ServerError) {
        response.mErrorMessage = "ServerError";
      } else if (error instanceof ParseError) {
        response.mErrorMessage = "Error in parsing server data";
      }

      listener.onError(response);
    }
  }
 @Override
 protected void deliverResponse(T response) {
   if (mListenerReference != null && mListenerReference.get() != null) {
     NetworkListener listener = mListenerReference.get();
     listener.onSuccess(response);
   }
 }
Ejemplo n.º 15
0
  private final Collection<ICompilationUnit> collectAssociatedCompilationUnits(
      IFileSpecification file) {
    String filename = file.getPath();
    Collection<WeakReference<ICompilationUnit>> relatedCompilationUnits =
        pathToCompilationUnitMapping.getVisibleAndInvisible(filename);

    // relatedCompilationUnits should never be null, but it is OK for it to be empty, as
    // we can be null, if someone passes us in a arbitrary file which has no compilation
    // units associated with it.
    assert (relatedCompilationUnits != null) : "relatedCompilationUnits should never be null";

    // add any compilation units which include the file, as they need to be recompiled also
    Collection<WeakReference<ICompilationUnit>> includingCompilationUnits =
        includeFilesToIncludingCompilationUnitMapping.get(filename);

    Collection<WeakReference<ICompilationUnit>> allRelatedCompilationUnits =
        new HashSet<WeakReference<ICompilationUnit>>();
    allRelatedCompilationUnits.addAll(relatedCompilationUnits);
    allRelatedCompilationUnits.addAll(includingCompilationUnits);

    HashSet<ICompilationUnit> associatedCompilationUnits = new HashSet<ICompilationUnit>();
    for (WeakReference<ICompilationUnit> relatedCURef : allRelatedCompilationUnits) {
      ICompilationUnit relatedCU = relatedCURef.get();
      if (relatedCU != null) {
        associatedCompilationUnits.add(relatedCU);
      }
    }

    final Set<ICompilationUnit> associatedCompilationUnitsAccountingForConflictingDefinitions =
        ASProjectScope.getCompilationUnitsWithConflictingDefinitions(
            this, associatedCompilationUnits);

    return associatedCompilationUnitsAccountingForConflictingDefinitions;
  }
 @Override
 public synchronized Component getComponentByURI(URI id) {
   WeakReference<Component> componentRef = uriToComponent.get(id);
   if (componentRef == null) return null;
   // Might also be null it reference has gone dead
   return componentRef.get();
 }
Ejemplo n.º 17
0
 public static synchronized Context getInstance() {
   if (instanceRef == null || instanceRef.get() == null) {
     return BaseApplication.getContext();
   } else {
     return instanceRef.get();
   }
 }
Ejemplo n.º 18
0
  private void fetchComments() {
    try {
      final URL newUrl = new URL(book.get().getCommentsUrl());

      // sax stuff
      final SAXParserFactory factory = SAXParserFactory.newInstance();
      final SAXParser parser = factory.newSAXParser();

      final XMLReader reader = parser.getXMLReader();

      // initialize our parser logic
      final CommentsHandler commentsHandler = new CommentsHandler(book.get().getComments());
      reader.setContentHandler(commentsHandler);

      // get the xml feed
      reader.parse(new InputSource(newUrl.openStream()));
    } catch (MalformedURLException e) {
      COMMENTS_ERROR = MALFORMED_URL;
      Log.e(TAG, "MalformedURLException: " + e + "\nIn fetchComments()");
    } catch (ParserConfigurationException pce) {
      COMMENTS_ERROR = PARSER_CONFIG_ERROR;
      Log.e(TAG, "ParserConfigurationException: " + pce + "\nIn fetchComments()");
    } catch (SAXException se) {
      COMMENTS_ERROR = SAX_ERROR;
      Log.e(TAG, "SAXException: " + se + "\nIn fetchComments()");
    } catch (IOException ioe) {
      COMMENTS_ERROR = IO_ERROR;
      Log.e(TAG, "IOException: " + ioe + "\nIn fetchComments()");
    }
  }
Ejemplo n.º 19
0
 /** Have we asked this peer for the key? */
 public synchronized boolean askedFromPeer(PeerNodeUnlocked peer, long now) {
   boolean anyValid = false;
   boolean ret = false;
   for (int i = 0; i < requestedNodes.length; i++) {
     WeakReference<? extends PeerNodeUnlocked> ref = requestedNodes[i];
     if (ref == null) continue;
     PeerNodeUnlocked pn = ref.get();
     if (pn == null) {
       requestedNodes[i] = null;
       continue;
     }
     long bootID = pn.getBootID();
     if (bootID != requestedBootIDs[i]) {
       requestedNodes[i] = null;
       continue;
     }
     anyValid = true;
     if (now - requestedTimes[i] < MAX_TIME_BETWEEN_REQUEST_AND_OFFER) {
       if (pn == peer) ret = true;
       anyValid = true;
     }
   }
   if (!anyValid) {
     requestedNodes = EMPTY_WEAK_REFERENCE;
     requestedTimes =
         requestedBootIDs = requestedTimeoutsRF = requestedTimeoutsFT = EMPTY_LONG_ARRAY;
     requestedTimeoutHTLs = EMPTY_SHORT_ARRAY;
   }
   return ret;
 }
  @SuppressWarnings("unchecked")
  void check() {

    watchDogRuns++;

    long current = System.currentTimeMillis();

    ArrayList<WeakReference<TimeoutMgmHandle>> connectionsCopy = null;
    synchronized (handles) {
      connectionsCopy = (ArrayList<WeakReference<TimeoutMgmHandle>>) handles.clone();
    }

    for (WeakReference<TimeoutMgmHandle> handleRef : connectionsCopy) {

      TimeoutMgmHandle handle = handleRef.get();
      if (handle == null) {
        remove(handleRef);

      } else {
        NonBlockingConnection con = handle.getConnection();
        if (con.isOpen()) {
          checkTimeout(con, current);

        } else {
          remove(handleRef);
        }
      }
    }

    computeSize();
  }
Ejemplo n.º 21
0
 public synchronized short minRequestorHTL(short htl) {
   long now = System.currentTimeMillis();
   boolean anyValid = false;
   for (int i = 0; i < requestorNodes.length; i++) {
     WeakReference<? extends PeerNodeUnlocked> ref = requestorNodes[i];
     if (ref == null) continue;
     PeerNodeUnlocked pn = ref.get();
     if (pn == null) {
       requestorNodes[i] = null;
       continue;
     }
     long bootID = pn.getBootID();
     if (bootID != requestorBootIDs[i]) {
       requestorNodes[i] = null;
       continue;
     }
     if (now - requestorTimes[i] < MAX_TIME_BETWEEN_REQUEST_AND_OFFER) {
       if (requestorHTLs[i] < htl) htl = requestorHTLs[i];
     }
     anyValid = true;
   }
   if (!anyValid) {
     requestorNodes = EMPTY_WEAK_REFERENCE;
     requestorTimes = requestorBootIDs = EMPTY_LONG_ARRAY;
     ;
     requestorHTLs = EMPTY_SHORT_ARRAY;
   }
   return htl;
 }
 protected void onSignOut(Activity currentActivity) {
   if (currentActivity == null) {
     Log.e(TAGERROR, "Activity can not be null");
   } else {
     changeCurrentState(StatusFacebookConn.DISCONNECTED);
     Log.i(TAGINFO, "Disconnected");
     LoginManager.getInstance().logOut();
     activityWeakReference
         .get()
         .getSharedPreferences("FacebookSession", Context.MODE_PRIVATE)
         .edit()
         .putBoolean("FacebookLogged", false)
         .commit();
     activityWeakReference
         .get()
         .getSharedPreferences("FacebookSession", Context.MODE_PRIVATE)
         .edit()
         .putString("FacebookEmail", null)
         .commit();
     currentActivity.startActivity(new Intent(currentActivity, LoginActivity.class));
     activityWeakReference.get().finish();
     currentActivity.finish();
     clearInstanceReference();
   }
 }
Ejemplo n.º 23
0
 public void removeListener(final ListenerType t) {
   if (t == null) {
     return;
   }
   synchronized (this.LOCK) {
     if (weakListener.size() > 0) {
       ListenerType l = null;
       final java.util.List<WeakReference<ListenerType>> newWeakListener =
           new ArrayList<WeakReference<ListenerType>>(this.weakListener.size());
       for (final WeakReference<ListenerType> listener : this.weakListener) {
         if ((l = listener.get()) == null) {
           /* weak item is gone */
           continue;
         } else if (l != t) {
           newWeakListener.add(listener);
         }
       }
       this.weakListener = newWeakListener;
     }
     /* remove strong item */
     if (strongListeners.contains(t)) {
       final java.util.List<ListenerType> newStrongListener =
           new ArrayList<ListenerType>(this.strongListeners);
       newStrongListener.remove(t);
       this.strongListeners = newStrongListener;
     }
   }
 }
Ejemplo n.º 24
0
  public synchronized void cleanupCurrentThread() {
    final long id = Thread.currentThread().getId();
    for (final ConcreteResource res : new HashSet<ConcreteResource>(lock.keySet())) {
      final WeakReference<Thread> ref = lock.get(res);
      if (ref != null) {
        boolean rm = false;
        if (ref.get() == null) {
          logger.debug(
              "Cleaning up lock: {} for thread: {}", res, Thread.currentThread().getName());
          rm = true;
        } else if (ref.get().getId() == id) {
          logger.debug(
              "Cleaning up lock: {} for thread: {}", res, Thread.currentThread().getName());
          rm = true;
        }

        if (rm) {
          synchronized (lock) {
            lock.remove(res);
            lock.notifyAll();
          }
        }
      }
    }
  }
  public void testDroppedThread() throws Exception {

    this.server.setHttpService(new EchoService());

    MultiThreadedHttpConnectionManager mthcm = new MultiThreadedHttpConnectionManager();
    client.setHttpConnectionManager(mthcm);
    WeakReference wr = new WeakReference(mthcm);

    GetMethod method = new GetMethod("/");
    client.executeMethod(method);
    method.releaseConnection();

    mthcm = null;
    client = null;
    method = null;

    System.gc();

    // this sleep appears to be necessary in order to give the JVM
    // time to clean up the miscellaneous pointers to the connection manager
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      fail("shouldn't be interrupted.");
    }

    Object connectionManager = wr.get();
    assertNull("connectionManager should be null", connectionManager);
  }
Ejemplo n.º 26
0
  public Map<ConcreteResource, CharSequence> getActiveLocks() {
    final Map<ConcreteResource, CharSequence> active =
        new HashMap<ConcreteResource, CharSequence>();
    for (final ConcreteResource f : lock.keySet()) {
      final StringBuilder owner = new StringBuilder();
      final WeakReference<Thread> ref = lock.get(f);
      if (ref == null) {
        owner.append("UNKNOWN OWNER; REF IS NULL.");
      }

      final Thread t = ref.get();
      if (t == null) {
        owner.append("UNKNOWN OWNER; REF IS EMPTY.");
      } else {
        owner.append(t.getName());
        if (!t.isAlive()) {
          owner.append(" (DEAD)");
        }
      }

      active.put(f, owner);
    }

    return active;
  }
Ejemplo n.º 27
0
  /**
   * Returns an instance of NativeLibrary for the specified name. The library is loaded if not
   * already loaded. If already loaded, the existing instance is returned.
   *
   * <p>More than one name may map to the same NativeLibrary instance; only a single instance will
   * be provided for any given unique file path.
   *
   * @param libraryName The library name to load. This can be short form (e.g. "c"), an explicit
   *     version (e.g. "libc.so.6" or "QuickTime.framework/Versions/Current/QuickTime"), or the full
   *     (absolute) path to the library (e.g. "/lib/libc.so.6").
   * @param options native library options for the given library (see {@link Library}).
   */
  public static final NativeLibrary getInstance(String libraryName, Map options) {
    options = new HashMap(options);
    if (options.get(Library.OPTION_CALLING_CONVENTION) == null) {
      options.put(Library.OPTION_CALLING_CONVENTION, new Integer(Function.C_CONVENTION));
    }

    // Use current process to load libraries we know are already
    // loaded by the VM to ensure we get the correct version
    if ((Platform.isLinux() || Platform.isAIX()) && Platform.C_LIBRARY_NAME.equals(libraryName)) {
      libraryName = null;
    }
    synchronized (libraries) {
      WeakReference ref = (WeakReference) libraries.get(libraryName + options);
      NativeLibrary library = ref != null ? (NativeLibrary) ref.get() : null;

      if (library == null) {
        if (libraryName == null) {
          library =
              new NativeLibrary("<process>", null, Native.open(null, openFlags(options)), options);
        } else {
          library = loadLibrary(libraryName, options);
        }
        ref = new WeakReference(library);
        libraries.put(library.getName() + options, ref);
        File file = library.getFile();
        if (file != null) {
          libraries.put(file.getAbsolutePath() + options, ref);
          libraries.put(file.getName() + options, ref);
        }
      }
      return library;
    }
  }
Ejemplo n.º 28
0
  /**
   * Notify the {@link ImageProxy} that an image has been loaded.
   *
   * @param iconId The id of the image that has been loaded.
   * @param result The image.
   */
  void imageReady(long iconId, Drawable result) {
    if (result == null) {
      return;
    }

    synchronized (mImageCache) {
      // put the icon into the cache
      mImageCache.put(iconId, result);
    }

    Set<WeakReference<ImageAvailableListener>> listeners = null;
    synchronized (mJobWaitQueue) {
      listeners = mJobWaitQueue.get(iconId);
      // all listeners will be notified now, so remove them
      mJobWaitQueue.remove(iconId);
    }

    if (listeners != null) {
      // notify listeners
      for (WeakReference<ImageAvailableListener> listenerRef : listeners) {
        ImageAvailableListener listener = listenerRef.get();
        if (listener != null) {
          listener.imageAvailable(iconId, result);
        }
      }
    }
  }
Ejemplo n.º 29
0
  /**
   * This method drains vis from a relay or source near the passed in location. The amount received
   * can be less than the amount requested so take that into account.
   *
   * @param world
   * @param x the x position of the draining block or entity
   * @param y the y position of the draining block or entity
   * @param z the z position of the draining block or entity
   * @param aspect what aspect to drain
   * @param amount how much to drain
   * @return how much was actually drained
   */
  public static int drainVis(World world, int x, int y, int z, Aspect aspect, int amount) {

    int drainedAmount = 0;

    WorldCoordinates drainer = new WorldCoordinates(x, y, z, world.provider.dimensionId);
    if (!nearbyNodes.containsKey(drainer)) {
      calculateNearbyNodes(world, x, y, z);
    }

    ArrayList<WeakReference<TileVisNode>> nodes = nearbyNodes.get(drainer);
    if (nodes != null && nodes.size() > 0)
      for (WeakReference<TileVisNode> noderef : nodes) {

        TileVisNode node = noderef.get();

        if (node == null) continue;

        int a = node.consumeVis(aspect, amount);
        drainedAmount += a;
        amount -= a;
        if (a > 0) {
          int color = Aspect.getPrimalAspects().indexOf(aspect);
          generateVisEffect(
              world.provider.dimensionId, x, y, z, node.xCoord, node.yCoord, node.zCoord, color);
        }
        if (amount <= 0) {
          break;
        }
      }

    return drainedAmount;
  }
Ejemplo n.º 30
0
  public String cachedValueOf(final String str) {
    if (str != null && (lengthLimit < 0 || str.length() <= lengthLimit)) {
      // Return value from cache if available
      try {
        lock.readLock().lock();
        WeakReference<String> ref = cache.get(str);
        if (ref != null) {
          return ref.get();
        }
      } finally {
        lock.readLock().unlock();
      }

      // Update cache with new content
      try {
        lock.writeLock().lock();
        WeakReference<String> ref = cache.get(str);
        if (ref != null) {
          return ref.get();
        }
        cache.put(str, new WeakReference<>(str));
      } finally {
        lock.writeLock().unlock();
      }
      return str;
    }
    return str;
  }