Checks if item is associative array type.

@param mixed $item

@return bool
501728
private function isAssocArray($item): bool
    {
        if (!is_array($item)) {
            // Is not an array at all
            return false;
        }

        if ($item === []) {
            // Treat empty array as Sequential
            return false;
        }

        // Check if keys are equal to sequence of 0 .. n-1
        return array_keys($item) !== range(0, count($item) - 1);
    }
1074228
public function getItem($item)
	{
		return isset($this->items[$item]) ? $this->items[$item] : false;
	}
1124795
public function isArray($item=null) {
    list($item) = self::_wrapArgs(func_get_args(), 1);
    return self::_wrap(is_array($item));
  }
1331251
public function isEmpty($item=null) {
    list($item) = self::_wrapArgs(func_get_args(), 1);
    
    return self::_wrap(is_array($item) || is_object($item)) ? !((bool) count((array) $item)) : (!(bool) $item);
  }
1044401
public function equal($item)
    {
        if ($item instanceof static) {
            $v = $this->tableName == $item->tableName;
            return
                $this->tableName == $item->tableName &&
                $this->parentAlias == $item->parentAlias &&
                get_class($this->joinField) === get_class($item->joinField);
        }

        return false;
    }
165048
public function contains( $item ) {
			
			for ( $i=0; $i < $this->len; $i++ ) {
			
				if ( $this->compare( $item, $this->items[$i] ) === 0 ) {
			
					return true;
			
				}
			
			}

			return false;
		}
146213
public function isSortable(array $item)
    {
        $config = Config::createField($item);

        return $config->getSortField() ? true : false;
    }
807195
public function isSatisfiedBy($item): bool
    {
        if (!$item instanceof Content) {
            throw new InvalidArgumentException($item, sprintf('Must be instance of %s', Content::class));
        }

        $relations = $this->contentService->loadRelations($item->versionInfo);

        foreach ($relations as $relation) {
            if (Relation::ASSET === $relation->type) {
                $relationsFromAssetSide = $this->contentService->loadReverseRelations($relation->destinationContentInfo);

                if (count($relationsFromAssetSide) > 1) {
                    return false;
                }
            }
        }

        return true;
    }
224974
function has($item) {
        $hash = call_user_func($this->hashFunction, $item);

        assert(is_scalar($hash));

        return array_key_exists($hash, $this->objects);

    }
182608
public function isChildOf(Geo $item){
        return ($this->left > $item->left) && ($this->right < $item->right) && ($this->depth == $item->depth+1);
    }
184795
public function isValid($item)
    {
        if (!$item) {
            $item = new \stdClass();
        }
        $validator = $this->getValidator();

        return $validator->validate($item);
    }
406788
public static function activateIfItemIsActive($item)
    {
        // No menu items provided.
        if (empty($list = $item->getActiveIfItemIsActiveOption())) {
            return false;
        }

        // Only a string value has been provided.
        if (!is_array($list)) {
            $list = [$list];
        }

        // Move all local menu items to a self key.
        // We can have another navigation menu list provided.
        $list['self'] = [];
        foreach ($list as $key => $value) {
            if (is_int($key)) {
                $list['self'][] = $value;
                unset($list[$key]);
            }
        }

        // Check until we find an active menu item.
        foreach ($list as $menu_name => $items) {
            // Check this navigation menu (self), or access the provided navigation menu.
            $menu = $menu_name == 'self' ? $item->getMenu() : app('Nav')->menu($menu_name);

            if (!is_iterable($items)) {
                continue;
            }

            // Check each item.
            foreach ($items as $nickname) {
                // Get the menu item for this nickname.
                $check_item = $menu->get($nickname);

                // Item exists, get it to check if it is active, and then,
                // if active, set this current item active.
                if (!is_null($check_item) && $check_item->checkActive(false) && $check_item->getActive()) {
                    $item->setActive();

                    return true;
                }
            }
        }

        return false;
    }
235934
protected function isCorrectType($item)
    {
        if (is_null($this->type)) {
            return true;
        }

        if ($this->type !== 'object' && is_object($item)) {
            return $item instanceof $this->type;
        }

        return gettype($item) === $this->type;
    }
1152589
private static function isValidArrayItem(Expr $item)
    {
        $value = ($item instanceof ArrayItem) ? $item->value : $item;

        while ($value instanceof ArrayDimFetch || $value instanceof PropertyFetch) {
            $value = $value->var;
        }

        // We just kind of give up if it's a method call. We can't tell if it's
        // valid via static analysis.
        return $value instanceof Variable || $value instanceof MethodCall || $value instanceof FuncCall;
    }
1089663
protected function itemToArray($item)
    {
        if (is_array($item)) {
            return $item;
        } elseif (method_exists($item, 'toArray')) {
            return $item->toArray();
        } elseif (method_exists($item, 'getArrayCopy')) {
            return $item->getArrayCopy();
        }

        throw new Exception\RuntimeException(sprintf(
            'Items as part of this DataSource, with type "%s" cannot be cast to an array',
            is_object($item) ? get_class($item) : gettype($item)
        ));
    }
1144301
public function isYamlFile($item)
    {
        return
            $this->isFile($item) && (
                ends_with(strtolower($item), '.yml') ||
                ends_with(strtolower($item), '.yaml')
            );
    }
1089957
public function remove($item)
    {
        $key = $item instanceof Item ? $item->name : $item;

        if ($this->has($key)) {
            $this->forget($key);
            return true;
        }

        return false;
    }