Adds the fileMap property definition.

@return string
427492
private function addFileMap()
    {
        $code = '';
        $definitions = $this->container->getDefinitions();
        ksort($definitions);
        foreach ($definitions as $id => $definition) {
            if (!$definition->isSynthetic() && $definition->isShared() && !$this->isHotPath($definition)) {
                $code .= sprintf("            %s => '%s.php',\n", $this->doExport($id), $this->generateMethodName($id));
            }
        }

        return $code ? "        \$this->fileMap = array(\n{$code}        );\n" : '';
    }
646237
public function addMap($class, $path = null)
    {
        if (is_array($class)) {
            foreach ($class as $ns => $path) {
                $this->files->addMap($ns, $path);
            }
        } else {
            $this->files->addMap($class, $path);
        }

        return $this;
    }
537107
public function enaImageFiles()
    {
        $properties = $this->getProperties();
        $extString  = (!empty($properties['acceptedFiles'])) ? $properties['acceptedFiles'] : '';
        $imagExts   = $this->getImageExtensionConstant();
        foreach ($imagExts as $imagExt) {
            if (in_array($imagExt, $extString) === false) {
                $extString[] = $imagExt;
            }
        }
        $properties                     = $this->getProperties();
        $properties['acceptedFiles']    = $extString;
        $this->setProperties($properties);
        return $this;
    }
362820
public function generatePropertyMapClass()
    {
        $classMap = array();

        foreach($this->elementClassFinder as $classFile)
        {
            /** @var \Symfony\Component\Finder\SplFileInfo $classFile */
            $className = str_replace(array('\\', 'src/', '/', '.php'), array('/', '', '\\', ''), $classFile->getRelativePathname());

            if (false !== strpos($className, 'Abstract') || false !== strpos($className, 'Interface'))
                continue;

            $namespacedClassName = $this->elementClassNamespace.$className;
            $reflectionClass = new \ReflectionClass($namespacedClassName);
            $classMap[$namespacedClassName] = $this->createMapEntry($reflectionClass);
        }

        foreach($this->resourceClassFinder as $classFile)
        {
            /** @var \Symfony\Component\Finder\SplFileInfo $classFile */
            $className = str_replace(array('\\', 'src/', '/', '.php'), array('/', '', '\\', ''), $classFile->getRelativePathname());

            if (false !== strpos($className, 'Abstract') || false !== strpos($className, 'Interface'))
                continue;

            $namespacedClassName = $this->resourceClassNamespace.$className;
            $reflectionClass = new \ReflectionClass($namespacedClassName);
            $classMap[$namespacedClassName] = $this->createMapEntry($reflectionClass);
        }

        $outputFile = $this->outputDir.$this->outputClassName.'.php';

        $data = str_replace("\n  ", "\n        ", var_export($classMap, true));
        $now = date('Y-m-d e');
        $outputString = <<<PHP
<?php

/**
 * This class is automatically generated by php-fhir-object-mapper, do not edit!
 *
 * Created: {$now}
 */
class {$this->outputClassName} implements \\ArrayAccess {

    /** @var array */
    private \$_classMap = {$data};

    public function offsetSet(\$offset, \$value) {
        throw new \\BadMethodCallException('You may not add objects to this map post-creation.');
    }

    public function offsetExists(\$offset) {
        return isset(\$this->_classMap[\$offset]);
    }

    public function offsetUnset(\$offset) {
        throw new \\BadMethodCallException('You may not remove objects from this map post-creation.');
    }

    public function offsetGet(\$offset) {
        if (isset(\$this->_classMap[\$offset]))
            return \$this->_classMap[\$offset];

        throw new \OutOfRangeException('No FHIR class named "'.\$offset.'" exists in this map.');
    }
}
PHP;
        return (bool)file_put_contents($outputFile, $outputString);
    }
68063
public static function buildTableMap()
    {
      $dbMap = Propel::getServiceContainer()->getDatabaseMap(DealerFolderTableMap::DATABASE_NAME);
      if (!$dbMap->hasTable(DealerFolderTableMap::TABLE_NAME)) {
        $dbMap->addTableObject(new DealerFolderTableMap());
      }
    }
463421
public function disPresentationFiles()
    {
        $properties     = $this->getProperties();
        $acceptedFiles  = $properties['acceptedFiles'];
        $pptsExt        = $this->getPresentationExtensionConstant();
        $acceptedFiles  = $this->rmAcceptedFiles($acceptedFiles, $pptsExt);
        $properties['acceptedFiles']    = $acceptedFiles;
        $this->setProperties($properties);
        return $this;
    }
769233
public function addFileToSet($f_id)
    {
        $app = Application::getFacadeApplication();
        if (is_object($f_id)) {
            $f = $f_id;
            if ($f instanceof FileEntity) {
                $file = $f;
                $fileVersion = $file->getApprovedVersion();
            } else {
                $fileVersion = $f;
                $file = $fileVersion->getFile();
            }
            $f_id = (int) $file->getFileID();
        } else {
            $f_id = (int) $f_id;
            $em = $app->make(EntityManagerInterface::class);
            $file = $em->find(FileEntity::class, $f_id);
            $fileVersion = $file->getApprovedVersion();
        }
        if ($file === null) {
            $result = null;
        } else {
            $file_set_file = File::createAndGetFile($f_id, $this->fsID);
            $fe = new \Concrete\Core\File\Event\FileSetFile($file_set_file);
            $director = $app->make(EventDispatcherInterface::class);
            $director->dispatch('on_file_added_to_set', $fe);
            if ($fileVersion !== null && $this->shouldRefreshFileThumbnails('add')) {
                $fileVersion->refreshThumbnails(false);
            }
            $result = $file_set_file;
        }

        return $result;
    }
944651
private static HashMap<String, Module> getFileExtensionMap()
	{
		if (fileExtensionMap==null)
			fileExtensionMap= new HashMap<String, Module>();
		
		return fileExtensionMap;
	}
1176131
private function setMapAction()
    {
        array_push($this->actions, 'map');

        $this->addForm = array_diff($this->addForm, ['map_lat', 'map_lng', 'map_address', 'map_province', 'map_locality', 'map_postal_code']);
        $this->editForm = array_diff($this->addForm, ['map_lat', 'map_lng', 'map_address', 'map_province', 'map_locality', 'map_postal_code']);

        return $this;
    }
602432
public function getMapping()
    {
        if (null === $this->mapping) {
            $mappingFilePath = $this->locateFile($this->mappingFileName);

            if (is_array($mappingFilePath)) {
                throw new \Exception("The mapping file wasn't found. Locations we tried: ".join(', ', $mappingFilePath));
            } elseif (!is_readable($mappingFilePath)) {
                throw new \RuntimeException(sprintf('The mapping.yaml was not found at %s or is not readable.', $mappingFilePath));
            } else {
                $this->mappingFilePath = $mappingFilePath;
                $this->mapping = Yaml::parse(file_get_contents($mappingFilePath));
            }
        }

        return $this->mapping;
    }
397544
private function getMappings(): Iterator
    {
        if ($this->mappings === null) {
            $filePaths = [];

            foreach ($this->mappingFilePaths as $mappingFilePath) {
                $newFilePaths = iterator_to_array(new SplFileObject($mappingFilePath, 'r'));
                $filePaths    = array_merge($filePaths, $newFilePaths);
            }

            $this->mappings = new ArrayIterator(
                array_map(
                    function (string $mapping) : FileMappingInterface {
                        return new UnixFileMapping(
                            $this->sourceDirectory,
                            $this->targetDirectory,
                            trim($mapping)
                        );
                    },
                    // Filter out empty lines.
                    array_filter(
                        $filePaths
                    )
                )
            );
        }

        return $this->mappings;
    }
350582
public function getValueMap() {

		$count	= count( $this->binded );
		$map	= [];

		for( $i = 0; $i < $count; $i++ ) {

			$map[ $this->binded[ $i ] ] = $this->value[ $i ];
		}

		return $map;
	}
1204749
protected function getMap()
    {
        $fileSets = $this->getFilesets();

        // No filesets set
        // We're assuming single file / directory
        if (empty($fileSets)) {
            return $this->getTarget();
        }

        $targets = [];

        foreach ($fileSets as $fs) {
            if (!($fs instanceof FileSet)) {
                continue;
            }

            // We need a directory to store the links
            if (!is_dir($this->getLink())) {
                throw new BuildException('Link must be an existing directory when using fileset');
            }

            $fromDir = $fs->getDir($this->getProject())->getAbsolutePath();

            if (!is_dir($fromDir)) {
                $this->log('Directory doesn\'t exist: ' . $fromDir, Project::MSG_WARN);
                continue;
            }

            $fsTargets = [];

            $ds = $fs->getDirectoryScanner($this->getProject());

            $fsTargets = array_merge(
                $fsTargets,
                $ds->getIncludedDirectories(),
                $ds->getIncludedFiles()
            );

            // Add each target to the map
            foreach ($fsTargets as $target) {
                if (!empty($target)) {
                    $targets[$target] = $fromDir . DIRECTORY_SEPARATOR . $target;
                }
            }
        }

        return $targets;
    }
489228
private function insertFile()
    {
        $fileDocument = [
            '_id' => $this->_documentId,
            'uploadDate' => new UTCDateTime(round(microtime(true) * 1000)),
        ];
        if ($this->filename === null) {
            $fileDocument['filename'] = $this->_documentId . '.dat';
        } else {
            $fileDocument['filename'] = $this->filename;
        }

        $fileDocument = array_merge(
            $fileDocument,
            $this->document,
            [
                'chunkSize' => $this->chunkSize,
                'length' => $this->length,
                'md5' => hash_final($this->_hashContext),
            ]
        );

        $this->collection->insert($fileDocument);
        return $fileDocument;
    }
718906
public static function buildTableMap()
    {
        $dbMap = Propel::getServiceContainer()->getDatabaseMap(C2MTableMap::DATABASE_NAME);
        if (!$dbMap->hasTable(C2MTableMap::TABLE_NAME)) {
            $dbMap->addTableObject(new C2MTableMap());
        }
    }
680705
private function addPhpFileNode()
    {
        $builder = new TreeBuilder('php_file');
        $node    = $this->getRootNode($builder, 'php_file');

        $node
            ->addDefaultsIfNotSet()
            ->children()
                ->scalarNode('directory')->defaultValue('%kernel.cache_dir%/doctrine/cache/phpfile')->end()
                ->scalarNode('extension')->defaultNull()->end()
                ->integerNode('umask')->defaultValue(0002)->end()
            ->end()
        ;

        return $node;
    }
1134863
protected function buildPropertyMap()
    {
        $map = [];
        $properties = (new ReflectionObject($this))->getProperties(ReflectionProperty::IS_PUBLIC);

        foreach ($properties as $property) {
            $map[$property->getName()] = $property;
        }

        return $map;
    }