Check if name is not snake case.

@param string $name
@param string $definedClass
@return boolean
2238
public function validateName($name, $definedClass)
    {
        if ($name != camel_case($name)) {
            throw new Exception('Name "'.$name.'" (defined in class "'.$definedClass.'") is not a camel case name.');
        }

        return true;
    }
1114075
public function hasClass(string $class): bool {
        return (bool)$this->collection()->reduce(function($carry, $node) use ($class) {
            $attr = $node->getAttr('class');

            return array_reduce(explode(' ', (string)$attr), function($carry, $item) use ($class) {
                if (strcasecmp($item, $class) == 0) {
                    return true;
                }

                return $carry;
            }, false);
        }, false);
    }
736225
protected function isFacade(string $namespace, string $name): bool
    {
        if (preg_match('/^Spryker[a-zA-Z]*\\\\Zed\\\\[a-zA-Z]+\\\\Business$/', $namespace) && preg_match('/^(.*?)(Facade|FacadeInterface)$/', $name)) {
            return true;
        }

        return false;
    }
258491
public function __isset($name)
    {
        $name = Type::snake_case($name);
        return isset($this->constraints[$name]);
    }
257413
boolean isAccepted(final String name) {
        for (String str : charsets) {
            if (str.equalsIgnoreCase(name)) {
                return true;
            }
        }
        return false;
    }
293882
public function has(string $name): bool
    {
        try {
            $this->dotGet($name);
        } catch (DotNotFoundException $e) {
            return false;
        }

        return true;
    }
163671
private function isValidWidgetClass($className)
    {
        //====================================================================//
        // Safety Check => Widget Type is String
        if (!is_string($className)) {
            return "Widget Type is Not a String";
        }
        //====================================================================//
        // Safety Check => Class Exists
        if (!class_exists($className)) {
            return "Widget Class Not Found";
        }
        //====================================================================//
        // Safety Check => Class Extends
        if (!is_subclass_of($className, AbstractWidget::class)) {
            return "Widget Class MUST extends ".AbstractWidget::class;
        }

        return true;
    }
1095502
public function hasProperty($name)
    {
        if (isset($this->properties[$name])) {
            return true;
        } else {
            $extendsClassDefinition = $this->getExtendsClassDefinition();
            if ($extendsClassDefinition) {
                if ($extendsClassDefinition->hasProperty($name)) {
                    return true;
                }
            }

            return false;
        }
    }
528257
private function isIgnoredAnnotation($name)
    {
        if ($this->ignoreNotImportedAnnotations || isset($this->ignoredAnnotationNames[$name])) {
            return true;
        }

        foreach (array_keys($this->ignoredAnnotationNamespaces) as $ignoredAnnotationNamespace) {
            $ignoredAnnotationNamespace = rtrim($ignoredAnnotationNamespace, '\\') . '\\';

            if (0 === stripos(rtrim($name, '\\') . '\\', $ignoredAnnotationNamespace)) {
                return true;
            }
        }

        return false;
    }
410797
public function hasValidator(string $name): bool
    {
        return isset($this->builtinValidators[$name]) ||
               isset($this->customValidators[$name]) ||
               isset($this->validators[$name]);
    }
329331
public function has($name)
    {
        if (! is_string($name)) {
            throw new InvalidArgumentException(sprintf(
                'The name parameter must be of type string, %s given',
                is_object($name) ? get_class($name) : gettype($name)
            ));
        }

        return array_key_exists($name, static::$_singletonEntries) ||
            $this->_definitionManager->has($name);

    }
21236
private boolean isKnownException(@SlashedClassName String clsName) {
        for (String exceptionCls : knownExceptions) {
            if (clsName.startsWith(exceptionCls)) {
                return true;
            }
        }

        return false;
    }
990059
protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = getClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }
17565
public function __isset($name) {
        if (array_key_exists($name, self::$coursecatfields)) {
            return isset($this->$name);
        }
        return false;
    }
1200162
private boolean isAssociatedClass(@DottedClassName String calledClass) {
        if (calledClass.equals(parentClassName)) {
            return true;
        }

        if (calledClass.length() <= clsName.length()) {
            return false;
        }
        int innerMarkPos = calledClass.indexOf('$', clsName.length());
        if (innerMarkPos < 0) {
            innerMarkPos = calledClass.indexOf('.', clsName.length());
            if (innerMarkPos < 0) {
                return false;
            }
        }

        String topClass = calledClass.substring(0, innerMarkPos);
        return topClass.equals(clsName) || calledClass.substring(innerMarkPos + 1).startsWith("access");
    }
795057
private function isValidShortClassName(string $name): bool
    {
        return empty($name) === false && preg_match(static::VALID_CLASS_NAME_REGEX, $name) === 1;
    }
843882
protected function checkValidTypeName($name)
    {
        if (in_array($name, ['Abstract', 'AbstractType', 'Generic'])) {
            return false;
        }
        if (
            strpos($name, '\AbstractType') !== false ||
            strpos($name, '/AbstractType') !== false
        ) {
            return false;
        }
        if (strpos($name, 'Trait') !== false) {
            return false;
        }

        return true;
    }