Sets `sysparm_exclude_reference_link` to a bool value

        :param exclude: bool
14567
def exclude_reference_link(self, exclude):
        
        if not isinstance(exclude, bool):
            raise InvalidUsage('exclude_reference_link must be of type bool')

        self._sysparms['sysparm_exclude_reference_link'] = exclude
918219
private void restoreExcludesFile(File excludesFileFile) throws MojoExecutionException {
        if (!excludesFileFile.exists()) {
            return;
        }

        try {
            String[] lines = FileUtil.readLines(excludesFileFile);
            List<String> newLines = new ArrayList<String>();
            for (String line : lines) {
                if (line.equals(EKSTAZI_LINE_MARKER)) break;
                newLines.add(line);
            }
            FileUtil.writeLines(excludesFileFile, newLines);
        } catch (IOException ex) {
            throw new MojoExecutionException("Could not restore 'excludesFile'", ex);
        }
    }
734328
def is_ignored(resource):
    ''''''
    ignored_domains = current_app.config['LINKCHECKING_IGNORE_DOMAINS']
    url = resource.url
    if url:
        parsed_url = urlparse(url)
        return parsed_url.netloc in ignored_domains
    return True
1371591
function retrieveFilesToExclude(excludeFiles) {
  return globby.sync(excludeFiles).map(function(file) {
    return path.normalize(file);
  });
}
1151889
def unlink_reference(self, source, target):
        
        target_uid = api.get_uid(target)
        # get the storage key
        key = self.get_relationship_key(target)
        # get all backreferences from the source
        # N.B. only like this we get the persistent mapping!
        backrefs = get_backreferences(source, relationship=None)
        if key not in backrefs:
            logger.warn(
                "Referenced object {} has no backreferences for the key {}"
                .format(repr(source), key))
            return False
        if target_uid not in backrefs[key]:
            logger.warn("Target {} was not linked by {}"
                        .format(repr(target), repr(source)))
            return False
        backrefs[key].remove(target_uid)
        return True
87891
function(relatedLinks, exclusions) {
			this._categorizedRelatedLinks = {};
			relatedLinks.forEach(function(info) {
				var relatedLink = info.relatedLink;
				var command = info.command;
				var invocation = info.invocation;
				if (!exclusions || exclusions.indexOf(relatedLink.id) === -1) {
					var category = relatedLink.category;
					this._categorizedRelatedLinks[category] = this._categorizedRelatedLinks[category] || [];
					this._categorizedRelatedLinks[category].push({
						title: command.name,
						order: relatedLink.order || 100,
						href: command.hrefCallback.call(invocation.handler, invocation)
					});
				}
			}, this);
			this._updateCategoryAnchors();
			this._updateCategoryNotifications();
		}
1335659
def normalize_excludes(rootpath, excludes):
    
    sep = os.path.sep
    f_excludes = []
    for exclude in excludes:
        if not os.path.isabs(exclude) and not exclude.startswith(rootpath):
            exclude = os.path.join(rootpath, exclude)
        if not exclude.endswith(sep):
            exclude += sep
        f_excludes.append(exclude)
    return f_excludes
1219441
def _is_excluded(self, path, dir_only):
        """"""

        return self.npatterns and self._match_excluded(path, self.npatterns)
71969
def clean(args):
    
    p = OptionParser(clean.__doc__)
    opts, args = p.parse_args(args)

    for link_name in os.listdir(os.getcwd()):
        if not op.islink(link_name):
            continue
        logging.debug("remove symlink `{0}`".format(link_name))
        os.unlink(link_name)
282575
def is_excluded(self, path):
        
        match = self.globster.match(self.relpath(path))
        if match:
            log.debug("{0} matched {1} for exclusion".format(path, match))
            return True
        return False
1139023
def exclude_options(ignore_file_path)
      ar = File.read(ignore_file_path)
      ar = ar.split("\n")
      ar.map! do |r|
        r.gsub!(/#.*$/,""); r.gsub!(/^\s*?$/,"")
        r.gsub!(/^\//,"./"); r.gsub!(/\/$/,"/*")
        r
      end
      ar =  ar.delete_if{|r|r==""}
      ar.map! do |r|
        "--exclude '" + r + "'"
      end
      return ar.join(" ")
    end
1359215
def exclude_by_filter(self, filename, module_name):
        '''
        
        '''
        for exclude_filter in self._exclude_filters:  # : :type exclude_filter: ExcludeFilter
            if exclude_filter.is_path:
                if glob_matches_path(filename, exclude_filter.name):
                    if exclude_filter.exclude:
                        pydev_log.debug("File %s ignored by filter %s" % (filename, exclude_filter.name))
                    return exclude_filter.exclude
            else:
                # Module filter.
                if exclude_filter.name == module_name or module_name.startswith(exclude_filter.name + '.'):
                    return exclude_filter.exclude
        return None
868084
public function setExcludeSelf($s = 'true'){
        if ($s == 'true' || (is_bool($s) && $s == true)){
            $this->options['ExcludeMe'] = 'true';
        } else if ($s == 'false' || (is_bool($s) && $s == false)){
            $this->options['ExcludeMe'] = 'false';
        } else {
            return false;
        }
    }
805395
def validate_include_exclude(include, exclude):
    
    if include is not None and exclude is not None:
        raise ValueError("Only one of 'include' or 'exclude' argument should be provided.")
    validate('include', include, instance_of=(str, Sequence), enforce_not_none=False)
    validate('exclude', exclude, instance_of=(str, Sequence), enforce_not_none=False)
471613
def remove_exclusion(self, role, value=None):
        

        self._remove_rule(self.excludes, role, value)
1128620
public void setExcludedOperatingSystemVersions(com.google.api.ads.admanager.axis.v201902.Technology[] excludedOperatingSystemVersions) {
        this.excludedOperatingSystemVersions = excludedOperatingSystemVersions;
    }
1228913
def linkify(self, timeperiods):
        
        new_exclude = []
        if hasattr(self, 'exclude') and self.exclude != []:
            logger.debug("[timeentry::%s] have excluded %s", self.get_name(), self.exclude)
            excluded_tps = self.exclude
            for tp_name in excluded_tps:
                timepriod = timeperiods.find_by_name(tp_name.strip())
                if timepriod is not None:
                    new_exclude.append(timepriod.uuid)
                else:
                    msg = "[timeentry::%s] unknown %s timeperiod" % (self.get_name(), tp_name)
                    self.add_error(msg)
        self.exclude = new_exclude