Get instance of DataMapper.

@return \Friday\Model\DataMapper
510799
private function getDataMapper()
    {
        if($this->dataMapper == null) {
            $this->dataMapper = new \Friday\Model\DataMapper(self::$app->config);
        }
        return $this->dataMapper;
    }
70364
public function getDataModel()
    {
        $dataModel = array();
        $model     = $this->config->getDataModel();

        foreach ($this->getEditFieldsArrays() as $name => $options) {
            //if this is a key, set it to 0
            if ($options['type'] === 'key') {
                $dataModel[$name] = 0;
            } else {
                //if this is a collection, convert it to an array
                if (is_a($model->$name, 'Illuminate\Database\Eloquent\Collection')) {
                    $dataModel[$name] = $model->$name->toArray();
                } else {
                    $dataModel[$name] = isset($options['value']) ? $options['value'] : null;
                }
            }
        }

        return $dataModel;
    }
436486
public function getUserMapper()
    {
        if (!$this->userMapper) {
            $this->userMapper = $this->getServiceLocator()->get('zfcuser_user_mapper');
        }

        return $this->userMapper;
    }
1101448
public static function instance()
    {
        if (null === self::$_instance) {
            $routeCollector = new RouteCollector(
                new \FastRoute\RouteParser\Std,
                new \FastRoute\DataGenerator\GroupCountBased
            );
            self::$_instance = $routeCollector;
        }
        return self::$_instance;
    }
218746
private function createDataMapper($entityClass)
    {
        /** @var DataMapperInterface $dataMapper */
        $dataMapperClass = isset($this->config['dataMapper']) ? $this->config['dataMapper'] : DoctrineDataMapper::class;

        $meta = $this->builder->getMeta($entityClass);

        if ($meta->storage['type'] == 'api') {
            $dataMapperClass = $meta->storage['handler'];
        }

        switch ($dataMapperClass) {
            case CsvDataMapper::class:
                $connectionClass = CsvDataGateway::class;

                break;

            default:
                $connectionClass = Connection::class;

                break;
        }

        $dataMapper = new $dataMapperClass(
            $this->getConnection($connectionClass),
            $entityClass,
            $meta->storage['table'],
            $this->entityRegistry
        );

        if ($dataMapper instanceof DispatcherAwareInterface) {
            $dataMapper->setDispatcher($this->getDispatcher());
        }

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

        return $this->userProviderMapper;
    }
673153
public function getInstance()
	{
		if (!is_null($this->instance)) {
			return $this->instance;
		}

        $this->instance = $this->getJobFactory()->create($this->payload['class'], $this->getArguments(), $this->queue);
        $this->instance->job = $this;
        return $this->instance;
	}
1367368
public function getPageMapper()
    {
        if (null === $this->pageMapper) {
            $this->pageMapper = $this->getServiceManager()->get('playgroundfacebook_page_mapper');
        }

        return $this->pageMapper;
    }
7226
protected function getSequenceMapper() {
    if (self::$sequenceMapper == null) {
      self::$sequenceMapper = self::getMapper(self::SEQUENCE_CLASS);
    }
    return self::$sequenceMapper;
  }
1125547
public function getDatatable()
    {
        $this->datatable->setModel($this->model);
        $this->datatable->build();

        return $this->datatable->generateColomns();
    }
185965
public function getAdapter()
    {
        if (isset($this->adapter)) {
            return $this->adapter;
        }
        if (isset($this->options['connection'])) {
            if (!($this->options['connection'] instanceof \PDO)) {
                throw new \RuntimeException('The specified connection is not a PDO instance');
            }

            $this->options['connection']->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
            $this->options['adapter'] = $this->options['connection']->getAttribute(\PDO::ATTR_DRIVER_NAME);
        }
        if (!isset($this->options['adapter'])) {
            throw new \RuntimeException('No adapter was specified for environment: ' . $this->getName());
        }

        $factory = AdapterFactory::instance();
        $adapter = $factory
            ->getAdapter($this->options['adapter'], $this->options);

        // Automatically time the executed commands
        $adapter = $factory->getWrapper('timed', $adapter);

        if (isset($this->options['wrapper'])) {
            $adapter = $factory
                ->getWrapper($this->options['wrapper'], $adapter);
        }

        if ($this->getCommand()) {
            $adapter->setCommand($this->getCommand());
        }

        // Use the TablePrefixAdapter if table prefix/suffixes are in use
        if ($adapter->hasOption('table_prefix') || $adapter->hasOption('table_suffix')) {
            $adapter = AdapterFactory::instance()
                ->getWrapper('prefix', $adapter);
        }

        $this->setAdapter($adapter);

        return $adapter;
    }
1296385
public function getObjectAttributeMappingMapper()
    {
        if (null === $this->objectAttributeMappingMapper) {
            $this->objectAttributeMappingMapper = $this->serviceLocator->get('playgroundflow_objectattributemapping_mapper');
        }
    
        return $this->objectAttributeMappingMapper;
    }
1364714
function dataMap()
    {
        if ( !isset( $this->DataMap[$this->Version] ) )
        {
            $attributes = $this->fetchAttributes( false, true, $this->Version );
            foreach ( $attributes as $attribute )
            {
                $this->DataMap[$this->Version][$attribute->attribute( 'identifier' )] = $attribute;
            }
        }
        return $this->DataMap[$this->Version];
    }
324434
public function toDatamapperObject()
    {
        $entities = new DatamapperCollection;

        foreach ($this->items as $name => $item) {
            $entities->put($name, $item->toDatamapperObject());
        }

        return $entities;
    }
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;
    }
970975
public function getStoryMapper()
    {
        if (null === $this->storyMapper) {
            $this->storyMapper = $this->serviceLocator->get('playgroundflow_story_mapper');
        }

        return $this->storyMapper;
    }
84902
public function getObjectMappingMapper()
    {
        if (null === $this->objectMappingMapper) {
            $this->objectMappingMapper = $this->serviceLocator->get('playgroundflow_objectmapping_mapper');
        }
    
        return $this->objectMappingMapper;
    }