public function build()
 {
     $this->setObjectManager($this->createEntityManager());
     $this->serializerBuilder = BreezeSerializerBuilder::create($this->getObjectManager());
     $this->validatorBuilder = new ValidatorBuilder();
     if ($this->annotationsEnabled) {
         $this->validatorBuilder->enableAnnotationMapping();
     }
     foreach ($this->mappings as $mapping) {
         if (isset($mapping['serializer'])) {
             $this->serializerBuilder->addMetadataDir($mapping['serializer']);
         }
         if (isset($mapping['validation'])) {
             if ($mapping['type'] == 'xml') {
                 $this->validatorBuilder->addXmlMapping($mapping['validation']);
             } else {
                 if ($mapping['type'] == 'yaml') {
                     $this->validatorBuilder->addYamlMapping($mapping['validation']);
                 }
             }
             //                else if ($mapping['type'] == 'annotation') {
             //                    $this->validatorBuilder->enableAnnotationMapping();
             //                }
         }
     }
     $serializer = $this->serializerBuilder->build();
     $this->setSerializer($serializer);
     $validator = $this->validatorBuilder->getValidator();
     $this->setValidator($validator);
 }

 /**
  * Override default deserialization visitors
  *
  * @param Container $app
  * @param SerializerBuilder $serializerBuilder
  */
 protected function setDeserializationVisitors(Container $app, SerializerBuilder $serializerBuilder)
 {
     $serializerBuilder->addDefaultDeserializationVisitors();
     foreach ($app["serializer.deserializationVisitors"] as $format => $visitor) {
         $serializerBuilder->setDeserializationVisitor($format, $visitor);
     }
 }

 /**
  * Create a serializer instance.
  *
  * @return Serializer
  */
 protected function createSerializer()
 {
     $builder = new SerializerBuilder();
     $builder->addDefaultHandlers();
     $builder->addDefaultDeserializationVisitors();
     $builder->addDefaultSerializationVisitors();
     $this->configureBuilder($builder);
     return $builder->build();
 }

 /**
  * @param Request $request
  * @param $clientId
  *
  * @Route("/get/tpe/from/client/{clientId}", name="getTpeFromClient", options={"expose"=true})
  * @return \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
  */
 public function getTpeFromClientAction(Request $request, $clientId)
 {
     if ($request->isXmlHttpRequest() && $request->isMethod('POST')) {
         $em = $this->getDoctrine()->getManager();
         $serializer = new SerializerBuilder();
         $clientRepository = $em->getRepository('CibLicenseBundle:Client');
         $client = $clientRepository->find($clientId);
         return new Response($serializer->create()->build()->serialize($client->getTpe(), 'json'), 200);
     } else {
         return $this->createNotFoundException('DANS TON CUL !');
     }
 }

 /**
  * Constructor.
  *
  * @param \net\authorize\api\contract\v1\AnetApiRequestType $request ApiRequest to send
  * @param string $responseType response type expected
  * @throws InvalidArgumentException if invalid request
  */
 public function __construct(\net\authorize\api\contract\v1\AnetApiRequestType $request, $responseType)
 {
     date_default_timezone_set('UTC');
     $this->logger = LogFactory::getLog(get_class($this));
     if (null == $request) {
         throw new InvalidArgumentException("request cannot be null");
     }
     if (null == $responseType || '' == $responseType) {
         throw new InvalidArgumentException("responseType cannot be null or empty");
     }
     if (null != $this->apiResponse) {
         throw new InvalidArgumentException("response has to be null");
     }
     $this->apiRequest = $request;
     $this->validate();
     $this->apiResponseType = $responseType;
     $this->httpClient = new HttpClient();
     $serializerBuilder = SerializerBuilder::create();
     $serializerBuilder->addMetadataDir(__DIR__ . '/../../yml/v1', 'net\\authorize\\api\\contract\\v1');
     //..\..\yml\v1\ //'/../lib/net/authorize/api/yml/v1'
     $serializerBuilder->configureHandlers(function (HandlerRegistryInterface $h) use($serializerBuilder) {
         $serializerBuilder->addDefaultHandlers();
         $h->registerSubscribingHandler(new BaseTypesHandler());
         // XMLSchema List handling
         $h->registerSubscribingHandler(new XmlSchemaDateHandler());
         // XMLSchema date handling
     });
     $this->serializer = $serializerBuilder->build();
 }

 /**
  *  RPC url action
  *
  * @param $bundle
  * @param $service
  * @param $method
  * @param Request $request
  *
  * @Route("/{bundle}/{service}/{method}" , defaults={"_format": "json"})
  * @Method("POST")
  *
  * @return Response
  */
 public function rpcAction($bundle, $service, $method, Request $request)
 {
     $response = new Response();
     $translator = $this->get('translator');
     try {
         $prefix = 'Hazu.Service';
         $serviceObject = $this->get("{$prefix}.{$bundle}.{$service}");
         if (true === method_exists($serviceObject, $method)) {
             $params = json_decode($request->getContent(), true);
             if (null === $params) {
                 throw new \Exception('$params não é um JSON valido');
             }
             $rService = $serviceObject->{$method}($params);
         } else {
             throw new \Exception($translator->trans('Metodo não encontrado'));
         }
     } catch (ServiceNotFoundException $e) {
         $rService = new HazuException($e->getMessage());
         $response->setStatusCode(500);
     } catch (\Exception $e) {
         $rService = new HazuException($e->getMessage());
         $response->setStatusCode(500);
     } finally {
         $serializer = SerializerBuilder::create()->build();
         $rJson = $serializer->serialize($rService, 'json', SerializationContext::create()->enableMaxDepthChecks());
         $response->headers->set('x-hazu-type', gettype($rService));
         if (gettype($rService) == 'object') {
             $response->headers->set('x-hazu-class', get_class($rService));
         }
         $response->setContent($rJson);
     }
     return $response;
 }

 protected function setUp()
 {
     parent::setUp();
     $this->serializer = SerializerBuilder::create()->build();
     $this->validator = Validation::createValidator();
     $this->action->setSerializer($this->serializer)->setValidator($this->validator);
 }

 /**
  * @return \JMS\Serializer\Serializer
  */
 private function serializer()
 {
     if (null === $this->serializer) {
         $this->serializer = SerializerBuilder::create()->addMetadataDir(__DIR__ . '/../../Infrastructure/Application/Serialization/JMS/Config')->setCacheDir(__DIR__ . '/../../../var/cache/jms-serializer')->build();
     }
     return $this->serializer;
 }

 /**
  * Test hydrate single entity
  */
 public function testHydrateEntity()
 {
     $serializer = SerializerBuilder::create()->build();
     $service = new HydratorService($serializer, $this->getTransformer());
     $result = $service->hydrateEntity(json_encode($this->testData), 'MJanssen\\Assets\\Entity\\Test');
     $this->assertEquals($this->createEntity($this->testData), $result);
 }

 /**
  * @param string $username
  * @param string $apiKey
  */
 public function __construct($username, $apiKey)
 {
     $this->username = $username;
     $this->apiKey = $apiKey;
     $this->serializer = SerializerBuilder::create()->setCacheDir(__DIR__ . '/../../../cache')->setDebug(true)->build();
     $this->client = new Client(new SerializerWrapper($this->serializer));
 }

 /**
  * Instantiate a SerpPageSerializer
  * @param string $cacheDir
  */
 public function __construct($cacheDir = self::DEFAULT_SERIALIZER_CACHE_DIR)
 {
     if (!SerpPageSerializerHelper::validateDir($cacheDir)) {
         throw new \Franzip\SerpPageSerializer\Exceptions\InvalidArgumentException('Invalid SerpPageSerializer $cacheDir: please supply a valid non-empty string.');
     }
     $this->serializer = SerializerBuilder::create()->setCacheDir($cacheDir)->build();
 }

 public function editAction(Request $request, $id)
 {
     $serializer = SerializerBuilder::create()->build();
     $data = array('success' => false, 'error' => 'Ошибка обновления книги');
     if ($request->getMethod() == 'POST') {
         $requestData = $request->request->all();
         if (empty($requestData['apiKey']) || !$this->checkApiKey($requestData['apiKey'])) {
             $data['error'] = 'Неверный ключ';
             $jsonContent = $serializer->serialize($data, 'json');
             return new Response($jsonContent);
         }
         $book = $this->getDoctrine()->getManager()->getRepository('IntaroBookStoreBundle:Book')->find($id);
         if (!$book) {
             $data['error'] = 'Книга не найдена';
             $jsonContent = $serializer->serialize($data, 'json');
             return new Response($jsonContent);
         }
         if (!empty($requestData['name']) && !empty($requestData['author']) && !empty($requestData['readingDate']) && isset($requestData['download'])) {
             $book->setName($requestData['name']);
             $book->setAuthor($requestData['author']);
             $book->setReadingDate(new \DateTime($requestData['readingDate']));
             $book->setDownload($requestData['download']);
         } else {
             $data['error'] = 'Заданы не все необходимые поля';
             $jsonContent = $serializer->serialize($data, 'json');
             return new Response($jsonContent);
         }
         $em = $this->getDoctrine()->getManager();
         $em->persist($book);
         $em->flush();
         $data = array('success' => true, 'message' => 'Книга успешно обновлена');
     }
     $jsonContent = $serializer->serialize($data, 'json');
     return new Response($jsonContent);
 }

 /**
  * @return mixed
  */
 public static function getSerializer()
 {
     if (!self::$serializer) {
         self::$serializer = SerializerBuilder::create()->build();
     }
     return self::$serializer;
 }

 private function getSerializer()
 {
     if (is_null($this->serializer)) {
         $this->serializer = SerializerBuilder::create()->addMetadataDir(dirname(__DIR__) . '/V1_1_1/Metadata/Cdm', 'CdmFr\\Model\\V1_1_1\\Cdm')->addMetadataDir(dirname(__DIR__) . '/V1_1_1/Metadata/CdmFr', 'CdmFr\\Model\\V1_1_1\\CdmFr')->addMetadataDir(dirname(__DIR__) . '/V1_1_1/Metadata/Lheo', 'CdmFr\\Model\\V1_1_1\\Lheo')->build();
     }
     return $this->serializer;
 }

 /**
  * Set up all the mocks and the serializer class
  *
  * @return void
  */
 public function setUp()
 {
     $this->serializer = SerializerBuilder::create()->build();
     $this->setupPheanstalkConnectionMock();
     $this->generateFakeParams();
     $this->setupEntityManagerMock();
 }

 public function __construct(array $config)
 {
     $config = array_replace($defaults = ['subscribers' => [], 'listeners' => [], 'extraHandlers' => []], $config);
     $serializerBuilder = SerializerBuilder::create();
     if (isset($config['cacheDir'])) {
         $serializerBuilder->setCacheDir($config['cacheDir']);
     }
     if (isset($config['propertyNamingStrategy'])) {
         $serializerBuilder->setPropertyNamingStrategy($config['propertyNamingStrategy']);
     }
     if (isset($config['objectConstructor'])) {
         $serializerBuilder->setObjectConstructor($config['objectConstructor']);
     }
     if (isset($config['debug'])) {
         $serializerBuilder->setDebug((bool) $config['objectConstructor']);
     }
     $serializerBuilder->addDefaultHandlers();
     $extraHandlers = $config['extraHandlers'];
     $serializerBuilder->configureHandlers(function (HandlerRegistry $handlerRegistry) use($extraHandlers) {
         array_walk($extraHandlers, [$handlerRegistry, 'registerSubscribingHandler']);
     });
     $subscribers = $config['subscribers'];
     $listeners = $config['listeners'];
     $serializerBuilder->configureListeners(function (EventDispatcher $dispatcher) use($subscribers, $listeners) {
         array_walk($subscribers, [$dispatcher, 'addSubscriber']);
         foreach ($listeners as $event => $callables) {
             foreach ($callables as $cb) {
                 $dispatcher->addListener($event, $cb);
             }
         }
     });
     $this->serializer = $serializerBuilder->build();
 }

 /**
  * @param string $key
  * @param mixed $value
  */
 public function store($key, $value)
 {
     $serializer = SerializerBuilder::create()->build();
     $jsonContent = $serializer->serialize($value, 'json');
     apc_store($this->getCacheKey() . $key, $jsonContent);
     $this->cacheDriver->store($this->getCacheKey() . $key, $jsonContent);
 }

 public function register()
 {
     \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists');
     $this->app->singleton('serializer', function ($app) {
         return SerializerBuilder::create()->setObjectConstructor(new DoctrineObjectConstructor($app->make('registry'), new UnserializeObjectConstructor()))->build();
     });
 }

 /**
  * Constructor
  *
  * By Default if a JMS Serializer isn't provided, one will be created.
  * Providing a JMS Serializer instance allows for additional event handling,
  * caching and extensions to be loaded
  *
  * @param Serializer $serializer
  */
 public function __construct(Serializer $serializer = null)
 {
     if (is_null($serializer)) {
         $serializer = SerializerBuilder::create()->build();
     }
     $this->serializer = $serializer;
 }

 protected function toXml($oObject)
 {
     $oSerializer = SerializerBuilder::create()->build();
     $sXml = $oSerializer->serialize($oObject, 'xml');
     $this->_sXml = $sXml;
     return $this;
 }