Returns True if the VG is exported, False otherwise.
491348
def is_exported(self):
        
        self.open()
        exp = lvm_vg_is_exported(self.handle)
        self.close()
        return bool(exp)
1157236
private function getExport(): bool
    {
        if (false === $this->export) {
            $this->export = (bool)Configure::read('Search.dashboardExport');
        }

        return $this->export;
    }
1073953
def is_valid_export_dir(self):
        
        if self.export_dir and not os.path.isabs(self.export_dir):
            self.export_dir = os.path.normpath(
                os.path.join(self.input_dir, self.export_dir))
        if not self.export_dir:
            self.export_dir = os.path.expanduser('~')  # home directory
            logging.warning('export_dir not specified. Using export_dir=%s'
                            % self.export_dir)
            return True
        elif not os.path.exists(self.export_dir):
            try:
                os.makedirs(self.export_dir)
            except PermissionError:
                return False
            return True
        return os.path.isdir(self.export_dir) and os.access(
            self.export_dir, os.W_OK)
62998
public static boolean checkIsPathOrLinkToSvg(String path) {

        if (path == null) {
            return false;
        }
        path = path.trim().toLowerCase();
        int paramPos = path.indexOf("?");
        if (paramPos >= 0) {
            path = path.substring(0, paramPos);
        }
        return path.endsWith(".svg");
    }
1332347
private boolean shouldImport(TypeName typeName) {
        // don't import classes from the java.lang package
        String pkg = typeName.getPackageName();
        String simpleName = typeName.getSimpleName();
        boolean exclude = (pkg.equals("java.lang") || pkg.equals("")) && getJavaDefaultTypes().contains(simpleName);
        return !exclude;
    }
1002086
function isPanelHTMLFile(bundleName, filePath) {
	const bundle = module.exports.find(bundleName);
	if (bundle) {
		return bundle.dashboard.panels.some(panel => {
			return panel.path.endsWith(filePath);
		});
	}

	return false;
}
1098615
public boolean includes(int[] v) {
		if (min != null && Version.compare(v, min) < 0) return false;
		if (max == null) return true;
		int c = Version.compare(v, max);
		if (c > 0) return false;
		if (c < 0) return true;
		return maxIncluded;
	}
1085179
private boolean hasImportFile(String resourcepath) {

        Long value = m_importFileUpdateCache.get(resourcepath);
        if (value == null) {
            return false;
        }
        long age = System.currentTimeMillis() - value.longValue();
        return age < 5000;
    }
776522
def load_exports(self, args=None):
        """"""
        if args is None:
            return False
        header = "glances_"
        # Build the export module available list
        args_var = vars(locals()['args'])
        for item in os.listdir(exports_path):
            export_name = os.path.basename(item)[len(header):-3].lower()
            if (item.startswith(header) and
                    item.endswith(".py") and
                    item != (header + "export.py") and
                    item != (header + "history.py")):
                self._exports_all[export_name] = os.path.basename(item)[:-3]
                # Set the disable_<name> to False by default
                setattr(self.args,
                        'export_' + export_name,
                        getattr(self.args, 'export_' + export_name, False))

        # Aim is to check if the export module should be loaded
        for export_name in self._exports_all:
            if getattr(self.args, 'export_' + export_name, False):
                # Import the export module
                export_module = __import__(self._exports_all[export_name])
                # Add the export to the dictionary
                # The key is the module name
                # for example, the file glances_xxx.py
                # generate self._exports_list["xxx"] = ...
                self._exports[export_name] = export_module.Export(args=args,
                                                                  config=self.config)
                self._exports_all[export_name] = self._exports[export_name]

        # Log plugins list
        logger.debug("Active exports modules list: {}".format(self.getExportsList()))
        return True
163620
private boolean isClang() {
    final String command = getCommand();
    if (command == null) {
      return false;
    }
    if (command.startsWith("clang")) {
      return true;
    }
    if (!GPP_COMMAND.equals(command)) {
      return false;
    }
    final String[] cmd = {
        command, "--version"
    };
    final String[] cmdout = CaptureStreamHandler.execute(cmd).getStdout();
    return cmdout != null && cmdout.length > 0 && cmdout[0].contains("(clang-");
  }
172017
function exports(_selection) {
            _selection.each(function(_data){
                chartWidth = width - margin.left - margin.right;
                chartHeight = height - margin.top - margin.bottom;
                data = _data;

                buildSVG(this);
            });
        }
78158
def is_submodule_included(src, tgt):
    """"""
    if tgt is None or not hasattr(tgt, 'i_orig_module'):
        return True
    if (tgt.i_orig_module.keyword == 'submodule' and
        src.i_orig_module != tgt.i_orig_module and
        src.i_orig_module.i_modulename == tgt.i_orig_module.i_modulename):
        if src.i_orig_module.search_one('include',
                                        tgt.i_orig_module.arg) is None:
            return False
    return True
1298355
private boolean tableListIncludesExportOnly(List<Table> tableList) {
        // list of all export tables (assume uppercase)
        NavigableSet<String> exportTables = CatalogUtil.getExportTableNames(m_catalogDb);

        // this loop is O(number-of-joins * number-of-export-tables)
        // which seems acceptable if not great. Probably faster than
        // re-hashing the export only tables for faster lookup.
        for (Table table : tableList) {
            if (exportTables.contains(table.getTypeName()) && TableType.isStream(table.getTabletype())) {
                return true;
            }
        }

        return false;
    }
279098
def do_check(vext_files):
    
    import vext
    # not efficient ... but then there shouldn't be many of these

    all_specs = set(vext.gatekeeper.spec_files_flat())
    if vext_files == ['*']:
        vext_files = all_specs
    unknown_specs = set(vext_files) - all_specs
    for fn in unknown_specs:
        print("%s is not an installed vext file." % fn, file=sys.stderr)

    if unknown_specs:
        return False

    check_passed = True
    for fn in [join(vext.gatekeeper.spec_dir(), fn) for fn in vext_files]:
        f = open_spec(open(fn))
        modules = f.get('test_import', [])
        for success, module in vext.gatekeeper.test_imports(modules):
            if not success:
                check_passed = False
            line = "import %s: %s" % (module, '[success]' if success else '[failed]')
            print(line)
        print('')

    return check_passed
405811
function checkGraphvizInstalled(config) {
	if (config.graphVizPath) {
		const cmd = path.join(config.graphVizPath, 'gvpr -V');
		return exec(cmd)
			.catch(() => {
				throw new Error('Could not execute ' + cmd);
			});
	}

	return exec('gvpr -V')
		.catch((error) => {
			throw new Error('Graphviz could not be found. Ensure that "gvpr" is in your $PATH.\n' + error);
		});
}
470683
@Override
    public boolean isSupported(Task task) {
        for (TaskProcessorFactory factory : factories) {
            if (factory.isSupported(task)) {
                return true;
            }
        }
        return false;
    }
252881
function getExports( component ){

    if ( !component.exports ){
        component.exports =         parsePart( Components.getPartContent( component, "exports" ));
    }
    return component.exports;
}