<p>Return the value of the <code>onunload</code> property.</p>
346706
public java.lang.String getOnunload() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.onunload);

    }
450319
public boolean isUnloadedAtDestination() {
		for (HandlingEvent event : this.lnkDeliveryHistory.eventsOrderedByCompletionTime()) {
			if (HandlingEvent.Type.UNLOAD.equals(event.getType()) && hasArrived()) {
				return true;
			}
		}
		return false;
	}
395764
public ImageDownloadResult getImageDownloadResultWait() throws Exception {
		try {
			ImageDownloadResult imdr = pool.take().get();
			return imdr;
		} catch (Exception e) {
			throw e;
		} finally {
			// in any case (Exception or not) the numPendingTask should be reduced
			numPendingTasks--;
		}
	}
682484
function () {
            if (this.$subBinding) {
                this.$subBinding.invalidateValueCache();
                return this.$subBinding.getValue();
            } else {

                if (this.$cachedValue !== undefined && !this.$jsonObject) {
                    return this.$cachedValue;
                }

                this.$originalValue = undefined;
                if (this.$.fnc && !this.$jsonObject) {
                    this.$originalValue = this.$.fnc.apply(this.$.scope, this._getFncParameters());
                } else if (this.$.path.length === 1) {
                    this.$originalValue = this.$.scope.get(this.$.key.name);
                } else if (this.$jsonObject && !_.isString(this.$jsonObject)) {
                    this.$originalValue = this.$.scope.get(this.$jsonObject, this.$.path.slice(1));
                } else {
                    this.$originalValue = this.$.scope.get(this.$.path);
                }
                this.$cachedValue = this.transform.call(this.transformScope, this.$originalValue);
                return this.$cachedValue;
            }

        }
1297514
public static <T> T getValue(ValuedProperty<T> property) {
		return (property == null) ? null : property.getValue();
	}
30050
function getOverload() {
  /**
   * Overload Cldr.prototype.get().
   */
  superGet = Cldr.prototype.get;
  Cldr.prototype.get = function(path) {
    var value = superGet.apply(this, arguments);
    path = pathNormalize(path, this.attributes).join("/");
    globalEe.trigger("get", [path, value]);
    this.ee.trigger("get", [path, value]);
    return value;
  };
}
717449
public void unload() {
    Map<String, String> settings = CACHE.get();
    CACHE.remove();
    // update cache of settings to be used in case of DB connectivity error
    this.getPropertyDbFailureCache = settings;
  }
1023379
public void unbind() throws Throwable
   {
      if (name == null)
         throw new IllegalArgumentException("Name is null");

      if (trace)
         log.trace("Unbinding " + name);

      Context context = null;
      try
      {
         Properties properties = new Properties();
         properties.setProperty(Context.PROVIDER_URL, jndiProtocol + "://" + jndiHost + ":" + jndiPort);
         context = new InitialContext(properties);


         Util.unbind(context, name);

         objs.remove(name);

         if (log.isDebugEnabled())
            log.debug("Unbound " + name);
      }
      catch (Throwable t)
      {
         log.exceptionDuringUnbind(t);
      }
      finally
      {
         if (context != null)
         {
            try
            {
               context.close();
            }
            catch (NamingException ne)
            {
               // Ignore
            }
         }
      }
   }
945893
private OperationResult getOperationResult() {
        if (operationResult == null) {
            this.operationResult = (OperationResult) marshaller.unmarshal(new StringSource(getPayload(String.class)));
        }

        return operationResult;
    }
345337
synchronized Object getValue() {
        while (value == NULL) {
            try {
                wait();
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
        }
        return value;
    }
1167613
public void unload() throws Exception {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
            logger.entering(CLASS_NAME, "unload className-->[" + servletConfig.getClassName() + "], servletName[" + servletConfig.getServletName()
                    + "]"); // 569469
        // logger.logp(Level.FINE, CLASS_NAME,"unload",
        // "entry className-->["+servletConfig.getClassName()+"], servletName["+servletConfig.getServletName()+"]");
        // // PK26183

        if (state == UNINITIALIZED_STATE) {
            return;
        }

        try {
            doDestroy();
        } catch (Throwable th) {
            com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(th, "com.ibm.ws.webcontainer.servlet.ServletWrapper.unload", "1511", this);
            logger.logp(Level.SEVERE, CLASS_NAME, "unload", "Exception.occured.during.servlet.unload", th);
        } finally {
            /*
             * 125087: Do not explicitly null out the servlet instance or its classloader.  These should
             * be GCed when the wrapper itself is garbage collected.
             */ 
            //target = null;
            //targetLoader = null;
            invalidateCacheWrappers();
            state = UNINITIALIZED_STATE;
        }

        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
            logger.exiting(CLASS_NAME, "unload"); // 569469

    }
158332
private Future triggerLoading() {
        if (keyLoadFinished.isDone()) {
            keyLoadFinished = new LoadFinishedFuture();

            // side effect -> just trigger load on SENDER_BACKUP ID SENDER died
            execService.execute(MAP_LOAD_ALL_KEYS_EXECUTOR, () -> {
                // checks if loading has finished and triggers loading in case SENDER died and SENDER_BACKUP took over.
                Operation op = new TriggerLoadIfNeededOperation(mapName);
                opService.<Boolean>invokeOnPartition(SERVICE_NAME, op, mapNamePartition)
                        // required since loading may be triggered after migration
                        // and in this case the callback is the only way to get to know if the key load finished or not.
                        .andThen(loadingFinishedCallback());
            });
        }
        return keyLoadFinished;
    }
280083
public synchronized boolean load(
            AmazonWebServiceRequest request,
            ResultCapture<?> extractor) {

        if (attributes != null) {
            return false;
        }

        ActionModel action = resourceModel.getLoadAction();
        if (action == null) {
            throw new UnsupportedOperationException(
                "This resource does not support being loaded.");
        }

        // The facade generator ensures it's only ever possible to pass an
        // instance of the appropriate type.
        @SuppressWarnings("unchecked")
        ResultCapture<Object> erasedExtractor =
                (ResultCapture<Object>) extractor;

        ActionResult result = ActionUtils.perform(
                this, action, request, erasedExtractor);

        this.attributes = parseAttributes(resourceModel, result.getData());

        return true;
    }
196882
@Override
    public synchronized boolean load() {
        Either<Void, T> oldData = data;
        long oldModified = modified;
        String oldKey = versionedKey;
        try {
            if (isOutOfDate() || needsData()) {
                String newVersionedKey = reader.getAsString(key)
                                               .orElse(null);
                val loaded = nonAtomicload(newVersionedKey);
                data = Either.right((T) loaded._2());
                modified = loaded._1();
                versionedKey = newVersionedKey;
            } else {
                return false;
            }
        } catch (Throwable e) {
            data = oldData;
            versionedKey = oldKey;
            modified = oldModified;
            logger.info(e.getMessage(), e);
            throw ExceptionSoftener.throwSoftenedException(e);
        }
        return true;
    }
1252923
public java.lang.String getOnchange() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.onchange);

    }
527082
public String getPropertyValue(String propertyName) {

        if (m_ownProperties.containsKey(propertyName)) {
            return m_ownProperties.get(propertyName).getEffectiveValue();
        }
        return null;
    }
1012846
@SubscribeEvent
	public void onDataUnload(ChunkEvent.Unload event)
	{
		//only unload on client, server unloads on save
		if (!event.getWorld().isRemote)
			return;

		for (HandlerInfo<?> handlerInfo : handlerInfos.values())
		{
			datas.get().remove(handlerInfo.identifier, event.getChunk());
		}
	}