var/cache/dev/jms_diextra/doctrine/EntityManager_66f5f61681ec2.php line 222

Open in your IDE?
  1. <?php
  3. namespace EntityManager66f5f61681ec2_546a8d27f194334ee012bfe64f629947b07e4919\__CG__\Doctrine\ORM;
  5. /**
  6.  * CG library enhanced proxy class.
  7.  *
  8.  * This code was generated automatically by the CG library, manual changes to it
  9.  * will be lost upon next generation.
  10.  */
  11. class EntityManager extends \Doctrine\ORM\EntityManager
  12. {
  13.     private $delegate;
  14.     private $container;
  16.     /**
  17.      * {@inheritDoc}
  18.      */
  19.     public function transactional($func)
  20.     {
  21.         return $this->delegate->transactional($func);
  22.     }
  24.     /**
  25.      * {@inheritDoc}
  26.      */
  27.     public function rollback()
  28.     {
  29.         return $this->delegate->rollback();
  30.     }
  32.     /**
  33.      * Removes an entity instance.
  34.      *
  35.      * A removed entity will be removed from the database at or before transaction commit
  36.      * or as a result of the flush operation.
  37.      *
  38.      * @param object $entity The entity instance to remove.
  39.      *
  40.      * @return void
  41.      *
  42.      * @throws ORMInvalidArgumentException
  43.      * @throws ORMException
  44.      */
  45.     public function remove($entity)
  46.     {
  47.         return $this->delegate->remove($entity);
  48.     }
  50.     /**
  51.      * Refreshes the persistent state of an entity from the database,
  52.      * overriding any local changes that have not yet been persisted.
  53.      *
  54.      * @param object $entity The entity to refresh.
  55.      *
  56.      * @return void
  57.      *
  58.      * @throws ORMInvalidArgumentException
  59.      * @throws ORMException
  60.      */
  61.     public function refresh($entity)
  62.     {
  63.         return $this->delegate->refresh($entity);
  64.     }
  66.     /**
  67.      * Tells the EntityManager to make an instance managed and persistent.
  68.      *
  69.      * The entity will be entered into the database at or before transaction
  70.      * commit or as a result of the flush operation.
  71.      *
  72.      * NOTE: The persist operation always considers entities that are not yet known to
  73.      * this EntityManager as NEW. Do not pass detached entities to the persist operation.
  74.      *
  75.      * @param object $entity The instance to make managed and persistent.
  76.      *
  77.      * @return void
  78.      *
  79.      * @throws ORMInvalidArgumentException
  80.      * @throws ORMException
  81.      */
  82.     public function persist($entity)
  83.     {
  84.         return $this->delegate->persist($entity);
  85.     }
  87.     /**
  88.      * {@inheritDoc}
  89.      */
  90.     public function newHydrator($hydrationMode)
  91.     {
  92.         return $this->delegate->newHydrator($hydrationMode);
  93.     }
  95.     /**
  96.      * Merges the state of a detached entity into the persistence context
  97.      * of this EntityManager and returns the managed copy of the entity.
  98.      * The entity passed to merge will not become associated/managed with this EntityManager.
  99.      *
  100.      * @param object $entity The detached entity to merge into the persistence context.
  101.      *
  102.      * @return object The managed copy of the entity.
  103.      *
  104.      * @throws ORMInvalidArgumentException
  105.      * @throws ORMException
  106.      *
  107.      * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
  108.      */
  109.     public function merge($entity)
  110.     {
  111.         return $this->delegate->merge($entity);
  112.     }
  114.     /**
  115.      * {@inheritDoc}
  116.      */
  117.     public function lock($entity, $lockMode, $lockVersion = NULL)
  118.     {
  119.         return $this->delegate->lock($entity, $lockMode, $lockVersion);
  120.     }
  122.     /**
  123.      * {@inheritDoc}
  124.      */
  125.     public function isOpen()
  126.     {
  127.         return $this->delegate->isOpen();
  128.     }
  130.     /**
  131.      * {@inheritDoc}
  132.      */
  133.     public function isFiltersStateClean()
  134.     {
  135.         return $this->delegate->isFiltersStateClean();
  136.     }
  138.     /**
  139.      * {@inheritDoc}
  140.      */
  141.     public function initializeObject($obj)
  142.     {
  143.         return $this->delegate->initializeObject($obj);
  144.     }
  146.     /**
  147.      * {@inheritDoc}
  148.      */
  149.     public function hasFilters()
  150.     {
  151.         return $this->delegate->hasFilters();
  152.     }
  154.     /**
  155.      * {@inheritDoc}
  156.      */
  157.     public function getUnitOfWork()
  158.     {
  159.         return $this->delegate->getUnitOfWork();
  160.     }
  162.     /**
  163.      * Gets the repository for an entity class.
  164.      *
  165.      * @param string $entityName The name of the entity.
  166.      *
  167.      * @return ObjectRepository|EntityRepository The repository class.
  168.      */
  169.     public function getRepository($className)
  170.     {
  171.         $repository = $this->delegate->getRepository($className);
  173.         if ($repository instanceof \Symfony\Component\DependencyInjection\ContainerAwareInterface) {
  174.             $repository->setContainer($this->container);
  176.             return $repository;
  177.         }
  179.         if (null !== $metadata = $this->container->get("jms_di_extra.metadata.metadata_factory")->getMetadataForClass(get_class($repository))) {
  180.             foreach ($metadata->classMetadata as $classMetadata) {
  181.                 foreach ($classMetadata->methodCalls as $call) {
  182.                     list($method, $arguments) = $call;
  183.                     call_user_func_array(array($repository, $method), $this->prepareArguments($arguments));
  184.                 }
  185.             }
  186.         }
  188.         return $repository;
  189.     }
  191.     /**
  192.      * {@inheritDoc}
  193.      */
  194.     public function getReference($entityName, $id)
  195.     {
  196.         return $this->delegate->getReference($entityName, $id);
  197.     }
  199.     /**
  200.      * {@inheritDoc}
  201.      */
  202.     public function getProxyFactory()
  203.     {
  204.         return $this->delegate->getProxyFactory();
  205.     }
  207.     /**
  208.      * {@inheritDoc}
  209.      */
  210.     public function getPartialReference($entityName, $identifier)
  211.     {
  212.         return $this->delegate->getPartialReference($entityName, $identifier);
  213.     }
  215.     /**
  216.      * Gets the metadata factory used to gather the metadata of classes.
  217.      *
  218.      * @return \Doctrine\ORM\Mapping\ClassMetadataFactory
  219.      */
  220.     public function getMetadataFactory()
  221.     {
  222.         return $this->delegate->getMetadataFactory();
  223.     }
  225.     /**
  226.      * {@inheritDoc}
  227.      */
  228.     public function getHydrator($hydrationMode)
  229.     {
  230.         return $this->delegate->getHydrator($hydrationMode);
  231.     }
  233.     /**
  234.      * {@inheritDoc}
  235.      */
  236.     public function getFilters()
  237.     {
  238.         return $this->delegate->getFilters();
  239.     }
  241.     /**
  242.      * {@inheritDoc}
  243.      */
  244.     public function getExpressionBuilder()
  245.     {
  246.         return $this->delegate->getExpressionBuilder();
  247.     }
  249.     /**
  250.      * {@inheritDoc}
  251.      */
  252.     public function getEventManager()
  253.     {
  254.         return $this->delegate->getEventManager();
  255.     }
  257.     /**
  258.      * {@inheritDoc}
  259.      */
  260.     public function getConnection()
  261.     {
  262.         return $this->delegate->getConnection();
  263.     }
  265.     /**
  266.      * {@inheritDoc}
  267.      */
  268.     public function getConfiguration()
  269.     {
  270.         return $this->delegate->getConfiguration();
  271.     }
  273.     /**
  274.      * Returns the ORM metadata descriptor for a class.
  275.      *
  276.      * The class name must be the fully-qualified class name without a leading backslash
  277.      * (as it is returned by get_class($obj)) or an aliased class name.
  278.      *
  279.      * Examples:
  280.      * MyProject\Domain\User
  281.      * sales:PriceRequest
  282.      *
  283.      * Internal note: Performance-sensitive method.
  284.      *
  285.      * @param string $className
  286.      *
  287.      * @return \Doctrine\ORM\Mapping\ClassMetadata
  288.      */
  289.     public function getClassMetadata($className)
  290.     {
  291.         return $this->delegate->getClassMetadata($className);
  292.     }
  294.     /**
  295.      * {@inheritDoc}
  296.      */
  297.     public function getCache()
  298.     {
  299.         return $this->delegate->getCache();
  300.     }
  302.     /**
  303.      * Flushes all changes to objects that have been queued up to now to the database.
  304.      * This effectively synchronizes the in-memory state of managed objects with the
  305.      * database.
  306.      *
  307.      * If an entity is explicitly passed to this method only this entity and
  308.      * the cascade-persist semantics + scheduled inserts/removals are synchronized.
  309.      *
  310.      * @param null|object|array $entity
  311.      *
  312.      * @return void
  313.      *
  314.      * @throws \Doctrine\ORM\OptimisticLockException If a version check on an entity that
  315.      *         makes use of optimistic locking fails.
  316.      * @throws ORMException
  317.      */
  318.     public function flush($entity = NULL)
  319.     {
  320.         return $this->delegate->flush($entity);
  321.     }
  323.     /**
  324.      * Finds an Entity by its identifier.
  325.      *
  326.      * @param string       $entityName  The class name of the entity to find.
  327.      * @param mixed        $id          The identity of the entity to find.
  328.      * @param integer|null $lockMode    One of the \Doctrine\DBAL\LockMode::* constants
  329.      *                                  or NULL if no specific lock mode should be used
  330.      *                                  during the search.
  331.      * @param integer|null $lockVersion The version of the entity to find when using
  332.      *                                  optimistic locking.
  333.      *
  334.      * @return object|null The entity instance or NULL if the entity can not be found.
  335.      *
  336.      * @throws OptimisticLockException
  337.      * @throws ORMInvalidArgumentException
  338.      * @throws TransactionRequiredException
  339.      * @throws ORMException
  340.      */
  341.     public function find($entityName, $id, $lockMode = NULL, $lockVersion = NULL)
  342.     {
  343.         return $this->delegate->find($entityName, $id, $lockMode, $lockVersion);
  344.     }
  346.     /**
  347.      * Detaches an entity from the EntityManager, causing a managed entity to
  348.      * become detached.  Unflushed changes made to the entity if any
  349.      * (including removal of the entity), will not be synchronized to the database.
  350.      * Entities which previously referenced the detached entity will continue to
  351.      * reference it.
  352.      *
  353.      * @param object $entity The entity to detach.
  354.      *
  355.      * @return void
  356.      *
  357.      * @throws ORMInvalidArgumentException
  358.      *
  359.      * @deprecated 2.7 This method is being removed from the ORM and won't have any replacement
  360.      */
  361.     public function detach($entity)
  362.     {
  363.         return $this->delegate->detach($entity);
  364.     }
  366.     /**
  367.      * {@inheritDoc}
  368.      */
  369.     public function createQueryBuilder()
  370.     {
  371.         return $this->delegate->createQueryBuilder();
  372.     }
  374.     /**
  375.      * {@inheritDoc}
  376.      */
  377.     public function createQuery($dql = '')
  378.     {
  379.         return $this->delegate->createQuery($dql);
  380.     }
  382.     /**
  383.      * {@inheritDoc}
  384.      */
  385.     public function createNativeQuery($sql, \Doctrine\ORM\Query\ResultSetMapping $rsm)
  386.     {
  387.         return $this->delegate->createNativeQuery($sql, $rsm);
  388.     }
  390.     /**
  391.      * {@inheritDoc}
  392.      */
  393.     public function createNamedQuery($name)
  394.     {
  395.         return $this->delegate->createNamedQuery($name);
  396.     }
  398.     /**
  399.      * {@inheritDoc}
  400.      */
  401.     public function createNamedNativeQuery($name)
  402.     {
  403.         return $this->delegate->createNamedNativeQuery($name);
  404.     }
  406.     /**
  407.      * {@inheritDoc}
  408.      */
  409.     public function copy($entity, $deep = false)
  410.     {
  411.         return $this->delegate->copy($entity, $deep);
  412.     }
  414.     /**
  415.      * Determines whether an entity instance is managed in this EntityManager.
  416.      *
  417.      * @param object $entity
  418.      *
  419.      * @return boolean TRUE if this EntityManager currently manages the given entity, FALSE otherwise.
  420.      */
  421.     public function contains($entity)
  422.     {
  423.         return $this->delegate->contains($entity);
  424.     }
  426.     /**
  427.      * {@inheritDoc}
  428.      */
  429.     public function commit()
  430.     {
  431.         return $this->delegate->commit();
  432.     }
  434.     /**
  435.      * {@inheritDoc}
  436.      */
  437.     public function close()
  438.     {
  439.         return $this->delegate->close();
  440.     }
  442.     /**
  443.      * Clears the EntityManager. All entities that are currently managed
  444.      * by this EntityManager become detached.
  445.      *
  446.      * @param string|null $entityName if given, only entities of this type will get detached
  447.      *
  448.      * @return void
  449.      *
  450.      * @throws ORMInvalidArgumentException If a non-null non-string value is given.
  451.      * @throws MappingException            If a $entityName is given, but that entity is not
  452.      *                                     found in the mappings.
  453.      */
  454.     public function clear($entityName = NULL)
  455.     {
  456.         return $this->delegate->clear($entityName);
  457.     }
  459.     /**
  460.      * {@inheritDoc}
  461.      */
  462.     public function beginTransaction()
  463.     {
  464.         return $this->delegate->beginTransaction();
  465.     }
  467.     public function __construct($objectManager, \Symfony\Component\DependencyInjection\ContainerInterface $container)
  468.     {
  469.         $this->delegate = $objectManager;
  470.         $this->container = $container;
  471.     }
  473.     private function prepareArguments(array $arguments)
  474.     {
  475.         $processed = array();
  476.         foreach ($arguments as $arg) {
  477.             if ($arg instanceof \Symfony\Component\DependencyInjection\Reference) {
  478.                 $processed[] = $this->container->get((string) $arg, $arg->getInvalidBehavior());
  479.             } else if ($arg instanceof \Symfony\Component\DependencyInjection\Parameter) {
  480.                 $processed[] = $this->container->getParameter((string) $arg);
  481.             } else {
  482.                 $processed[] = $arg;
  483.             }
  484.         }
  486.         return $processed;
  487.     }
  488. }