vendor/friendsofsymfony/elastica-bundle/Provider/AbstractProvider.php line 8

Open in your IDE?
  1. <?php
  3. namespace FOS\ElasticaBundle\Provider;
  5. use FOS\ElasticaBundle\Persister\ObjectPersisterInterface;
  6. use Symfony\Component\OptionsResolver\OptionsResolver;
  8. @trigger_error(sprintf('The %s class is deprecated since version 4.1 and will be removed in 5.0.', AbstractProvider::class), E_USER_DEPRECATED);
  10. /**
  11.  * @deprecated since 4.1 will be removed in 5.x. Use PagerProvider instead
  12.  * 
  13.  * AbstractProvider.
  14.  */
  15. abstract class AbstractProvider implements ProviderInterface
  16. {
  17.     /**
  18.      * @var array
  19.      */
  20.     protected $baseOptions;
  22.     /**
  23.      * @var string
  24.      */
  25.     protected $objectClass;
  27.     /**
  28.      * @var ObjectPersisterInterface
  29.      */
  30.     protected $objectPersister;
  32.     /**
  33.      * @var OptionsResolver
  34.      */
  35.     protected $resolver;
  37.     /**
  38.      * @var IndexableInterface
  39.      */
  40.     private $indexable;
  42.     /**
  43.      * Constructor.
  44.      *
  45.      * @param ObjectPersisterInterface $objectPersister
  46.      * @param IndexableInterface       $indexable
  47.      * @param string                   $objectClass
  48.      * @param array                    $baseOptions
  49.      */
  50.     public function __construct(
  51.         ObjectPersisterInterface $objectPersister,
  52.         IndexableInterface $indexable,
  53.         $objectClass,
  54.         array $baseOptions = array()
  55.     ) {
  56.         $this->baseOptions = $baseOptions;
  57.         $this->indexable = $indexable;
  58.         $this->objectClass = $objectClass;
  59.         $this->objectPersister = $objectPersister;
  60.         $this->resolver = new OptionsResolver();
  61.         $this->configureOptions();
  62.     }
  64.     /**
  65.      * {@inheritDoc}
  66.      */
  67.     public function populate(\Closure $loggerClosure = null, array $options = array())
  68.     {
  69.         $options = $this->resolveOptions($options);
  71.         $logger = !$options['debug_logging'] ?
  72.             $this->disableLogging() :
  73.             null;
  75.         $this->doPopulate($options, $loggerClosure);
  77.         if (null !== $logger) {
  78.             $this->enableLogging($logger);
  79.         }
  80.     }
  82.     /**
  83.      * Disables logging and returns the logger that was previously set.
  84.      *
  85.      * @return mixed
  86.      */
  87.     abstract protected function disableLogging();
  89.     /**
  90.      * Perform actual population.
  91.      *
  92.      * @param array $options
  93.      * @param \Closure $loggerClosure
  94.      */
  95.     abstract protected function doPopulate($options, \Closure $loggerClosure = null);
  97.     /**
  98.      * Reenables the logger with the previously returned logger from disableLogging();.
  99.      *
  100.      * @param mixed $logger
  101.      *
  102.      * @return mixed
  103.      */
  104.     abstract protected function enableLogging($logger);
  106.     /**
  107.      * Configures the option resolver.
  108.      */
  109.     protected function configureOptions()
  110.     {
  111.         $this->resolver->setDefaults(array(
  112.             'reset' => true,
  113.             'batch_size' => 100,
  114.             'skip_indexable_check' => false,
  115.         ));
  117.         $this->resolver->setRequired(array(
  118.             'indexName',
  119.             'typeName',
  120.         ));
  121.     }
  124.     /**
  125.      * Filters objects away if they are not indexable.
  126.      *
  127.      * @param array $options
  128.      * @param array $objects
  129.      * @return array
  130.      */
  131.     protected function filterObjects(array $options, array $objects)
  132.     {
  133.         if ($options['skip_indexable_check']) {
  134.             return $objects;
  135.         }
  137.         $index = $options['indexName'];
  138.         $type = $options['typeName'];
  140.         $return = array();
  141.         foreach ($objects as $object) {
  142.             if (!$this->indexable->isObjectIndexable($index, $type, $object)) {
  143.                 continue;
  144.             }
  146.             $return[] = $object;
  147.         }
  149.         return $return;
  150.     }
  152.     /**
  153.      * Merges the base options provided by the class with options passed to the populate
  154.      * method and runs them through the resolver.
  155.      *
  156.      * @param array $options
  157.      *
  158.      * @return array
  159.      */
  160.     protected function resolveOptions(array $options)
  161.     {
  162.         return $this->resolver->resolve(array_merge($this->baseOptions, $options));
  163.     }
  164. }