<p>
createMetaphoneVersionOfKeyword.
</p>

@param _keyword a {@link java.lang.String} object.
@return a {@link java.lang.String} object.
341725
static public String createMetaphoneVersionOfKeyword(final String _keyword)
    {
        if (_keyword == null || _keyword.trim().length() == 0)
            return null;
        return new Metaphone().metaphone(_keyword);
    }
1211019
public String getMetadataSingleString(String name) {
    String s = "";
    if (metadata == null)
      createMetadataDictionary();
    if (metadata.contains(name))
      s = metadata.get(name).toString();
    return s;
  }
1075698
public void setKeywords(final List<String> keywords) {
        StringBuilder builder = new StringBuilder();
        for (String keyword: keywords) {
            if (builder.length() > 0) {
                builder.append(',');
            }
            builder.append(keyword.trim());
        }
        this.keywords = Optional.of(builder.toString());
    }
1267426
public static Keyword keyword(Object o) {
        if (o instanceof Keyword)
            return (Keyword) o;
        else if (o instanceof String) {
            String s = (String) o;
            if (s.charAt(0) == ':')
                return new KeywordImpl(s.substring(1));
            else
                return new KeywordImpl(s);
        }
        else throw new IllegalArgumentException("Cannot make keyword from " + o.getClass().getSimpleName());
    }
955820
public static Vertex newPunctuationInstance(String realWord)
    {
        return new Vertex(realWord, new CoreDictionary.Attribute(Nature.w, 1000));
    }
939768
private static final String getKey(String apiVersion, String kind) {
        if (kind == null) {
            return null;
        } else if (apiVersion == null) {
            return kind;
        } else {
            return String.format("%s#%s", apiVersion, kind);
        }
    }
1363832
public static Version stringToVersion(String str) {
        if (str == null || str.isEmpty() || str.equals("0")) {
            return Version.emptyVersion;
        }

        if (str.equals("1") || str.equals("1.0") || str.equals("1.0.0"))
            return VERSION_1_0;

        return new Version(str);
    }
775206
public static Leaderboard getFromDKV(String param_name, String key_str) {
    return getFromDKV(param_name, Key.make(key_str));
  }
828211
protected List<Map<String, ?>> generateSpecialKeywords(Set<String> keywords) {
		final List<Map<String, ?>> list = new ArrayList<>();
		if (!keywords.isEmpty()) {
			list.add(pattern(it -> {
				it.matches(keywordRegex(keywords));
				it.style(SPECIAL_KEYWORD_STYLE);
				it.comment("Special Keywords"); //$NON-NLS-1$
			}));
		}
		return list;
	}
267846
public final void keyword_key() throws RecognitionException {
		try {
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:168:5: ( VT_KEYWORD )
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:168:7: VT_KEYWORD
			{
			match(input,VT_KEYWORD,FOLLOW_VT_KEYWORD_in_keyword_key548); 
			entry_stack.peek().retval.setSection(DSLMappingEntry.KEYWORD);
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
	}
645782
@Nullable
    public static EnhancedMimeType create(@Nullable final String str) {
        if (str == null) {
            return null;
        }
        try {
            return new EnhancedMimeType(str);
        } catch (final MimeTypeParseException ex) {
            throw new RuntimeException("Failed to create versioned mime type: " + str, ex);
        }
    }
985549
public function createKeywordIfNotExists($keyword, $do_persist = true)
    {
        if (null === $keyword_object = $this->em->getRepository('BackBee\NestedNode\KeyWord')->exists($keyword)) {
            $keyword_object = new \BackBee\NestedNode\KeyWord();
            $keyword_object->setRoot($this->em->find('BackBee\NestedNode\KeyWord', md5('root')));
            $keyword_object->setKeyWord(preg_replace('#[/\"]#', '', trim($keyword)));

            if (true === $do_persist) {
                $this->em->persist($keyword_object);
                $this->em->flush($keyword_object);
            }
        }

        return $keyword_object;
    }
125550
def get_keywords_as_string(keywords):
        
        if type(keywords) is list:
            keywords = ', '.join(keywords)
        if type(keywords) is str:
            final_keywords = keywords
        elif type(keywords) is unicode:
            final_keywords = keywords.encode('utf-8')
        elif keywords is None:
            final_keywords = ""
        else:
            raise TypeError("keywords argument must be a string or a list of strings; got a %s" % type(keywords))
        return final_keywords
68455
def _do_create_keywords(args, kw):
    
    v = kw.get('varlist', ())
    # prevent varlist="FOO" from being interpreted as ['F', 'O', 'O']
    if is_String(v): v = (v,)
    kw['varlist'] = tuple(v)
    if args:
        # turn positional args into equivalent keywords
        cmdstrfunc = args[0]
        if cmdstrfunc is None or is_String(cmdstrfunc):
            kw['cmdstr'] = cmdstrfunc
        elif callable(cmdstrfunc):
            kw['strfunction'] = cmdstrfunc
        else:
            raise SCons.Errors.UserError(
                'Invalid command display variable type. '
                'You must either pass a string or a callback which '
                'accepts (target, source, env) as parameters.')
        if len(args) > 1:
            kw['varlist'] = tuple(SCons.Util.flatten(args[1:])) + kw['varlist']
    if kw.get('strfunction', _null) is not _null \
                      and kw.get('cmdstr', _null) is not _null:
        raise SCons.Errors.UserError(
            'Cannot have both strfunction and cmdstr args to Action()')
699760
public String getKeywords()
    {
        if (this.getProperty(XMLTags.META_KEYWORDS) != null)
            return this.getProperty(XMLTags.META_KEYWORDS);
        return DBConstants.BLANK;  // Override this
    }
257785
static AttrVersion createFromString(final String str)
    throws BOSHException {
        if (str == null) {
            return null;
        } else {
            return new AttrVersion(str);
        }
    }
826921
public com.google.appengine.v1.CreateVersionMethod getCreateVersion() {
    if (methodCase_ == 2) {
       return (com.google.appengine.v1.CreateVersionMethod) method_;
    }
    return com.google.appengine.v1.CreateVersionMethod.getDefaultInstance();
  }