Returns true if all keys are unique
177034
def all_unique(keys, axis=semantics.axis_default):
    """"""
    index = as_index(keys, axis)
    return index.groups == index.size
499423
private boolean isReadOnlyKey(Collection.Key key) {

	return (key.equals(KeyConstants._java) || key.equals(KeyConstants._separator) || key.equals(KeyConstants._os) || key.equals(KeyConstants._coldfusion)
		|| key.equals(KeyConstants._lucee));
    }
165895
public function has($key)
    {
        $keys = is_array($key) ? $key : func_get_args();

        $input = $this->all();

        foreach ($keys as $value) {
            if (! Arr::has($input, $value)) {
                return false;
            }
        }

        return true;
    }
789881
function allUnique(arr) {
    var hash = {},
        index,
        len;

    for (index = 0, len = arr.length; index < len; index++) {
        if (hash[arr[index]]) {
            return false;
        }
        hash[arr[index]] = true;
    }
    return true;
}
933508
def is_unique(self):
        """"""
        if self._is_unique is None:
            t = self.values[:-1] == self.values[1:]  # type: np.ndarray
            self._is_unique = ~np.any(t)
        return self._is_unique
126775
function hasKeys(obj) {
		return (!Array.isArray(obj) && _.isObject(obj) && _.keys(obj).length > 0);
	}
989633
public static function isApiKeyUnique($key)
    {
        $model = static::whereApiKey($key)->first(['id']);

        return (empty($model)) ? true : false;
    }
653898
function haveDifferentKeys(object1, object2) {
  var keys1 = Object.keys(object1);
  var keys2 = Object.keys(object2);

  if (keys1.length !== keys2.length) {
    return true;
  }

  return !keys1.every(function existsInKeys2 (key) {
    return keys2.indexOf(key) !== -1;
  });
}
953258
def all_equal(keys, axis=semantics.axis_default):
    """"""
    index = as_index(keys, axis)
    return index.groups == 1
111424
protected boolean hasKey() {
        boolean result = false;
        String requestURI = this.request.getUri();
        parseKeys(requestURI);

        if(this.parsedKeys != null) {
            result = true;
        } else {
            logger.error("Error when validating request. No key specified.");
            RestErrorHandler.writeErrorResponse(this.messageEvent,
                                                HttpResponseStatus.BAD_REQUEST,
                                                "Error: No key specified !");
        }
        return result;
    }
1217540
function unique( field ) {
   const seen = {};
   const id = field ? value => value[ field ] : value => value;

   return value => {
      const key = id( value );
      if( seen[ key ] ) {
         return false;
      }
      seen[ key ] = true;
      return true;
   };
}
485592
def are_stringable_keys(self, m):
        
        for x in m.keys():
            if len(self.handlers[x].tag(x)) != 1:
                return False
        return True
225492
def has_key(self, key):
        
        if key in self._dict:
            try: 
                self[key]
                return True
            except ValueError:
                return False
            except KeyError:
                return False
        return False
120832
def unique(values):
    '''
    
    '''
    ret = None
    if isinstance(values, collections.Hashable):
        ret = set(values)
    else:
        ret = []
        for value in values:
            if value not in ret:
                ret.append(value)
    return ret
214477
protected function allValuesUnique()
    {
        // Init some vars.
        $environment     = $this->getEnvironment();
        $translator      = $environment->getTranslator();
        $dataProvider    = $environment->getDataProvider($this->model->getProviderName());
        $editInformation = $GLOBALS['container']['dc-general.edit-information'];

        // Run each and check the unique flag.
        foreach ($this->getDataDefinition()->getPropertiesDefinition()->getPropertyNames() as $propertyName) {
            $definition = $this->getDataDefinition()->getPropertiesDefinition()->getProperty($propertyName);
            $extra      = $definition->getExtra();
            $value      = $this->model->getProperty($propertyName);

            // Check the flag and the value.
            if (('' !== $value) && $extra['unique'] && isset($extra['unique'])) {
                // Check the database. If return true the value is already in the database.
                if (!$dataProvider->isUniqueValue($propertyName, $value, $this->model->getId())) {
                    $editInformation->setModelError(
                        $this->model,
                        [$translator->translate('not_unique', 'MSC', [$propertyName])],
                        $definition
                    );

                    return false;
                }
            }
        }

        return true;
    }
566978
public boolean containsKey(Object key) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);
        while (true) {
            Object item = tab[i];
            if (item == k)
                return true;
            if (item == null)
                return false;
            i = nextKeyIndex(i, len);
        }
    }
193629
public function has_all(array $keys) {
        foreach ($keys as $key) {
            if (!$this->has($key)) {
                return false;
            }
        }
        return true;
    }