vendor/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/Configuration.php line 732

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ODM\MongoDB;
  22. use Doctrine\Common\Annotations\AnnotationReader;
  23. use Doctrine\Common\Cache\Cache;
  24. use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
  25. use Doctrine\Common\Persistence\ObjectRepository;
  26. use Doctrine\Common\Proxy\AbstractProxyFactory;
  27. use Doctrine\ODM\MongoDB\Mapping\ClassMetadataFactory;
  28. use Doctrine\ODM\MongoDB\Mapping\Driver\AnnotationDriver;
  29. use Doctrine\ODM\MongoDB\PersistentCollection\DefaultPersistentCollectionFactory;
  30. use Doctrine\ODM\MongoDB\PersistentCollection\DefaultPersistentCollectionGenerator;
  31. use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionFactory;
  32. use Doctrine\ODM\MongoDB\PersistentCollection\PersistentCollectionGenerator;
  33. use Doctrine\ODM\MongoDB\Repository\DefaultRepositoryFactory;
  34. use Doctrine\ODM\MongoDB\Repository\DocumentRepository as NewDocumentRepository;
  35. use Doctrine\ODM\MongoDB\Repository\RepositoryFactory;
  37. /**
  38.  * Configuration class for the DocumentManager. When setting up your DocumentManager
  39.  * you can optionally specify an instance of this class as the second argument.
  40.  * If you do not pass a configuration object, a blank one will be created for you.
  41.  *
  42.  *     <?php
  43.  *
  44.  *     $config = new Configuration();
  45.  *     $dm = DocumentManager::create(new Connection(), $config);
  46.  *
  47.  * @since       1.0
  48.  */
  49. class Configuration extends \Doctrine\MongoDB\Configuration
  50. {
  51.     /**
  52.      * Never autogenerate a proxy/hydrator/persistent collection and rely that
  53.      * it was generated by some process before deployment. Copied from
  54.      * \Doctrine\Common\Proxy\AbstractProxyFactory.
  55.      *
  56.      * @var integer
  57.      */
  58.     const AUTOGENERATE_NEVER = 0;
  60.     /**
  61.      * Always generates a new proxy/hydrator/persistent collection in every request.
  62.      *
  63.      * This is only sane during development.
  64.      * Copied from \Doctrine\Common\Proxy\AbstractProxyFactory.
  65.      *
  66.      * @var integer
  67.      */
  68.     const AUTOGENERATE_ALWAYS = 1;
  70.     /**
  71.      * Autogenerate the proxy/hydrator/persistent collection class when the file does not exist.
  72.      *
  73.      * This strategy causes a file exists call whenever any proxy/hydrator is used the
  74.      * first time in a request. Copied from \Doctrine\Common\Proxy\AbstractProxyFactory.
  75.      *
  76.      * @var integer
  77.      */
  78.     const AUTOGENERATE_FILE_NOT_EXISTS = 2;
  80.     /**
  81.      * Generate the proxy/hydrator/persistent collection classes using eval().
  82.      *
  83.      * This strategy is only sane for development.
  84.      * Copied from \Doctrine\Common\Proxy\AbstractProxyFactory.
  85.      *
  86.      * @var integer
  87.      */
  88.     const AUTOGENERATE_EVAL = 3;
  90.     /**
  91.      * Array of attributes for this configuration instance.
  92.      *
  93.      * @var array
  94.      * @deprecated This property will be private in MongoDB ODM 2.0.
  95.      */
  96.     protected $attributes = [
  97.         'mongoCmd' => '$',
  98.         'retryConnect' => 0,
  99.         'retryQuery' => 0,
  100.     ];
  102.     /**
  103.      * Adds a namespace under a certain alias.
  104.      *
  105.      * @param string $alias
  106.      * @param string $namespace
  107.      */
  108.     public function addDocumentNamespace($alias, $namespace)
  109.     {
  110.         $this->attributes['documentNamespaces'][$alias] = $namespace;
  111.     }
  113.     /**
  114.      * Resolves a registered namespace alias to the full namespace.
  115.      *
  116.      * @param string $documentNamespaceAlias
  117.      * @return string
  118.      * @throws MongoDBException
  119.      */
  120.     public function getDocumentNamespace($documentNamespaceAlias)
  121.     {
  122.         if ( ! isset($this->attributes['documentNamespaces'][$documentNamespaceAlias])) {
  123.             throw MongoDBException::unknownDocumentNamespace($documentNamespaceAlias);
  124.         }
  126.         return trim($this->attributes['documentNamespaces'][$documentNamespaceAlias], '\\');
  127.     }
  129.     /**
  130.      * Retrieves the list of registered document namespace aliases.
  131.      *
  132.      * @return array
  133.      */
  134.     public function getDocumentNamespaces()
  135.     {
  136.         return $this->attributes['documentNamespaces'];
  137.     }
  139.     /**
  140.      * Set the document alias map
  141.      *
  142.      * @param array $documentNamespaces
  143.      * @return void
  144.      */
  145.     public function setDocumentNamespaces(array $documentNamespaces)
  146.     {
  147.         $this->attributes['documentNamespaces'] = $documentNamespaces;
  148.     }
  150.     /**
  151.      * Sets the cache driver implementation that is used for metadata caching.
  152.      *
  153.      * @param MappingDriver $driverImpl
  154.      * @todo Force parameter to be a Closure to ensure lazy evaluation
  155.      *       (as soon as a metadata cache is in effect, the driver never needs to initialize).
  156.      */
  157.     public function setMetadataDriverImpl(MappingDriver $driverImpl)
  158.     {
  159.         $this->attributes['metadataDriverImpl'] = $driverImpl;
  160.     }
  162.     /**
  163.      * Add a new default annotation driver with a correctly configured annotation reader.
  164.      *
  165.      * @param array $paths
  166.      * @return Mapping\Driver\AnnotationDriver
  167.      */
  168.     public function newDefaultAnnotationDriver($paths = array())
  169.     {
  170.         $reader = new AnnotationReader();
  172.         return new AnnotationDriver($reader, (array)$paths);
  173.     }
  175.     /**
  176.      * Gets the cache driver implementation that is used for the mapping metadata.
  177.      *
  178.      * @return MappingDriver
  179.      */
  180.     public function getMetadataDriverImpl()
  181.     {
  182.         return isset($this->attributes['metadataDriverImpl']) ?
  183.             $this->attributes['metadataDriverImpl'] : null;
  184.     }
  186.     /**
  187.      * Gets the cache driver implementation that is used for metadata caching.
  188.      *
  189.      * @return \Doctrine\Common\Cache\Cache
  190.      */
  191.     public function getMetadataCacheImpl()
  192.     {
  193.         return isset($this->attributes['metadataCacheImpl']) ?
  194.             $this->attributes['metadataCacheImpl'] : null;
  195.     }
  197.     /**
  198.      * Sets the cache driver implementation that is used for metadata caching.
  199.      *
  200.      * @param \Doctrine\Common\Cache\Cache $cacheImpl
  201.      */
  202.     public function setMetadataCacheImpl(Cache $cacheImpl)
  203.     {
  204.         $this->attributes['metadataCacheImpl'] = $cacheImpl;
  205.     }
  207.     /**
  208.      * Sets the directory where Doctrine generates any necessary proxy class files.
  209.      *
  210.      * @param string $dir
  211.      */
  212.     public function setProxyDir($dir)
  213.     {
  214.         $this->attributes['proxyDir'] = $dir;
  215.     }
  217.     /**
  218.      * Gets the directory where Doctrine generates any necessary proxy class files.
  219.      *
  220.      * @return string
  221.      */
  222.     public function getProxyDir()
  223.     {
  224.         return isset($this->attributes['proxyDir']) ?
  225.             $this->attributes['proxyDir'] : null;
  226.     }
  228.     /**
  229.      * Gets a boolean flag that indicates whether proxy classes should always be regenerated
  230.      * during each script execution.
  231.      *
  232.      * @return boolean|integer
  233.      */
  234.     public function getAutoGenerateProxyClasses()
  235.     {
  236.         return isset($this->attributes['autoGenerateProxyClasses']) ?
  237.             $this->attributes['autoGenerateProxyClasses'] : true;
  238.     }
  240.     /**
  241.      * Sets a boolean flag that indicates whether proxy classes should always be regenerated
  242.      * during each script execution.
  243.      *
  244.      * @param boolean|int $autoGenerateProxyClasses Possible values are constants of Doctrine\Common\Proxy\AbstractProxyFactory
  245.      */
  246.     public function setAutoGenerateProxyClasses($autoGenerateProxyClasses)
  247.     {
  248.         if (is_bool($autoGenerateProxyClasses)) {
  249.             @trigger_error(
  250.                 sprintf('Passing boolean value to "%s" is deprecated, please use constants of "%s" instead.', __METHOD__, AbstractProxyFactory::class),
  251.                 E_USER_DEPRECATED
  252.             );
  253.         }
  255.         if ($autoGenerateProxyClasses === AbstractProxyFactory::AUTOGENERATE_ALWAYS || $autoGenerateProxyClasses === AbstractProxyFactory::AUTOGENERATE_NEVER) {
  256.             @trigger_error(
  257.                 sprintf('The "AUTOGENERATE_ALWAYS" and "AUTOGENERATE_NEVER" strategies for proxy generation are deprecated and will be dropped in doctrine/mongodb-odm 2.0. Please use "AUTOGENERATE_FILE_NOT_EXISTS" and "AUTOGENERATE_EVAL".'),
  258.                 E_USER_DEPRECATED
  259.             );
  260.         }
  262.         $this->attributes['autoGenerateProxyClasses'] = $autoGenerateProxyClasses;
  263.     }
  265.     /**
  266.      * Gets the namespace where proxy classes reside.
  267.      *
  268.      * @return string
  269.      */
  270.     public function getProxyNamespace()
  271.     {
  272.         return isset($this->attributes['proxyNamespace']) ?
  273.             $this->attributes['proxyNamespace'] : null;
  274.     }
  276.     /**
  277.      * Sets the namespace where proxy classes reside.
  278.      *
  279.      * @param string $ns
  280.      */
  281.     public function setProxyNamespace($ns)
  282.     {
  283.         $this->attributes['proxyNamespace'] = $ns;
  284.     }
  286.     /**
  287.      * Sets the directory where Doctrine generates hydrator class files.
  288.      *
  289.      * @param string $dir
  290.      */
  291.     public function setHydratorDir($dir)
  292.     {
  293.         $this->attributes['hydratorDir'] = $dir;
  294.     }
  296.     /**
  297.      * Gets the directory where Doctrine generates hydrator class files.
  298.      *
  299.      * @return string
  300.      */
  301.     public function getHydratorDir()
  302.     {
  303.         return isset($this->attributes['hydratorDir']) ?
  304.             $this->attributes['hydratorDir'] : null;
  305.     }
  307.     /**
  308.      * Gets a boolean flag that indicates whether hydrator classes should always be regenerated
  309.      * during each script execution.
  310.      *
  311.      * @return boolean|integer Possible values are defined constants
  312.      */
  313.     public function getAutoGenerateHydratorClasses()
  314.     {
  315.         return isset($this->attributes['autoGenerateHydratorClasses']) ?
  316.             $this->attributes['autoGenerateHydratorClasses'] : true;
  317.     }
  319.     /**
  320.      * Sets a boolean flag that indicates whether hydrator classes should always be regenerated
  321.      * during each script execution.
  322.      *
  323.      * @param boolean|integer $bool
  324.      */
  325.     public function setAutoGenerateHydratorClasses($bool)
  326.     {
  327.         if (is_bool($bool)) {
  328.             @trigger_error(
  329.                 sprintf('Passing boolean value to "%s" is deprecated, please use "AUTOGENERATE_*" constants of "%s" instead.', __METHOD__, self::class),
  330.                 E_USER_DEPRECATED
  331.             );
  332.         }
  333.         $this->attributes['autoGenerateHydratorClasses'] = $bool;
  334.     }
  336.     /**
  337.      * Gets the namespace where hydrator classes reside.
  338.      *
  339.      * @return string
  340.      */
  341.     public function getHydratorNamespace()
  342.     {
  343.         return isset($this->attributes['hydratorNamespace']) ?
  344.             $this->attributes['hydratorNamespace'] : null;
  345.     }
  347.     /**
  348.      * Sets the namespace where hydrator classes reside.
  349.      *
  350.      * @param string $ns
  351.      */
  352.     public function setHydratorNamespace($ns)
  353.     {
  354.         $this->attributes['hydratorNamespace'] = $ns;
  355.     }
  357.     /**
  358.      * Sets the directory where Doctrine generates persistent collection class files.
  359.      *
  360.      * @param string $dir
  361.      */
  362.     public function setPersistentCollectionDir($dir)
  363.     {
  364.         $this->attributes['persistentCollectionDir'] = $dir;
  365.     }
  367.     /**
  368.      * Gets the directory where Doctrine generates persistent collection class files.
  369.      *
  370.      * @return string
  371.      */
  372.     public function getPersistentCollectionDir()
  373.     {
  374.         return isset($this->attributes['persistentCollectionDir']) ?
  375.             $this->attributes['persistentCollectionDir'] : null;
  376.     }
  378.     /**
  379.      * Gets a integer flag that indicates how and when persistent collection
  380.      * classes should be generated.
  381.      *
  382.      * @return integer Possible values are defined constants
  383.      */
  384.     public function getAutoGeneratePersistentCollectionClasses()
  385.     {
  386.         return isset($this->attributes['autoGeneratePersistentCollectionClasses']) ?
  387.             $this->attributes['autoGeneratePersistentCollectionClasses'] : self::AUTOGENERATE_ALWAYS;
  388.     }
  390.     /**
  391.      * Sets a integer flag that indicates how and when persistent collection
  392.      * classes should be generated.
  393.      *
  394.      * @param integer $mode Possible values are defined constants
  395.      */
  396.     public function setAutoGeneratePersistentCollectionClasses($mode)
  397.     {
  398.         $this->attributes['autoGeneratePersistentCollectionClasses'] = $mode;
  399.     }
  401.     /**
  402.      * Gets the namespace where persistent collection classes reside.
  403.      *
  404.      * @return string
  405.      */
  406.     public function getPersistentCollectionNamespace()
  407.     {
  408.         return isset($this->attributes['persistentCollectionNamespace']) ?
  409.             $this->attributes['persistentCollectionNamespace'] : null;
  410.     }
  412.     /**
  413.      * Sets the namespace where persistent collection classes reside.
  414.      *
  415.      * @param string $ns
  416.      */
  417.     public function setPersistentCollectionNamespace($ns)
  418.     {
  419.         $this->attributes['persistentCollectionNamespace'] = $ns;
  420.     }
  422.     /**
  423.      * Sets the default DB to use for all Documents that do not specify
  424.      * a database.
  425.      *
  426.      * @param string $defaultDB
  427.      */
  428.     public function setDefaultDB($defaultDB)
  429.     {
  430.         $this->attributes['defaultDB'] = $defaultDB;
  431.     }
  433.     /**
  434.      * Gets the default DB to use for all Documents that do not specify a database.
  435.      *
  436.      * @return string $defaultDB
  437.      */
  438.     public function getDefaultDB()
  439.     {
  440.         return isset($this->attributes['defaultDB']) ?
  441.             $this->attributes['defaultDB'] : null;
  442.     }
  444.     /**
  445.      * Set the class metadata factory class name.
  446.      *
  447.      * @param string $cmfName
  448.      */
  449.     public function setClassMetadataFactoryName($cmfName)
  450.     {
  451.         $this->attributes['classMetadataFactoryName'] = $cmfName;
  452.     }
  454.     /**
  455.      * Gets the class metadata factory class name.
  456.      *
  457.      * @return string
  458.      */
  459.     public function getClassMetadataFactoryName()
  460.     {
  461.         if ( ! isset($this->attributes['classMetadataFactoryName'])) {
  462.             $this->attributes['classMetadataFactoryName'] = ClassMetadataFactory::class;
  463.         }
  464.         return $this->attributes['classMetadataFactoryName'];
  465.     }
  467.     /**
  468.      * Gets array of default commit options.
  469.      *
  470.      * @return array
  471.      */
  472.     public function getDefaultCommitOptions()
  473.     {
  474.         if (isset($this->attributes['defaultCommitOptions'])) {
  475.             return $this->attributes['defaultCommitOptions'];
  476.         }
  478.         return array('w' => 1);
  479.     }
  481.     /**
  482.      * Sets array of default commit options.
  483.      *
  484.      * @param array $defaultCommitOptions
  485.      */
  486.     public function setDefaultCommitOptions($defaultCommitOptions)
  487.     {
  488.         $this->attributes['defaultCommitOptions'] = $defaultCommitOptions;
  489.     }
  491.     /**
  492.      * Add a filter to the list of possible filters.
  493.      *
  494.      * @param string $name       The name of the filter.
  495.      * @param string $className  The class name of the filter.
  496.      * @param array  $parameters The parameters for the filter.
  497.      */
  498.     public function addFilter($name, $className, array $parameters = array())
  499.     {
  500.         $this->attributes['filters'][$name] = array(
  501.             'class' => $className,
  502.             'parameters' => $parameters
  503.         );
  504.     }
  506.     /**
  507.      * Gets the class name for a given filter name.
  508.      *
  509.      * @param string $name The name of the filter.
  510.      *
  511.      * @return string|null The filter class name, or null if it is undefined
  512.      */
  513.     public function getFilterClassName($name)
  514.     {
  515.         return isset($this->attributes['filters'][$name])
  516.             ? $this->attributes['filters'][$name]['class']
  517.             : null;
  518.     }
  520.     /**
  521.      * Gets the parameters for a given filter name.
  522.      *
  523.      * @param string $name The name of the filter.
  524.      *
  525.      * @return array|null The filter parameters, or null if it is undefined
  526.      */
  527.     public function getFilterParameters($name)
  528.     {
  529.         return isset($this->attributes['filters'][$name])
  530.             ? $this->attributes['filters'][$name]['parameters']
  531.             : null;
  532.     }
  534.     /**
  535.      * Sets default repository class.
  536.      *
  537.      * @param string $className
  538.      *
  539.      * @return void
  540.      *
  541.      * @throws MongoDBException If not is a ObjectRepository
  542.      *
  543.      * @deprecated in version 1.2 and will be removed in 2.0. Please use setDefaultDocumentRepositoryClassName instead.
  544.      */
  545.     public function setDefaultRepositoryClassName($className)
  546.     {
  547.         @trigger_error(
  548.             sprintf('"%s" was deprecated in doctrine/mongodb-odm 1.2 and will be removed in 2.0. Please use "%s::setDefaultDocumentRepositoryClassName" instead.', __METHOD__, __CLASS__),
  549.             E_USER_DEPRECATED
  550.         );
  551.         $this->setDefaultDocumentRepositoryClassName($className);
  552.     }
  554.     /**
  555.      * Get default repository class.
  556.      *
  557.      * @return string
  558.      *
  559.      * @deprecated in version 1.2 and will be removed in 2.0. Please use getDefaultDocumentRepositoryClassName instead.
  560.      */
  561.     public function getDefaultRepositoryClassName()
  562.     {
  563.         @trigger_error(
  564.             sprintf('"%s" was deprecated in doctrine/mongodb-odm 1.2 and will be removed in 2.0. Please use "%s::getDefaultDocumentRepositoryClassName" instead.', __METHOD__, __CLASS__),
  565.             E_USER_DEPRECATED
  566.         );
  567.         return $this->getDefaultDocumentRepositoryClassName();
  568.     }
  570.     /**
  571.      * @throws MongoDBException If not is a ObjectRepository.
  572.      */
  573.     public function setDefaultDocumentRepositoryClassName($className)
  574.     {
  575.         $reflectionClass = new \ReflectionClass($className);
  576.         if (! $reflectionClass->implementsInterface(ObjectRepository::class)) {
  577.             throw MongoDBException::invalidDocumentRepository($className);
  578.         }
  579.         $this->attributes['defaultDocumentRepositoryClassName'] = $className;
  580.     }
  582.     /**
  583.      * Get default repository class.
  584.      *
  585.      * @return string
  586.      */
  587.     public function getDefaultDocumentRepositoryClassName()
  588.     {
  589.         return isset($this->attributes['defaultDocumentRepositoryClassName'])
  590.             ? $this->attributes['defaultDocumentRepositoryClassName']
  591.             : NewDocumentRepository::class;
  592.     }
  594.     /**
  595.      * Set the document repository factory.
  596.      *
  597.      * @param RepositoryFactory $repositoryFactory
  598.      */
  599.     public function setRepositoryFactory(RepositoryFactory $repositoryFactory)
  600.     {
  601.         $this->attributes['repositoryFactory'] = $repositoryFactory;
  602.     }
  604.     /**
  605.      * Get the document repository factory.
  606.      *
  607.      * @return RepositoryFactory
  608.      */
  609.     public function getRepositoryFactory()
  610.     {
  611.         return isset($this->attributes['repositoryFactory'])
  612.             ? $this->attributes['repositoryFactory']
  613.             : new DefaultRepositoryFactory();
  614.     }
  616.     /**
  617.      * Set the persistent collection factory.
  618.      *
  619.      * @param PersistentCollectionFactory $persistentCollectionFactory
  620.      */
  621.     public function setPersistentCollectionFactory(PersistentCollectionFactory $persistentCollectionFactory)
  622.     {
  623.         $this->attributes['persistentCollectionFactory'] = $persistentCollectionFactory;
  624.     }
  626.     /**
  627.      * Get the persistent collection factory.
  628.      *
  629.      * @return DefaultPersistentCollectionFactory
  630.      */
  631.     public function getPersistentCollectionFactory()
  632.     {
  633.         if ( ! isset($this->attributes['persistentCollectionFactory'])) {
  634.             $this->attributes['persistentCollectionFactory'] = new DefaultPersistentCollectionFactory();
  635.         }
  636.         return $this->attributes['persistentCollectionFactory'];
  637.     }
  639.     /**
  640.      * Set the persistent collection generator.
  641.      *
  642.      * @param PersistentCollectionGenerator $persistentCollectionGenerator
  643.      */
  644.     public function setPersistentCollectionGenerator(PersistentCollectionGenerator $persistentCollectionGenerator)
  645.     {
  646.         $this->attributes['persistentCollectionGenerator'] = $persistentCollectionGenerator;
  647.     }
  649.     /**
  650.      * Get the persistent collection generator.
  651.      *
  652.      * @return DefaultPersistentCollectionGenerator
  653.      */
  654.     public function getPersistentCollectionGenerator()
  655.     {
  656.         if ( ! isset($this->attributes['persistentCollectionGenerator'])) {
  657.             $this->attributes['persistentCollectionGenerator'] = new DefaultPersistentCollectionGenerator(
  658.                 $this->getPersistentCollectionDir(),
  659.                 $this->getPersistentCollectionNamespace()
  660.             );
  661.         }
  662.         return $this->attributes['persistentCollectionGenerator'];
  663.     }
  665.     /**
  666.      * {@inheritdoc}
  667.      *
  668.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  669.      */
  670.     public function getLoggerCallable()
  671.     {
  672.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  674.         return parent::getLoggerCallable();
  675.     }
  677.     /**
  678.      * {@inheritdoc}
  679.      *
  680.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  681.      */
  682.     public function setLoggerCallable($loggerCallable)
  683.     {
  684.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  686.         parent::setLoggerCallable($loggerCallable);
  687.     }
  689.     /**
  690.      * {@inheritdoc}
  691.      *
  692.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  693.      */
  694.     public function getMongoCmd()
  695.     {
  696.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  698.         return parent::getMongoCmd();
  699.     }
  701.     /**
  702.      * {@inheritdoc}
  703.      *
  704.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  705.      */
  706.     public function setMongoCmd($cmd)
  707.     {
  708.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  710.         parent::setMongoCmd($cmd);
  711.     }
  713.     /**
  714.      * {@inheritdoc}
  715.      *
  716.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  717.      */
  718.     public function getRetryConnect()
  719.     {
  720.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  722.         return parent::getRetryConnect();
  723.     }
  725.     /**
  726.      * {@inheritdoc}
  727.      *
  728.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  729.      */
  730.     public function setRetryConnect($retryConnect)
  731.     {
  732.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  734.         parent::setRetryConnect($retryConnect);
  735.     }
  737.     /**
  738.      * {@inheritdoc}
  739.      *
  740.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  741.      */
  742.     public function getRetryQuery()
  743.     {
  744.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  746.         return parent::getRetryQuery();
  747.     }
  749.     /**
  750.      * {@inheritdoc}
  751.      *
  752.      * @deprecated This method is deprecated and will be removed in MongoDB ODM 2.0.
  753.      */
  754.     public function setRetryQuery($retryQuery)
  755.     {
  756.         @trigger_error(sprintf('The "%s" method is deprecated and will be removed in doctrine/mongodb-odm 2.0.', __METHOD__), E_USER_DEPRECATED);
  758.         parent::setRetryQuery($retryQuery);
  759.     }
  760. }