PHP ClassLoader::classExists方法代码示例

 /**
  * Create a new pagetype
  */
 public function actionNew()
 {
     $form = new \Foundation\Form();
     $form->setCSRFToken($this->getCSRFToken());
     $form->setAction($this->path("manage/elementtypes/new"));
     $field = $form->newField();
     $field->setLegend('New element type');
     $element = $field->newElement('TextInput', 'name');
     $element->setLabel('Name');
     $element->addValidator(new \Foundation\Form\Validator\NotEmpty($element));
     $element->addFilter(new \Foundation\Form\Filter\Safe($element));
     $element = $field->newElement('TextInput', 'class');
     $element->setLabel('Class');
     $element->addValidator(new \Foundation\Form\Validator\NotEmpty($element));
     $form->newButton('submit', 'Add Element');
     $this->setVar('form', $form);
     if ($input = $form->processInput($this->post)) {
         //class_exists causes doctrine to try and load the class which fails so we look first if doctrine can load it and then
         //if that fails we use class exists with no auto_load so it just looks in existing includes
         if (\Doctrine\Common\ClassLoader::classExists(ltrim($input->get('class'), '\\')) or class_exists($input->get('class'), false)) {
             $elementType = new \Jazzee\Entity\ElementType();
             $elementType->setName($input->get('name'));
             $elementType->setClass($input->get('class'));
             $this->addMessage('success', $input->get('name') . " saved.");
             $this->_em->persist($elementType);
             $this->redirectPath('manage/elementtypes');
         } else {
             $this->addMessage('error', "That is not a valid class name.  The class must eithier by loadable by a Doctrine::classLoader registered in the autoload stack or already be included.");
         }
     }
 }

 public function testClassExists()
 {
     $this->assertFalse(ClassLoader::classExists('ClassLoaderTest\\ClassD'));
     $badLoader = function ($className) {
         require __DIR__ . '/ClassLoaderTest/ClassD.php';
         return true;
     };
     spl_autoload_register($badLoader);
     $this->assertTrue(ClassLoader::classExists('ClassLoaderTest\\ClassD'));
     spl_autoload_unregister($badLoader);
 }

 public function testClassExistsWhenLoaderIsProtected()
 {
     require_once __DIR__ . '/ClassLoaderTest/ExternalLoader.php';
     // Test static call
     \ClassLoaderTest\ExternalLoader::registerStatic();
     $this->assertFalse(ClassLoader::classExists('ClassLoaderTest\\Class\\That\\Does\\Not\\Exist'));
     \ClassLoaderTest\ExternalLoader::unregisterStatic();
     // Test object
     $loader = new \ClassLoaderTest\ExternalLoader();
     $loader->register();
     $this->assertFalse(ClassLoader::classExists('ClassLoaderTest\\Class\\That\\Does\\Not\\Exist'));
     $loader->unregister();
 }

 public function testClassExistsWithSilentAutoloader()
 {
     $test = $this;
     $silentLoader = function ($className) use($test) {
         $test->assertSame('ClassLoaderTest\\ClassE', $className);
         require __DIR__ . '/ClassLoaderTest/ClassE.php';
     };
     $additionalLoader = function () use($test) {
         $test->fail('Should not call this loader, class was already loaded');
     };
     $this->assertFalse(ClassLoader::classExists('ClassLoaderTest\\ClassE'));
     spl_autoload_register($silentLoader);
     spl_autoload_register($additionalLoader);
     $this->assertTrue(ClassLoader::classExists('ClassLoaderTest\\ClassE'));
     spl_autoload_unregister($additionalLoader);
     spl_autoload_unregister($silentLoader);
 }

 /**
  * Finalize the mapping and make sure that it is consistent.
  *
  * @throws MappingException if inconsistencies are discovered.
  */
 public function validateClassMapping()
 {
     // associative array fields need a separate property to store the keys.
     // make sure that generated or specified name does not collide with an
     // existing mapping.
     $assocFields = array();
     foreach ($this->fieldMappings as $fieldName) {
         $mapping = $this->mappings[$fieldName];
         if (empty($mapping['assoc'])) {
             continue;
         }
         if (isset($this->mappings[$mapping['assoc']])) {
             throw MappingException::assocOverlappingFieldDefinition($this->name, $fieldName, $mapping['assoc']);
         }
         if (!empty($assocFields[$mapping['assoc']])) {
             throw MappingException::assocOverlappingAssocDefinition($this->name, $fieldName, $assocFields[$mapping['assoc']]);
         }
         $assocFields[$mapping['assoc']] = $fieldName;
     }
     if (!empty($this->versionNameField) && !$this->versionable) {
         throw new MappingException(sprintf("You cannot use the @VersionName annotation on the non-versionable document %s (field = %s)", $this->name, $this->versionNameField));
     }
     if (!empty($this->versionCreatedField) && !$this->versionable) {
         throw new MappingException(sprintf("You cannot use the @VersionCreated annotation on the non-versionable document %s (field = %s)", $this->name, $this->versionCreatedField));
     }
     if (count($this->translatableFields)) {
         if (!isset($this->localeMapping)) {
             throw new MappingException("You must define a locale mapping for translatable document '" . $this->name . "'");
         }
     }
     // we allow mixed referrers on non-referenceable documents. maybe the mix:referenceable is just not mapped
     if (count($this->referrersMappings)) {
         if (!$this->referenceable) {
             throw new MappingException('You can not have referrers mapped on document "' . $this->name . '" as the document is not referenceable');
         }
         foreach ($this->referrersMappings as $referrerName) {
             $mapping = $this->mappings[$referrerName];
             // only a santiy check with reflection. otherwise we could run into endless loops
             if (!ClassLoader::classExists($mapping['referringDocument'])) {
                 throw new MappingException(sprintf('Invalid referrer mapping on document "%s" for field "%s": The referringDocument class "%s" does not exist', $this->name, $mapping['fieldName'], $mapping['referringDocument']));
             }
             $reflection = new ReflectionClass($mapping['referringDocument']);
             if (!$reflection->hasProperty($mapping['referencedBy'])) {
                 throw new MappingException(sprintf('Invalid referrer mapping on document "%s" for field "%s": The referringDocument "%s" has no property "%s"', $this->name, $mapping['fieldName'], $mapping['referringDocument'], $mapping['referencedBy']));
             }
         }
     }
     $this->validateIdentifier();
 }

 /**
  * Validate association targets actually exist.
  *
  * @throws MappingException
  * @return void
  */
 public function validateAssocations()
 {
     foreach ($this->associationMappings as $mapping) {
         if (!ClassLoader::classExists($mapping['targetEntity'])) {
             throw MappingException::invalidTargetEntityClass($mapping['targetEntity'], $this->name, $mapping['fieldName']);
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function submitForm(array &$form, FormStateInterface $form_state)
 {
     $pdf_tool = $this->config('printable.settings')->get('pdf_tool');
     \Drupal::service('config.factory')->getEditable('printable.settings')->set('pdf_tool', $form_state->getValue('print_pdf_pdf_tool'))->set('save_pdf', $form_state->getValue('print_pdf_content_disposition'))->set('paper_size', (string) $form_state->getValue('print_pdf_paper_size'))->set('page_orientation', $form_state->getValue('print_pdf_page_orientation'))->set('pdf_location', $form_state->getValue('print_pdf_filename'))->save();
     if (ClassLoader::classExists('mikehaertl\\wkhtmlto\\Pdf') && $pdf_tool == 'wkhtmltopdf') {
         \Drupal::service('config.factory')->getEditable('printable.settings')->set('path_to_binary', $form_state->getValue('path_to_binary'))->save();
     }
 }

 /**
  * Create a new pagetype
  */
 public function actionNew()
 {
     $form = new \Foundation\Form();
     $form->setCSRFToken($this->getCSRFToken());
     $form->setAction($this->path("manage/paymenttypes/new"));
     $field = $form->newField();
     $element = $field->newElement('TextInput', 'className');
     $element->setLabel('Class');
     $element->addValidator(new \Foundation\Form\Validator\NotEmpty($element));
     $form->newButton('submit', 'Next');
     if (isset($this->post['className'])) {
         $className = $this->post['className'];
         if (!isset($this->post['newtypeform'])) {
             $this->post = array();
             //reset $_POST so we don't try and validate the empty form
         }
         //class_exists causes doctrine to try and load the class which fails so we look first if doctrine can load it and then
         //if that fails we use class exists with no auto_load so it just looks in existing includes
         if (\Doctrine\Common\ClassLoader::classExists(ltrim($className, '\\')) or class_exists($className, false)) {
             $paymentType = new \Jazzee\Entity\PaymentType();
             $paymentClass = new $className($paymentType, $this);
             $form = $paymentClass->getSetupForm();
             $form->setAction($this->path("manage/paymenttypes/new"));
             $form->newHiddenElement('className', $className);
             $form->newHiddenElement('newtypeform', true);
         } else {
             $form->getElementByName('className')->addMessage('That is not a valid class name.  The class must eithier by loadable by a Doctrine::classLoader in the autoload stack or already be included.');
         }
     }
     $this->setVar('form', $form);
     if ($input = $form->processInput($this->post)) {
         if ($input->get('newtypeform')) {
             if ($this->_em->getRepository('Jazzee\\Entity\\PaymentType')->findBy(array('name' => $input->get('name')))) {
                 $form->getElementByName('name')->addMessage('That payment name has already been used.');
                 return false;
             }
             $paymentClass->setup($input);
             $this->_em->persist($paymentType);
             foreach ($paymentType->getVariables() as $var) {
                 $this->_em->persist($var);
             }
             $this->addMessage('success', $input->get('name') . ' saved.');
             $this->redirectPath('manage/paymenttypes');
         }
     }
 }