Get loading state of the syncers

@returns {boolean}
503760
function loadingStateGetter() {
	if (Object.keys(this._syncers).length > 0) {
		return some(this._syncers, syncer => {
			return syncer.loading
		})
	}
	return false
}
275530
function syncSetState (newState) {
  // Mutation is faster and should be safe here.
  this.state = assign(
    this.state,
    isFunction(newState) ?
      newState(this.state, this.props) :
      newState
  );
}
1361276
function isLoadNeeded(newProps, oldProps) {
        return !_.isEqual(newProps.formDesign, oldProps.formDesign) || !_.isEqual(newProps.data, oldProps.data);
      }
117580
@SuppressWarnings("sync-override")
	@Override
	public EList<EObject> getContents() {
		synchronized (getLock()) {
			if (isLoaded && !isLoading && !isInitializing && !isUpdating && !fullyInitialized && !isLoadedFromStorage()) {
				try {
					eSetDeliver(false);
					installDerivedState(false);
				} finally {
					eSetDeliver(true);
				}
			}
			return doGetContents();
		}
	}
813020
function ready() {
  for (var i = 0; i < preloadTiles.length; i++) {
    var state = layerAbove.textureStore().query(preloadTiles[i]);
    if (!state.hasTexture) {
      return false;
    }
  }
  return true;
}
1021517
function isHelperGroup(helpers) {
  if (!helpers) return false;
  if (helpers.isGroup) {
    return true;
  }
  if (typeof helpers === 'function' || isObject(helpers)) {
    var keys = Object.keys(helpers).filter(function(name) {
      return ['async', 'sync', 'displayName'].indexOf(name) === -1;
    });
    return keys.length > 1;
  }
  return false;
}
1373257
function () {

          if (!this.storage) {
            return null;
          }

          var serialized;

          // try loading storage item
          serialized = this.storage.getItem(this.id);

          if (serialized) {
            // check for promise
            if (typeof serialized === 'object' && typeof serialized.then === 'function') {
              return this._handleAsyncLoad(serialized);
            }
            // otherwise handle synchronous load
            return this._handleSyncLoad(serialized);
          } else {
            return null;
          }
        }
1054556
function(isLoaded) {
    var self = this;
    var isLoading = !isLoaded;
    var state = self.state;
    var prev = state.loadingStatus;

    isLoading = isLoading || false;
    state.loadingStatus = isLoading;

    self._notifyParentLoadingStatus(prev, !self.isLoaded());
  }
490193
function getInitialState() {
  if (!window.localStorage) {
    return undefined;
  }

  const storedState = window.localStorage.getItem(storeKey);

  if (!storedState) {
    return undefined;
  }

  const normalisedState = storedState.replace(new RegExp('"isFetching":true', 'g'), '"isFetching":false');
  return JSON.parse(normalisedState);
}
982395
public boolean load() {
        if ((lastLoaded + cacheTTLMillis) <= System.currentTimeMillis()) {
            clearCache();
        }
        if (!readCache()) {
            if (shouldReadDataFromFallback()) {
                return loadFallback();
            }
        }
        return true;
    }
737068
function() {
    var xhr = new XMLHttpRequest();
    var url = assetsBaseUrl + assetsRelativeUrl['images'];

    // @todo Remove the sync call and use a callback
    xhr.open('GET', url);

    xhr.onload = () => {
      var data = JSON.parse(xhr.responseText);
      this.images = data.images;
      this.images.forEach(image => {
        image.fullPath = assetsBaseUrl + data.basepath.images + image.path;
        image.fullThumbPath =
          assetsBaseUrl + data.basepath.images_thumbnails + image.thumbnail;
      });
      Events.emit('assetsimagesload', this.images);
    };
    xhr.onerror = () => {
      console.error('Error loading registry file.');
    };
    xhr.send();

    this.hasLoaded = true;
  }
820382
public function syncRaw()
    {
        if ($model = $this->fresh()) {
            $this->setRawAttributes($model->getAttributes());

            return true;
        }

        return false;
    }
844238
boolean isAsync() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "isAsync");
        boolean isAsync = !asyncConsumers.isEmpty() && getState() == STARTED;
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "isAsync", isAsync);
        return isAsync;
    }
1135574
public boolean syncPlugins(NewRelicCache cache)
    {
        boolean ret = true;

        if(apiClient == null)
            throw new IllegalArgumentException("null API client");

        // Get the Plugins configuration using the REST API
        if(cache.isPluginsEnabled())
        {
            ret = false;

            logger.info("Getting the plugins");
            Collection<Plugin> plugins = apiClient.plugins().list(true);
            for(Plugin plugin : plugins)
            {
                cache.plugins().add(plugin);

                logger.fine("Getting the components for plugin: "+plugin.getId());
                Collection<PluginComponent> components = apiClient.pluginComponents().list(PluginComponentService.filters().pluginId(plugin.getId()).build());
                cache.plugins().components(plugin.getId()).add(components);
            }

            cache.setUpdatedAt();

            ret = true;
        }

        return ret;
    }
937986
function forceSync() {
  var donePromise = mediator.promise(resultSyncSubscribers.getTopic(CONSTANTS.TOPICS.FORCE_SYNC, CONSTANTS.DONE_PREFIX));

  var errorPromise = mediator.promise(resultSyncSubscribers.getTopic(CONSTANTS.TOPICS.FORCE_SYNC, CONSTANTS.ERROR_PREFIX));

  mediator.publish(resultSyncSubscribers.getTopic(CONSTANTS.TOPICS.FORCE_SYNC));

  return getTopicPromises(donePromise, errorPromise);
}
1147941
public synchronized boolean sync() {
		if (!validState) {
			throw new InvalidStateException();
		}
		try {
			fc.force(false);
			return true;
		} catch (Exception e) {
			log.error("Exception in sync()", e);
		}
		return false;
	}
1334053
function () {
            /*  special case: just retrieve current state  */
            var state_old = _cs.states[this.__state].state;
            if (arguments.length === 0)
                return state_old;

            /*  determine parameters  */
            var params = $cs.params("state", arguments, {
                state:    { pos: 0, req: true,
                            valid: function (s) { return _cs.state_name2idx(s) !== -1; } },
                func:     { pos: 1, def: undefined },
                min:      {         def: undefined },
                max:      {         def: undefined },
                sync:     {         def: false     }
            });

            /*  if requested state is still not reached...  */
            var sOld = this.__state;
            var sNew = _cs.state_name2idx(params.state);
            if (   ( params.min === true && !params.max          && sNew  >  sOld)
                || (!params.min          &&  params.max === true && sNew  <  sOld)
                || ( params.min === true &&  params.max === true && sNew !== sOld)
                || (!params.min          && !params.max          && sNew !== sOld)) {
                var enqueue = true;
                var cid     = this.id();
                var request = {
                    comp:     this,
                    state:    params.state
                };

                /*  handle the params.func callback using await  */
                if (typeof params.func === "function" && _cs.states.length > 1) {
                    this.await({
                        state:     params.state,
                        direction: (sNew > sOld ? "upward" : "downward"),
                        func:      params.func,
                        spool:     _cs.states[1].state /* the first state after "dead" */
                    });
                }
                if (params.sync) {
                    /*  perform new state transition request (synchronously)  */
                    if (_cs.state_progression_single(request))
                        enqueue = false;

                    /*  delete any old transition request  */
                    if (_cs.state_requests[cid])
                        delete _cs.state_requests[cid];
                }
                if (enqueue) {
                    /*  enqueue new state transition request and trigger
                        state transition progression (asynchronously)  */
                    _cs.state_requests[cid] = request;
                    _cs.hook("ComponentJS:state-invalidate", "none", "requests");
                    _cs.state_progression();
                }
            }
            else {
                /*  still run its optional callback function  */
                if (typeof params.func === "function")
                    params.func.call(this, params.state);
            }

            /*  return old (and perhaps still current) state  */
            return state_old;
        }