Gets the configuration describing the queryable state as deactivated.
7539
public static QueryableStateConfiguration disabled() {
		final Iterator<Integer> proxyPorts = NetUtils.getPortRangeFromString(QueryableStateOptions.PROXY_PORT_RANGE.defaultValue());
		final Iterator<Integer> serverPorts = NetUtils.getPortRangeFromString(QueryableStateOptions.SERVER_PORT_RANGE.defaultValue());
		return new QueryableStateConfiguration(proxyPorts, serverPorts, 0, 0, 0, 0);
	}
925281
def deleted(self):
        
        query = queries.build_query({**self.spec,
                                     'future': False,
                                     '_deleted': True})
        return [Entry(e) for e in query]
1029086
function() {
        var deactivated = false;
        // the return from the controls is unimportant in this case
        if(OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
            this.moveLayerBack();
            this.map.events.un({
                "removelayer": this.handleMapEvents,
                "changelayer": this.handleMapEvents,
                scope: this
            });
            this.layer.removeFeatures(this.vertices, {silent: true});
            this.layer.removeFeatures(this.virtualVertices, {silent: true});
            this.vertices = [];
            this.handlers.drag.deactivate();
            this.handlers.keyboard.deactivate();
            var feature = this.feature;
            if (feature && feature.geometry && feature.layer) {
                this.unselectFeature(feature);
            }
            deactivated = true;
        }
        return deactivated;
    }
54342
void internalDeactivate ()
    {
      final String methodName = "internalDeactivate";
      if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
          SibTr.entry(this, TRACE, methodName);
      }

      synchronized (_sessionsByMeUuid) {
        _sessionsByMeUuid.clear();
      }

      super.deactivate();

      if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
        SibTr.exit(this, TRACE, methodName);
      }

    }
744677
public com.groupon.odo.proxylib.models.Method getMethodForEnabledId(int enabledId) {
        com.groupon.odo.proxylib.models.Method method = null;
        int override_id = 0;
        PreparedStatement queryStatement = null;
        ResultSet results = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            queryStatement = sqlConnection.prepareStatement(
                "SELECT * FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
                    " WHERE " + Constants.ENABLED_OVERRIDES_OVERRIDE_ID + " = ?"
            );
            queryStatement.setInt(1, enabledId);
            results = queryStatement.executeQuery();
            if (results.next()) {
                override_id = results.getInt(Constants.ENABLED_OVERRIDES_OVERRIDE_ID);

                queryStatement = sqlConnection.prepareStatement(
                    "SELECT * FROM " + Constants.DB_TABLE_OVERRIDE +
                        " WHERE " + Constants.GENERIC_ID + " = ?"
                );
                queryStatement.setInt(1, override_id);
                results = queryStatement.executeQuery();
                if (results.next()) {
                    method = new com.groupon.odo.proxylib.models.Method();
                    method.setId(override_id);
                    method.setClassName(results.getString(Constants.OVERRIDE_CLASS_NAME));
                    method.setMethodName(results.getString(Constants.OVERRIDE_METHOD_NAME));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (results != null) {
                    results.close();
                }
            } catch (Exception e) {
            }
            try {
                if (queryStatement != null) {
                    queryStatement.close();
                }
            } catch (Exception e) {
            }
        }

        // now get the rest of the data from the plugin manager
        // this gets all of the actual data
        try {
            method = PluginManager.getInstance().getMethod(method.getClassName(), method.getMethodName());
            method.setId(override_id);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return method;
    }
358333
public function account_deactivated()
    {
        $config = $this->app->make('config');
        $this->error->add(t($config->get('concrete.user.deactivation.message')));
    }
1266384
function() {
        var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
        if(deactivated) {
            this.layer.events.un({
                "moveend": this.update,
                "refresh": this.update,
                "visibilitychanged": this.update,
                scope: this
            });
        }
        return deactivated;
    }
312297
function() {
        var deactivated = false;
        if(OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
            this.clearTimer();
            this.down = null;
            this.first = null;
            this.last = null;
            deactivated = true;
        }
        return deactivated;
    }
226427
@Override
    public boolean isHAEnabled() {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "isHAEnabled");

        final boolean haEnabled = Configuration.HAEnabled();

        if (tc.isEntryEnabled())
            Tr.exit(tc, "isHAEnabled", haEnabled);
        return haEnabled;
    }
543158
def _get_enabled_disabled(enabled_prop="true"):
    '''
    
    '''
    ret = set()
    cmd = '/usr/bin/svcprop -c -p general/enabled "*"'
    lines = __salt__['cmd.run_stdout'](cmd, python_shell=False).splitlines()
    for line in lines:
        comps = line.split()
        if not comps:
            continue
        if comps[2] == enabled_prop:
            ret.add(comps[0].split("/:properties")[0])
    return sorted(ret)
1148788
function isEnabled() {
  const key = '@key@';
  const value = '1';
  const re = new RegExp(`(?:^|; )${key}=${value}(?:;|$)`);

  document.cookie = `${key}=${value}`;

  const enabled = re.test(document.cookie);

  if (enabled) {
    // eslint-disable-next-line
    remove(key);
  }

  return enabled;
}
1128770
def get_admin_enforcement(self):
        
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.protection_url + "/enforce_admins"
        )
        return data["enabled"]
888039
private boolean checkEnabled() {
        /* Enable this analyzer ONLY if the Nexus URL has been set to something
         other than the default one (if it's the default one, we'll use the
         central one) and it's enabled by the user.
         */
        boolean retval = false;
        try {
            if (!DEFAULT_URL.equals(getSettings().getString(Settings.KEYS.ANALYZER_NEXUS_URL))
                    && getSettings().getBoolean(Settings.KEYS.ANALYZER_NEXUS_ENABLED)) {
                LOGGER.info("Enabling Nexus analyzer");
                retval = true;
            } else {
                LOGGER.debug("Nexus analyzer disabled, using Central instead");
            }
        } catch (InvalidSettingException ise) {
            LOGGER.warn("Invalid setting. Disabling Nexus analyzer");
        }

        return retval;
    }
1243412
function() {
        this.cache = null;
        if (this.layer && this.layer.events) {
            this.layer.events.un({
                "beforefeaturesadded": this.handleAdd,
                "beforefeaturesremoved": this.handleRemove,
                scope: this
            });            
        }
        return OpenLayers.Strategy.prototype.deactivate.apply(this, arguments);
    }
476651
public static function getUndeletedStates()
    {
        return array(
            Page::STATE_OFFLINE,
            Page::STATE_ONLINE,
            Page::STATE_HIDDEN,
            Page::STATE_ONLINE + Page::STATE_HIDDEN,
        );
    }
409541
function() {
        var deactivated = false;
        if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
            for (var i=0, len=this.KEY_EVENTS.length; i<len; i++) {
                OpenLayers.Event.stopObserving(
                    this.observeElement, this.KEY_EVENTS[i], this.eventListener);
            }
            deactivated = true;
        }
        return deactivated;
    }
236851
public boolean getWhoCardRequestEnabled() {
		InteractionConfiguration configuration = getConfiguration();
		if (configuration == null) {
			return false;
		}
		JSONObject profile = configuration.optJSONObject(KEY_PROFILE);
		return profile.optBoolean(KEY_PROFILE_REQUEST, true);
	}