Given the arch name, returns the directory where it will be
        built.

        This returns a different directory depending on what
        alternative or optional dependencies are being built.
354552
def get_build_container_dir(self, arch):
        '''
        '''
        dir_name = self.get_dir_name()
        return join(self.ctx.build_dir, 'other_builds',
                    dir_name, '{}__ndk_target_{}'.format(arch, self.ctx.ndk_api))
632331
def get_build_path(self):
        
        target_path = path.join(settings.BUILD_DIR, self.get_url().lstrip('/'))
        if not self.fs.exists(target_path):
            logger.debug("Creating {}".format(target_path))
            self.fs.makedirs(target_path)
        return os.path.join(target_path, 'index.html')
489673
def build_dirs(self):
        

        arch = self.arch_name()

        build_path = os.path.join('build', arch)
        output = os.path.join('build', 'output')
        test = os.path.join('build', 'test', arch)

        return {'build': build_path, 'output': output, 'test': test}
260304
def resolve_name(name, arch, osarch=None):
    '''
    
    '''
    if osarch is None:
        osarch = get_osarch()

    if not check_32(arch, osarch) and arch not in (ARCHMAP.get(osarch, osarch), 'noarch'):
        name += '.{0}'.format(arch)
    return name
1196110
def _get_distutils_build_directory():
    
    pattern = "lib.{platform}-{major}.{minor}"
    return os.path.join('build', pattern.format(platform=sysconfig.get_platform(),
                                                major=sys.version_info[0],
                                                minor=sys.version_info[1]))
147122
public function getDirectory()
    {
        if (!isset($this->directory)) {
            $this->setDirectory($this->getPHPCI()->buildPath);
        }
        return $this->directory;
    }
1159259
public File getBuildDir() {
        // we use the null check variant so that people can write true unit tests with a mock ItemParent
        // and without a JenkinsRule. Such tests are of limited utility as there is a high risk of hitting
        // some code that needs the singleton, but for persistence migration test cases it makes sense to permit
        Jenkins j = Jenkins.getInstanceOrNull();
        if (j == null) {
            return new File(getRootDir(), "builds");
        }
        return j.getBuildDirFor(this);
    }
1104819
def path (self):
        
        if not self.path_:
            if self.action_:
                p = self.action_.properties ()
                (target_path, relative_to_build_dir) = p.target_path ()

                if relative_to_build_dir:
                    # Indicates that the path is relative to
                    # build dir.
                    target_path = os.path.join (self.project_.build_dir (), target_path)

                # Store the computed path, so that it's not recomputed
                # any more
                self.path_ = target_path

        return os.path.normpath(self.path_)
713799
function getAppsDataDir(){
	switch(process.platform){
		case 'win32': return process.env.LOCALAPPDATA;
		case 'linux': return process.env.HOME + '/.config';
		case 'darwin': return process.env.HOME + '/Library/Application Support';
		default: throw Error("unknown platform "+process.platform);
	}
}
165956
def get_thumbsdir(self, path):
        
        # Thumbsdir could be a callable
        # In that case, the path is built on the fly, based on the source path
        thumbsdir = self.thumbsdir
        if callable(self.thumbsdir):
            thumbsdir = self.thumbsdir(path)
        return thumbsdir
983152
def is_directory (self):
        
        filename = self.get_os_filename()
        return os.path.isdir(filename) and not os.path.islink(filename)
344222
def postbuild_arch(self, arch):
        '''
        '''
        postbuild = "postbuild_{}".format(arch.arch)
        if hasattr(self, postbuild):
            getattr(self, postbuild)()
749849
def get_buildfile_path(settings):
    
    base = os.path.basename(settings.build_url)
    return os.path.join(BUILDS_ROOT, base)
737618
public Optional<Path> getArduinoDirectory() {
        if (arduinoDirectory != null) {
            return Optional.ofNullable(Paths.get(arduinoDirectory));
        }

        logger.log(Level.INFO, "Looking for Árduino directory");

        Path arduinoPath = Paths.get(homeDirectory, "Documents/Arduino");
        if (!Files.exists(arduinoPath)) {
            logger.log(Level.INFO, "Not found in " + arduinoPath);

            // try again in the onedrive folder, noticed it there on several windows machines
            arduinoPath = Paths.get(homeDirectory, "OneDrive/Documents/Arduino");
        }
        if (!Files.exists(arduinoPath)) {
            logger.log(Level.INFO, "Not found in " + arduinoPath);

            Optional<String> path = getArduinoPathWithDialog();
            if (path.isPresent()) {
                logger.log(Level.INFO, "Finally found in  " + path);
                arduinoPath = Paths.get(path.get());
            }
        }

        if (!Files.exists(arduinoPath)) return Optional.empty();

        logger.log(Level.INFO, "looking for libraries");

        // there was an arduino install without a libraries directory - add it.
        Path libsPath = arduinoPath.resolve("libraries");
        if (!Files.exists(libsPath)) {
            try {
                logger.log(Level.INFO, "Creating libraries folder");
                Files.createDirectory(libsPath);
            } catch (IOException e) {
                return Optional.empty();
            }
        }

        arduinoDirectory = arduinoPath.toString();

        return Optional.of(arduinoPath);
    }
274861
def get_bin_dir(self, build_module: str) -> str:
        
        bin_dir = os.path.join(self.conf.get_bin_path(), build_module)
        if not os.path.isdir(bin_dir):
            # exist_ok=True in case of concurrent creation of the same dir
            os.makedirs(bin_dir, exist_ok=True)
        return bin_dir
488802
def get_root_dir(self):
        
        if os.path.isdir(self.root_path):
            return self.root_path
        else:
            return os.path.dirname(self.root_path)
440539
def get_default_library_dir_from_file_path
      #Get the first directory name after src/design or src/testbench:
      rel_design_path_list = @relative_path_from_project.to_s.split('/')
      return nil if rel_design_path_list.length < 3
      return nil unless STANDARD_LIBRARY_FOLDERS_LIST.include? [rel_design_path_list.first(2)].join('/')
      Pathname.new([rel_design_path_list.first(3)].join('/'))
    end