Returns the class name of the Value Object class associated with a given type or false if the type is unknown.

@param string $type

@return string|boolean
977447
protected function findClassNameForType($type)
    {
        $className = (isset($this->typeToValueObjectClassName[$type]))
            ? $this->typeToValueObjectClassName[$type]
            : false;

        return $className;
    }
725192
public static function GetTypeName( $value ) : string
   {

      if ( \is_null( $value ) )
      {
         return Type::PHP_NULL;
      }

      if ( \is_object( $value ) )
      {
         return \get_class( $value );
      }

      if ( \is_string( $value ) )
      {
         return Type::PHP_STRING;
      }

      if ( \is_int( $value ) )
      {
         return Type::PHP_INTEGER;
      }

      if ( \is_bool( $value ) )
      {
         return Type::PHP_BOOLEAN;
      }

      if ( \is_double( $value ) )
      {
         return Type::PHP_DOUBLE;
      }

      if ( \is_float( $value ) )
      {
         return Type::PHP_FLOAT;
      }

      if ( \is_resource( $value ) )
      {
         return Type::PHP_RESOURCE;
      }

      if ( \is_array( $value ) )
      {
         return Type::PHP_ARRAY;
      }

      return Type::PHP_UNKNOWN;

   }
469876
public function getMessageClassObject($type) {
        // Type is obligatory // TODO: Configurate obligatory?
        if ($type == null) throw new Exception("Error Type is null");

        $messageClassString = $this->getMessageClassString($type);
        if ($messageClassString == null) {
            throw new Exception("Error Type");
        }

        $messageClassObject = new $messageClassString;
        if ($messageClassObject->getMyType() == "any") {
            $messageClassObject->setAnyType($type);
            $messageClassObject->setTypeClient($type);
        }

        return $messageClassObject;
    }
354454
public static function getTypeName($type)
	{
		static $ref = [];
		
		$key = static::class;
		
		if(empty($ref[$key]))
		{
			$ref[$key] = new \ReflectionClass($key);
		}
		
		foreach($ref[$key]->getConstants() as $k => $v)
		{
			if($v === $type && strpos($k, 'T_') === 0)
			{
				return $k;
			}
		}

		return static::UNKNOWN;
	}
528208
public function getType($type)
    {
        $aliases = array(
            'int'    => 'integer',
            'bool'   => 'boolean',
            'double' => 'float',
            'object' => '\\stdClass'
        );
        $default = array(
            'integer', 'boolean', 'float', '\\stdClass', 'callable', 'string', 'resource', 'void', 'mixed'
        );
        $typeHintEnabled = false;

        if (isset($aliases[$type])) {
            $type = $aliases[$type];
        }

        if (!in_array($type, $default)) {
            $typeHintEnabled = true;
        }

        return array(
            'name' => $type,
            'hint' => $typeHintEnabled
        );
    }
1321784
public function getType($type)
    {
        if (!$this->hasType($type)) {
            $this->metaTypeList[$type] = new $type();
        }

        return $this->metaTypeList[$type];
    }
1161905
protected function classMetadataExists($type)
    {
        $className = $this->getClassNameForType($type);
        try {
            $metadata = $this->mf->getMetadataFor($className);
            return true;
        } catch (MappingException $e) {
            return false;
        }
        return false === $this->shouldFilterClassMetadata($metadata);
    }
20223
protected function getType($value)
    {
        if (is_object($value)) {
            return get_class($value);
        } elseif (is_null($value)) {
            return 'null';
        } elseif (is_string($value)) {
            return 'string';
        } elseif (is_array($value)) {
            return 'array';
        } elseif (is_int($value)) {
            return 'integer';
        } elseif (is_bool($value)) {
            return 'boolean';
        } elseif (is_float($value)) {
            return 'float';
        } elseif (is_resource($value)) {
            return 'resource';
        } else {
            return 'unknown';
        }
    }
328958
private function checkType($type)
    {
        $isInType = true;

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

        return $isInType;
    }
390931
@NullSafe
  public static String getName(Class type) {
    return type != null ? type.getName() : null;
  }
373742
public static function isKnownType(string $type): bool
    {
        return self::isInternalPhpType($type) || self::isClassType($type);
    }
818252
public function instantiate(string $type): object
    {
        if (!class_exists($type)) {
            throw new ClassNotFoundException;
        }

        $rClass = new ReflectionClass($type);
        $rConst = $rClass->getConstructor();
        if (is_null($rConst)) {
            return $rClass->newInstance();
        }

        return $rClass->newInstanceArgs($this->complete($rConst));
    }
988110
protected static function getClassName($type)
    {
        if (in_array($type, array_keys(self::$elements))) {
            $type = self::$elements[$type];
        }

        if (!class_exists($type)) {
            throw new InvalidArgumentException(
                "Input class '{$type}' does not exists."
            );
        }

        if (! is_subclass_of($type, ElementInterface::class)) {
            throw new InvalidArgumentException(
                "The class '{$type}' does not implement the " .
                "Slick\\Form\\ElementInterface interface."
            );
        }

        return $type;
    }
654385
public function get_class($type)
	{
		if (!empty($this->classes[$type]))
		{
			return $this->classes[$type];
		}
		if (!empty($this->default[$type]))
		{
			return $this->default[$type];
		}

		return null;
	}
1334826
protected function getTitle($type)
    {
        return array_key_exists($type, $this->config('titles'))
            ? $this->config('titles')[$type]
            : null;
    }
1305659
public function getNewType($type = null)
    {
        $className = $this->getTypeClass($type);
        /** @var GenericType $object */
        $object = new $className();
        $object->setManager($this);

        return $object;
    }
250534
public function getDefinition(string $type)
    {
        if (isset($this->definitions[$type])) {
            return $this->definitions[$type];
        }

        return null;
    }