Get the sequence mapper
@return PersistenceMapper
7226
protected function getSequenceMapper() {
    if (self::$sequenceMapper == null) {
      self::$sequenceMapper = self::getMapper(self::SEQUENCE_CLASS);
    }
    return self::$sequenceMapper;
  }
217718
public function getLeaderboardMapper()
    {
        if (null === $this->leaderboardType) {
            $this->leaderboardType = $this->serviceLocator->get('playgroundreward_learderboard_mapper');
        }

        return $this->leaderboardType;
    }
304664
public function getPersistenceHelper()
    {
        if (null === $this->persistenceHelper) {
            $this->persistenceHelper = new Doctrine\ORM\PersistenceHelper(
                $this->em,
                $this->getPersistenceEventQueue()
            );
        }

        return $this->persistenceHelper;
    }
468938
private function _generateMappings()
    {
        if (!isset($this->_mappings) && $this->_map->mappings) {
            //up to date, nothing to do
            return;
        }
        $this->_mappingsChanged = false;
        if (!count($this->_mappings)) {
            return '';
        }

        foreach ($this->_mappings as $m) {
            if ($m['originalSource'] && !in_array($m['originalSource'], $this->_map->sources)) {
                $this->_map->sources[] = $m['originalSource'];
            }
        }

        $this->_map->names = array();
        foreach ($this->_mappings as $m) {
            if ($m['originalName'] && !in_array($m['originalName'], $this->_map->names)) {
                $this->_map->names[] = $m['originalName'];
            }
        }

        // group mappings by generated line number.
        $groupedMap = $groupedMapEncoded = array();
        foreach ($this->_mappings as $m) {
            $groupedMap[$m['generatedLine']][] = $m;
        }
        ksort($groupedMap);

        $lastGeneratedLine = $lastOriginalSourceIndex = $lastOriginalNameIndex = $lastOriginalLine = $lastOriginalColumn = 0;

        foreach ($groupedMap as $lineNumber => $lineMap) {
            while (++$lastGeneratedLine < $lineNumber) {
                $groupedMapEncoded[] = ';';
            }

            $lineMapEncoded = array();
            $lastGeneratedColumn = 0;

            foreach ($lineMap as $m) {
                $mapEncoded = Kwf_SourceMaps_Base64VLQ::encode($m['generatedColumn'] - $lastGeneratedColumn);
                $lastGeneratedColumn = $m['generatedColumn'];

                // find the index
                if ($m['originalSource']) {
                    $index = array_search($m['originalSource'], $this->_map->sources);
                    $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($index - $lastOriginalSourceIndex);
                    $lastOriginalSourceIndex = $index;

                    // lines are stored 0-based in SourceMap spec version 3
                    $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($m['originalLine'] - 1 - $lastOriginalLine);
                    $lastOriginalLine = $m['originalLine'] - 1;

                    $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($m['originalColumn'] - $lastOriginalColumn);
                    $lastOriginalColumn = $m['originalColumn'];

                    if ($m['originalName']) {
                        $index = array_search($m['originalName'], $this->_map->names);
                        $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($index - $lastOriginalNameIndex);
                        $lastOriginalNameIndex = $index;
                    }
                }

                $lineMapEncoded[] = $mapEncoded;
            }

            $groupedMapEncoded[] = implode(',', $lineMapEncoded).';';
        }

        $this->_map->mappings = rtrim(implode($groupedMapEncoded), ';');
    }
630938
protected function getUserMapper()
    {
        if ( null === $this->_userMapper )
        {
            $mapper = $this->getMapper();

            $this->_userMapper = $this->getServiceLocator()
                                      ->get( 'Di' )
                                      ->get( 'Grid\User\Model\User\Mapper', array(
                                          'dbAdapter' => $mapper->getDbAdapter(),
                                          'dbSchema'  => $mapper->getDbSchema(),
                                      ) );
        }

        return $this->_userMapper;
    }
853553
public function map()
    {
        $column = array();
        foreach ($this as $record) {
            $key = reset($record);
            $val = next($record);
            $column[$key] = $val;
        }
        return $column;
    }
63339
public function getDataMapper()
    {
        if (!$this->mapper) {
            $this->mapper = new DataMapper($this->table, $this->keys);
        }

        return $this->mapper;
    }
731837
public function getZfcUserMapper()
    {
        if (!$this->zfcUserMapper instanceof UserMapperInterface) {
            $this->setZfcUserMapper($this->getServiceManager()->get('zfcuser_user_mapper'));
        }

        return $this->zfcUserMapper;
    }
694843
private function initializeMapper() {
    // set the mapper
    $persistenceFacade = ObjectFactory::getInstance('persistenceFacade');
    if ($persistenceFacade->isKnownType($this->type)) {
      $this->mapper = $persistenceFacade->getMapper($this->type);
    }
    else {
      // initialize null mapper if not done already
      if (self::$nullMapper == null) {
        self::$nullMapper = new NullMapper();
      }
      $this->mapper = self::$nullMapper;
    }
  }
739645
public function getPersistentCollectionGenerator()
    {
        if (!isset($this->odmOptions['persistentCollectionGenerator'])) {
            $this->odmOptions['persistentCollectionGenerator'] = new DefaultPersistentCollectionGenerator(
                $this->getPersistentCollectionDir(),
                $this->getPersistentCollectionNamespace()
            );
        }

        return $this->odmOptions['persistentCollectionGenerator'];
    }
1061980
public function getUserProviderMapper()
    {
        if ($this->userProviderMapper == null) {
            $this->userProviderMapper = $this->getServiceManager()->get('playgrounduser_userprovider_mapper');
        }

        return $this->userProviderMapper;
    }
542648
protected function getDataMapper() {
		if(!$this->dataMapper)
			$this->dataMapper = $this->definition->getContainer()['dataMapper'];
		return $this->dataMapper;
	}
436970
public function getRewardMapper()
    {
        if (null === $this->rewardMapper) {
            $this->rewardMapper = $this->serviceLocator->get('playgroundreward_reward_mapper');
        }

        return $this->rewardMapper;
    }
648066
private function getMapping()
    {
        if ($this->mapping === null) {
            $defaultStore = $this->getDefaultStoreView();
            $index        = $this->indexManager->getIndexByName($this->indexName, $defaultStore);

            $this->mapping = $index->getMapping();
        }

        return $this->mapping;
    }
743947
public function getCountryMapper()
    {
        if (null === $this->countryMapper) {
            $this->countryMapper = $this->getServiceManager()->get('delcountriesflags_mapper');
        }
        return $this->countryMapper;
    }
519962
public function getFaqMapper()
    {
        if (null === $this->faqMapper) {
            $this->faqMapper = $this->getServiceManager()->get('playgroundfaq_faq_mapper');
        }

        return $this->faqMapper;
    }
546498
public function buildMappingInformation()
    {
        $mappings = new MappingCollection(MappingCollection::TYPE_ENTITY);
        foreach ($this->indexInformer->getClassesAndAnnotations() as $className => $annotation) {
            $mappings->add($this->buildMappingFromClassAndAnnotation($className, $annotation));
        }

        return $mappings;
    }