<p>
A keyword for a finding.
</p>

@param keyword
A keyword for a finding.
333392
public void setKeyword(java.util.Collection<KeywordFilter> keyword) {
        if (keyword == null) {
            this.keyword = null;
            return;
        }

        this.keyword = new java.util.ArrayList<KeywordFilter>(keyword);
    }
175598
private static void checkForKeyword(String name) {
    if (KEYWORDS.contains(name) || KEYWORDS.contains(name.toUpperCase())) {
      throw new MolgenisDataException(
          "Name [" + name + "] is not allowed because it is a reserved keyword.");
    }
  }
1048084
@Override
    public void setPassword(final String password) {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "setPassword", "***");
        }
        _password = password;
    }
990989
private static final int findKeyword(String s, String[] list) {
        s = PatternProps.trimWhiteSpace(s).toLowerCase(rootLocale);
        for (int i = 0; i < list.length; ++i) {
            if (s.equals(list[i]))
                return i;
        }
        return -1;
    }
134844
public void consumeExpectedKeyword(String keyword) {
        if (current().matches(Token.TokenType.KEYWORD, keyword)) {
            consume();
        } else {
            addError(current(), "Unexpected token: '%s'. Expected: '%s'", current().getSource(), keyword);
        }
    }
797806
public void addWord(String word) {
        if (!vocabulary.containsKey(word)) {
            VocabularyWord vw = new VocabularyWord(word);

            /*
                TODO: this should be done in different way, since this implementation causes minWordFrequency ultimate ignoral if markAsSpecial set to TRUE
            
                Probably the best way to solve it, is remove markAsSpecial option here, and let this issue be regulated with minWordFrequency
              */
            // vw.setSpecial(markAsSpecial);

            // initialize frequencyShift only if hugeModelExpected. It's useless otherwise :)
            if (hugeModelExpected)
                vw.setFrequencyShift(new byte[retentionDelay]);

            vocabulary.put(word, vw);



            if (hugeModelExpected && minWordFrequency > 1
                            && hiddenWordsCounter.incrementAndGet() % scavengerThreshold == 0)
                activateScavenger();

            return;
        }
    }
768699
public boolean hasKeyword(String text)
    {
        checkForConstructedFailureStates();

        State currentState = this.rootState;
        for (int i = 0; i < text.length(); ++i)
        {
        	State nextState = getState(currentState, text.charAt(i));
            if (nextState != null && nextState != currentState && nextState.emit().size() != 0) {
                return true;
            }
            currentState = nextState;
        }
        return false;
    }
610068
private void doSearch()
    {
        setSearchPanelVisible(true);
        String selectedText = textComponent.getSelectedText();
        if (selectedText != null)
        {
            searchPanel.setQuery(selectedText);
        }
        searchPanel.requestFocusForTextField();
    }
173416
public void setSearchText(String searchText) {
        if (TextUtils.isEmpty(searchText)) {
            searchText = null;
        }
        this.searchText = searchText;
        if (this.searchBox != null) {
            this.searchBox.setText(searchText);
        }
    }
748283
public void setKeyPhrases(java.util.Collection<KeyPhrase> keyPhrases) {
        if (keyPhrases == null) {
            this.keyPhrases = null;
            return;
        }

        this.keyPhrases = new java.util.ArrayList<KeyPhrase>(keyPhrases);
    }
231820
public function removeKeyword(Keyword $keyword)
    {
        if ($this->keywords->contains($keyword)) {
            $this->keywords->removeElement($keyword);
        }
    }
285112
function search(keyword, typeFilter) {
        keyword = keyword.toLowerCase();
        typeFilter = typeFilter || type.Element;
        var results = findAll(function (elem) {
            var name = elem.name ? elem.name.toLowerCase() : "";
            return (name.indexOf(keyword) > -1 && elem instanceof typeFilter);
        });
        return results;
    }
1048266
def _Keyword(self, t):
        
        self._write(t.name)
        self._write("=")
        self._dispatch(t.expr)
308482
public static KeywordInfo getKeywordInfo(String keyword, ApplicationContext context, Map<String, String> beanMap) {
        Object bean = context.getBean(beanMap.get(keyword));
        return AnnotationUtils.findAnnotation(bean.getClass(), KeywordInfo.class);
    }
877662
public static boolean match(String keyword, String mappingId) {
		if (mappingId.indexOf(keyword) != -1) { // match found!
			return true;
		}
		return false;
	}
698707
public void setFindings(java.util.Collection<Finding> findings) {
        if (findings == null) {
            this.findings = null;
            return;
        }

        this.findings = new java.util.ArrayList<Finding>(findings);
    }
679612
@SuppressWarnings("static-method")
	protected String protectCommentKeyword(String keyword) {
		if ("*/".equals(keyword)) { //$NON-NLS-1$
			return "* /"; //$NON-NLS-1$
		}
		if ("/*".equals(keyword)) { //$NON-NLS-1$
			return "/ *"; //$NON-NLS-1$
		}
		if ("//".equals(keyword)) { //$NON-NLS-1$
			return "/ /"; //$NON-NLS-1$
		}
		return keyword;
	}