Reloads the data from the repository if the last refresh did not occur within durationInMillis.

@param integer $durationInMillis
@throws CmisObjectNotFoundException - if the object doesn't exist anymore in the repository
439513
public function refreshIfOld($durationInMillis = 0)
    {
        if ($this->getRefreshTimestamp() < ((round(microtime(true) * 1000)) - (integer) $durationInMillis)) {
            $this->refresh();
        }
    }
18748
public void addPutTimeNanos(long duration) {
        for (;;) {
            long nanos = putTimeTakenNanos;
            if (nanos <= Long.MAX_VALUE - duration) {
                if (PUT_TIME_TAKEN_NANOS.compareAndSet(this, nanos, nanos + duration)) {
                    return;
                }
            } else {
                //counter full. Just reset.
                if (PUT_TIME_TAKEN_NANOS.compareAndSet(this, nanos, duration)) {
                    clear();
                    return;
                }
            }
        }
    }
483116
public function reload()
    {
        $this->configuration = null;

        $this->load($this->domDocument, $this->cachePath, $this->xmlSchemaFile);
    }
896731
public void addGetTimeNano(long duration) {
      if (unsupportCacheGetTotalTime.get() <= Long.MAX_VALUE - duration) {
         unsupportCacheGetTotalTime.addAndGet(duration);
      } else {
         //counter full. Just reset.
         clear();
         unsupportCacheGetTotalTime.set(duration);
      }
   }
531709
void reload() {

        CmsRpcAction<CmsResourceStatusBean> action = new CmsRpcAction<CmsResourceStatusBean>() {

            @Override
            public void execute() {

                start(0, true);
                CmsCoreProvider.getVfsService().getResourceStatus(
                    m_structureId,
                    CmsCoreProvider.get().getLocale(),
                    m_includeTargets,
                    m_detailContentId,
                    null,
                    this);
            }

            @Override
            protected void onResponse(CmsResourceStatusBean result) {

                reinitContent(result);
            }
        };
        action.execute();
    }
558421
public function reload()
    {
        if ($this->root !== $this) {
            $this->root->reload();
            return;
        }
        if (! isset($this->store)) {
            return;
        }
        if (! $this->store->touch()) {
            return;
        }
        try {
            $this->store->open(false);
            $this->data = $this->store->read();
        } catch (AccessException $e) {
            throw new AccessException('Could not read configration: ' . $e->getMessage(), null, $e);
        }
        $this->store->close();
    }
1336677
public function setTimeout($timeout)
    {
        if ($this->status != self::STATUS_NEW) {
            throw new \RuntimeException('Cannot set worker timeout after worker has started working');
        }

        $this->timeout = $timeout;
    }
1315072
public function add($duration)
    {
        $d1 = $this->refDate;
        $d2 = clone $d1;

        if ($duration instanceof QtiDuration) {
            $toAdd = $duration;
        } elseif ($duration instanceof DateInterval) {
            $toAdd = self::createFromDateInterval($duration);
        } else {
            return;
        }

        $d2->add(new DateInterval($this->__toString()));
        $d2->add(new DateInterval($toAdd->__toString()));

        $interval = $d2->diff($d1);
        $this->interval = $interval;
    }
449713
public function plusDuration(Duration $duration) : ZonedDateTime
    {
        return ZonedDateTime::ofInstant($this->instant->plus($duration), $this->timeZone);
    }
1029635
public function reload()
    {
        // update application components to the latest version
        if (file_exists($this->lock_file)) {
            unlink($this->lock_file);
        }

        $this->composer = $this->factory->createComposer($this->getIO());
    }
584777
public void onTimerEvent(TimerEvent event, ActivityContextInterface aci) {
		// time to refresh :)
		
		if (getSubscribeRequestTypeCMP() != null) {
			return;
		}

		try {
			DialogActivity da = (DialogActivity) aci.getActivity();
			Request refreshSubscribe = createRefresh(da, getSubscriptionData());
			setSubscribeRequestTypeCMP(SubscribeRequestType.REFRESH);
			da.sendRequest(refreshSubscribe);
		} catch (Exception e) {
			if (tracer.isSevereEnabled()) {
				tracer.severe("Failed to send unSUBSCRIBE for forked dialog.", e);
			}
		}
	}
1287076
public function setMaxTime(QtiDuration $maxTime = null)
    {
        // Prevent to get 0s durations stored.
        if (is_null($maxTime) === false && $maxTime->getSeconds(true) === 0) {
            $maxTime = null;
        }

        $this->maxTime = $maxTime;
    }
1015844
public function writeDuration(QtiDuration $duration)
    {
        try {
            $this->writeString($duration->__toString());
        } catch (BinaryStreamAccessException $e) {
            $msg = "An error occured while writing a duration.";
            throw new QtiBinaryStreamAccessException($msg, $this, QtiBinaryStreamAccessException::DURATION, $e);
        }
    }
1269657
protected function _afterEntityInsert(AnCommandContext $context)
    {
        $this->subscribee->getRepository()
                         ->getBehavior('subscribable')
                         ->resetStats(array($this->subscribee));
    }
894795
protected function _getDurationInSeconds($duration) {
        $interval = new \DateInterval($duration);
        return ($interval->d * 24 * 60 * 60) +
            ($interval->h * 60 * 60) +
            ($interval->i * 60) +
            $interval->s;
    }
1035822
public void refresh(Object entity)
    {
        if (contains(entity))
        {
            MainCache mainCache = (MainCache) getPersistenceCache().getMainCache();
            Node node = mainCache.getNodeFromCache(entity, getMetadata(entity.getClass()), this);
            // Locking as it might read from persistence context.

            try
            {
                lock.readLock().lock();
                node.setPersistenceDelegator(this);
                node.refresh();
            }
            finally
            {
                lock.readLock().unlock();
            }
        }
        else
        {
            throw new IllegalArgumentException("This is not a valid or managed entity, can't be refreshed");
        }
    }
935183
public function refreshInstance()
  {
    $this->counter    = 0;
    $this->startedAt  = microtime(true);
    $this->expiresAt  = $this->computeExpiration();
    $this->setUpComponents($this->components);
  }