See if an schema element exists

@param string $type Type of name, see get()
@param string $name Name or OID

@return boolean
333287
public function exists($type, $name)
    {
        $entry = $this->get($type, $name);
        if ($entry instanceof Net_LDAP2_ERROR) {
                return false;
        } else {
            return true;
        }
    }
725778
public function check(string $type, string $context): bool
    {
        /** @var DataSource $dataSource */
        $dataSource = $this->dataSourceRepository->findOneBy(['name' => $type]);
        if (!$dataSource) {
            // unknown data source
            return false;
        }

        if (!in_array($context, $dataSource->getContext())) {
            return false;
        }

        return true;
    }
1012016
public function searchByNameAndType($name = null, $type = null)
    {
        $searchResult = $this->getRequest()->request(
            'POST',
            $this->getRequestUrl('models/searches'),
            [
                'model_query' => [
                    'name' => $name,
                    'type' => $type,
                ],

            ]
        );

        return $this->getModelsFromResult($searchResult);
    }
140841
public static function findByNameType( $name, $type, $config = [] ) {

		return self::queryByNameType( $name, $type, $config )->all();
	}
306893
protected function hasQueryBuilderMethod(string $name) : bool
    {
        if (method_exists($this->queryBuilder, $name)) {
            return true;
        }

        if (method_exists($this->queryBuilder, 'hasMacro') && $this->queryBuilder->hasMacro($name)) {
            return true;
        }

        return false;
    }
1279590
public static function isExistByNameType( $modelId, $name, $type ) {

		$meta = self::findByNameType( $modelId, $type, $name );

		return isset( $meta );
	}
1138745
public function getCheck($name)
    {
        if (!$this->hasCheck($name)) {
            throw SchemaException::tableCheckDoesNotExist($this->getName(), $name);
        }

        return $this->checks[$name];
    }
711004
public function exists($name)
    {
        return ($this->basic->exists($name) || $this->dynamic->exists($name));
    }
1292091
public function hasField($name)
    {
        if ($name instanceof Field) {
            return $name;
        }

        $f_object = $this->hasElement($name);
        if (!$f_object || !$f_object instanceof Field) {
            return false;
        }

        return $f_object;
    }
729266
public function object_exists( $name ) {
		
		$this->object = $this->bucket->object( $name );
		return $this->object->exists();
		
	}
379621
public static function isExistByNameType( $parentId, $parentType, $name, $type, $config = [] ) {

		$meta = self::queryByNameType( $parentId, $parentType, $name, $type, $config )->one();

		return isset( $meta );
	}
680400
public function getQuery(string $name, string $type = null, $default = null)
    {
        $value = $this->getUserData($this->uri->getQueries(), $name);

        if ($type) {
            $value = $this->validateType($value, $type, $default);
        }

        return $value;
    }
328958
private function checkType($type)
    {
        $isInType = true;

        foreach ($this->getKeys() as $key) {
            if (gettype($key) !== $type) {
                $isInType = false;
                break;
            }
        }

        return $isInType;
    }
828109
public static function checkSchemaType($type)
    {
        if (isset(self::$_schemaTypes[$type])) {
            return self::$_schemaTypes[$type];
        } else {
            return false;
        }
    }
28815
public function exists(string $name): bool
    {
        if (isset($this->cache[$name])) {
            return true;
        }

        try {
            $this->findTemplate($name);
        } catch (\InvalidArgumentException $e) {
            return false;
        }

        return true;
    }
153935
public function has(string $name) : bool
    {
        if (Arr::keyExists($this->registry, $name)) {
            return true;
        } else {
            return false;
        }
    }
29070
public static function getSchema($name) {
        if (!isset(self::$schemas[$name])) {
            try {
                self::$schemas[$name] = Schema::i($name);
            } catch (Exception $e) {
                return false;
            }
        }

        return self::$schemas[$name];
    }