Return an ownership policy that returns true for {@link ConfigurationOwnershipPolicy#has(ConfigurationKey, Map)}

@return policy
174093
public static ConfigurationOwnershipPolicy ownsAll()
    {
        return new ConfigurationOwnershipPolicy()
        {
            @Override
            public boolean has(ConfigurationKey key, Map<String, String> variables)
            {
                return true;
            }
        };
    }
237962
public java.util.Map<String, String> getPolicies() {
        if (policies == null) {
            policies = new com.amazonaws.internal.SdkInternalMap<String, String>();
        }
        return policies;
    }
1130298
public java.util.List<PolicyDescription> getPolicyDescriptions() {
        if (policyDescriptions == null) {
            policyDescriptions = new com.amazonaws.internal.SdkInternalList<PolicyDescription>();
        }
        return policyDescriptions;
    }
1101989
PolicyNode getPolicyTree() {
        if (rootNode == null)
            return null;
        else {
            PolicyNodeImpl policyTree = rootNode.copyTree();
            policyTree.setImmutable();
            return policyTree;
        }
    }
1157846
public java.lang.String getOwningGroup() {
    java.lang.Object ref = owningGroup_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      if (bs.isValidUtf8()) {
        owningGroup_ = s;
      }
      return s;
    }
  }
258775
private com.datastax.driver.core.policies.RetryPolicy getPolicy(RetryPolicy policy, Properties props)
    {
        com.datastax.driver.core.policies.RetryPolicy retryPolicy = null;

        String isLoggingRetry = (String) props.get("isLoggingRetry");

        switch (policy)
        {
        case DowngradingConsistencyRetryPolicy:
            retryPolicy = DowngradingConsistencyRetryPolicy.INSTANCE;
            break;

        case FallthroughRetryPolicy:
            retryPolicy = FallthroughRetryPolicy.INSTANCE;
            break;

        case Custom:
            retryPolicy = getCustomRetryPolicy(props);
            break;

        default:
            break;
        }

        if (retryPolicy != null && Boolean.valueOf(isLoggingRetry))
        {
            retryPolicy = new LoggingRetryPolicy(retryPolicy);
        }

        return retryPolicy;

    }
227084
public boolean containsKey(String key) {

        if (key == null) {
            throw new NullPointerException("Missing resource key.");
        }

        PropertyBundle p = this;

        do {
            String value = p.key2values.get(key);
            if (value != null) {
                return true;
            }
        } while ((p = p.parent) != null);

        return false;

    }
483226
@SuppressWarnings("unchecked")
  private boolean hasPropertiesConfiguration(Dictionary properties) {
    HashMap<Object, Object> mapProperties = new HashMap<Object, Object>(properties.size());
    for (Object key : Collections.list(properties.keys())) {
      mapProperties.put(key, properties.get(key));
    }
    mapProperties.remove(Constants.SERVICE_PID);
    mapProperties.remove("service.factoryPid");
    return !mapProperties.isEmpty();
  }
262489
private boolean checkPartitionOwner() {
        InternalPartitionServiceImpl partitionService = getService();
        PartitionStateManager partitionStateManager = partitionService.getPartitionStateManager();
        InternalPartitionImpl partition = partitionStateManager.getPartitionImpl(getPartitionId());
        PartitionReplica owner = partition.getOwnerReplicaOrNull();

        NodeEngine nodeEngine = getNodeEngine();
        if (owner == null || !owner.isIdentical(nodeEngine.getLocalMember())) {
            ILogger logger = getLogger();
            if (logger.isFinestEnabled()) {
                logger.finest("This node is not owner partition. Cannot process request. partitionId="
                        + getPartitionId() + ", replicaIndex=" + getReplicaIndex() + ", namespaces=" + namespaces);
            }
            return false;
        }
        return true;
    }
384564
public alluxio.grpc.Bits getOwnerBits() {
    alluxio.grpc.Bits result = alluxio.grpc.Bits.valueOf(ownerBits_);
    return result == null ? alluxio.grpc.Bits.NONE : result;
  }
631531
@Override
    public boolean contains(String policyName)
    throws PolicyStoreException {

        // search for policy - active and inactive
        String pid = this.getPID(policyName);

        ObjectProfile objectProfile = null;
        try {
            objectProfile =
                this.apiAService.getObjectProfile(getContext(), pid, null);
        } catch (ObjectNotInLowlevelStorageException e) {
        } catch (ServerException e) {
            throw new PolicyStoreException("Add: error getting object profile for "
                                                 + pid
                                                 + " - "
                                                 + e.getMessage(),
                                                 e);

        }

        if (objectProfile == null) {
            // no object found
            return false;
        } else {
            if (objectProfile.objectState.equals("A")
                    || objectProfile.objectState.equals("I")) {
                // active or inactive object found - policy exists
                return true;
            } else {
                // deleted object - policy does not exist
                return false;
            }
        }
    }
317338
public static Set<Policy> policies(Config config) {
    BasicSettings settings = new BasicSettings(config);
    return settings.admission().stream().map(admission ->
      new SegmentedLruPolicy(admission, config)
    ).collect(toSet());
  }
309191
def get_policy(self):
        
        if not self._policy:
            self._policy = self.policy_class(self._maps, self._clients)
        return self._policy
479581
public Map<String, Map<String, List<String>>> resourcePermissions() {
		return getEntity(invokeGet("_permissions", null), Map.class);
	}
942832
public static Set<Policy> policies(Config config) {
    CollisionSettings settings = new CollisionSettings(config);
    return settings.density()
        .map(density -> new CollisionPolicy(settings, density))
        .collect(toSet());
  }
719
public synchronized Map<String, Object> getConfiguration(String key) {
		return Optional.ofNullable(inventory.get(key))
				.flatMap(v->v.getConfiguration())
				.map(v->v.getMap())
				.orElse(null);
	}
1096099
@SuppressWarnings("unchecked")
	public static Map<String, ConfigurationKey<?>> registeredKeys() {
		synchronized (registeredKeys) {
			if (copy == null) copy = Collections.unmodifiableMap((Map<String, ConfigurationKey<?>>) registeredKeys.clone());
			return copy;
		}
	}