Builds a StoredProcedure instance with the required configuration
@param \eMapper\Mapper $mapper
969549
protected function buildProcedure(Mapper $mapper) {
		//create procedure instance
		$this->procedure = $mapper->newProcedure($this->procedureName);
		
		if (isset($this->usePrefix))
			$this->procedure->usePrefix($this->usePrefix);
		
		if (!empty($this->argumentTypes))
			$this->procedure->argTypes($this->argumentTypes);
		
		//PostgreSQL options
		if ($this->procedure instanceof PostgreSQLStoredProcedure) {
			if (isset($this->returnSet))
				$this->procedure->returnSet($this->returnSet);
			
			if (isset($this->escapeName))
				$this->procedure->escapeName($this->escapeName);
		}
		
		//configure procedure
		$this->procedure->merge($this->config);
	}
700584
protected function createInstanceFromEntityArray(array $entityArray, DoplioDataMapper $mapper = null)
    {
        if (!$mapper) {
            $mapper = $this;
        }

        $className = get_class($mapper->table);
        $instance  = new $className();

        return $this->fillExistingInstanceFromEntityArray($instance, $entityArray);
    }
1040545
public function createMapper()
    {
        if ($this->mapperElement !== null) {
            throw new BuildException(
                'Cannot define more than one mapper',
                $this->getLocation()
            );
        }
        $this->mapperElement = new Mapper($this->project);

        return $this->mapperElement;
    }
275303
public static function buildTableMap()
    {
      $dbMap = Propel::getServiceContainer()->getDatabaseMap(DealerTableMap::DATABASE_NAME);
      if (!$dbMap->hasTable(DealerTableMap::TABLE_NAME)) {
        $dbMap->addTableObject(new DealerTableMap());
      }
    }
480288
public function constructUsing($objectCreator)
	{
		if ($objectCreator instanceof \Closure) {
			$objectCreator = new ClosureObjectCreator($objectCreator);
		}
		if (!$objectCreator instanceof ObjectCreatorInterface) {
			throw new PapperConfigurationException('Argument objectCreator must be closure or instance of Papper\ObjectCreatorInterface');
		}
		$this->typeMap->setObjectCreator($objectCreator);
	}
127714
private function registerConfigurationMapper()
    {
        $this->app->bind(DriverMapper::class, function () {
            $mapper = new DriverMapper;
            $mapper->registerMapper(new SqlMapper);
            $mapper->registerMapper(new SqliteMapper);
            $mapper->registerMapper(new OCIMapper);
            return $mapper;
        });
    }
68063
public static function buildTableMap()
    {
      $dbMap = Propel::getServiceContainer()->getDatabaseMap(DealerFolderTableMap::DATABASE_NAME);
      if (!$dbMap->hasTable(DealerFolderTableMap::TABLE_NAME)) {
        $dbMap->addTableObject(new DealerFolderTableMap());
      }
    }
472409
public function add(Mapper $fileNameMapper)
    {
        if ($this->isReference()) {
            throw $this->noChildrenAllowed();
        }
        if ($this->container == null) {
            if ($this->type == null && $this->classname == null) {
                $this->container = new CompositeMapper();
            } else {
                $m = $this->getImplementation();
                if ($m instanceof ContainerMapper) {
                    $this->container = $m;
                } else {
                    throw new BuildException("$m mapper implementation does not support nested mappers!");
                }
            }
        }
        $this->container->add($fileNameMapper);
        $this->checked = false;
    }
718906
public static function buildTableMap()
    {
        $dbMap = Propel::getServiceContainer()->getDatabaseMap(C2MTableMap::DATABASE_NAME);
        if (!$dbMap->hasTable(C2MTableMap::TABLE_NAME)) {
            $dbMap->addTableObject(new C2MTableMap());
        }
    }
247825
public static function buildTableMap()
    {
      $dbMap = Propel::getServiceContainer()->getDatabaseMap(PersonFunctionLinkTableMap::DATABASE_NAME);
      if (!$dbMap->hasTable(PersonFunctionLinkTableMap::TABLE_NAME)) {
        $dbMap->addTableObject(new PersonFunctionLinkTableMap());
      }
    }
1142248
public function createService(ServiceLocatorInterface $serviceLocator)
    {
        $config = $serviceLocator->get('config')['mongoObjectMapper'];
        $client = self::constructMongoClient(@$config['uri'], @$config['options']);

        $mapperClass = 'MongoObject\Mapper';
        if (isset($config['mapperClass'])) {
            $mapperClass = $config['mapperClass'];
        }

        return new $mapperClass($client->selectDb($config['database']), @$config['modelsNamespace']);
    }
787640
public static function buildTableMap()
    {
        $dbMap = Propel::getServiceContainer()->getDatabaseMap(FunctionPhaseTableMap::DATABASE_NAME);
        if (!$dbMap->hasTable(FunctionPhaseTableMap::TABLE_NAME)) {
            $dbMap->addTableObject(new FunctionPhaseTableMap());
        }
    }
44646
public static function buildTableMap()
    {
      $dbMap = Propel::getServiceContainer()->getDatabaseMap(FeatureTypeTableMap::DATABASE_NAME);
      if (!$dbMap->hasTable(FeatureTypeTableMap::TABLE_NAME)) {
        $dbMap->addTableObject(new FeatureTypeTableMap());
      }
    }
52430
protected function registerMapperInitializer(Application $app)
    {
        $initializer = function ($mapper, $app) {
            $mapper->setSqlFactory(new SqlFactory);
        };

        $app->initializer('Synapse\Mapper\AbstractMapper', $initializer);
    }
844154
public function getMapper($mapperClass = null, array $options = [])
    {
        $mapperClass = $mapperClass ?? $this->mapper ?? $this->serviceAlias;

        if (!array_key_exists($mapperClass, $this->mappers)) {
            $this->setMapper($mapperClass, $options);
        }

        return $this->mappers[$mapperClass];
    }
907153
public static function buildTableMap()
    {
        $dbMap = Propel::getServiceContainer()->getDatabaseMap(PlayerTableMap::DATABASE_NAME);
        if (!$dbMap->hasTable(PlayerTableMap::TABLE_NAME)) {
            $dbMap->addTableObject(new PlayerTableMap());
        }
    }
398735
public function mapper($entity, $entityMap = null)
    {
        if ($entity instanceof Wrapper) {
            throw new MappingException('Tried to instantiate mapper on wrapped Entity');
        }

        $entity = $this->resolveEntityClass($entity);

        $entity = $this->getInverseMorphMap($entity);

        // Return existing mapper instance if exists.
        if (array_key_exists($entity, $this->mappers)) {
            return $this->mappers[$entity];
        } else {
            return $this->buildMapper($entity, $entityMap);
        }
    }