Inflects the anthroponym.

@param {object} anthroponym
@param {string} anthroponym.firstName
@param {string} anthroponym.lastName
@param {string} anthroponym.middleName
@param {string} anthroponym.gender
@param {string} inflectionCase
351569
function shevchenko(anthroponym, inflectionCase) {
  return anthroponymInflector.inflect(new Anthroponym(anthroponym), new InflectionCase(inflectionCase)).toObject();
}
768598
function (name, lastname) {
		name = name || this.exports.generate.name();
		lastname = lastname || this.exports.generate.lastName();
		var ret = name + '.' + lastname + '@' + this.exports.generate.domain();
		return ret.replace(/ /g, '').toLowerCase();
	}
1168043
private static void insertName(String name, int activeLine, WordNet wordNetOptimum, WordNet wordNetAll)
    {
        if (isBadCase(name)) return;
        wordNetOptimum.insert(activeLine, new Vertex(Predefine.TAG_PEOPLE, name, new CoreDictionary.Attribute(Nature.nrj), WORD_ID), wordNetAll);
    }
983841
function parseName(name) {
  if (name) {
    const arr = name.split('.')
    const len = arr.length

    if (len > 2) {
      return arr.slice(0, -1).join('.')
    }
    else if (len === 2 || len === 1) {
      return arr[0]
    }
  }
  return name
}
77396
public void setGender(String v) {
    if (PronounFeats_Type.featOkTst && ((PronounFeats_Type)jcasType).casFeat_gender == null)
      jcasType.jcas.throwFeatMissing("gender", "de.julielab.jules.types.PronounFeats");
    jcasType.ll_cas.ll_setStringValue(addr, ((PronounFeats_Type)jcasType).casFeatCode_gender, v);}
274687
function checkNamePrefix1(i) {
  const start = i;
  let l;

  if (l = checkNamespacePrefix(i)) i += l;
  else return 0;

  if (l = checkCommentML(i)) i += l;

  if (l = checkNamespaceSeparator(i)) i += l;
  else return 0;

  return i - start;
}
1032912
def full_name(self):
        """"""
        if self.first_name and self.middle_name and self.last_name:
            return "%s %s %s" % (self.first_name, self.middle_name, self.last_name)
        if self.first_name and self.last_name:
            return "%s %s" % (self.first_name, self.last_name)
8619
def name(gender = :any)
      case gender
      when :any then rand(0..1) == 0 ? name(:male) : name(:female)
      when :male then fetch_sample(MALE_FIRST_NAMES)
      when :female then fetch_sample(FEMALE_FIRST_NAMES)
      else raise ArgumentError, 'Invalid gender, must be one of :any, :male, :female'
      end
    end
364687
def split_name(obj):
    
    if obj['_type'] in ('person', 'legislator'):
        for key in ('first_name', 'last_name'):
            if key not in obj or not obj[key]:
                # Need to split
                (obj['first_name'], obj['last_name'],
                 obj['suffixes']) = name_tools.split(obj['full_name'])[1:]
                break

    return obj
673816
function toDisplayName(name) {
        var extIndex = name.lastIndexOf('.');
        name = name.substring(0, extIndex !== -1 ? extIndex : undefined).replace(/-/g, ' ');

        return name.split(" ").map(function (part) {
            return part[0].toUpperCase() + part.substring(1);
        }).join(" ");
    }
622097
function checkSemanticActionName(node) {
  var name = node.name;
  var underscoreIdx = name.indexOf('_');

  // The underscore should not appear on the ends,
  // case names should begin with a lowercase letter,
  // and there should be only one underscore in the name.
  if ((underscoreIdx > 0 && underscoreIdx < (name.length - 1)) &&
      name[underscoreIdx + 1] === name[underscoreIdx + 1].toLowerCase() &&
      name.indexOf('_', underscoreIdx + 1) === -1) {
    return true;
  }
  return false;
}
951910
function nameValMatch(definedNameVals, lookupKey) {
    var keys = _.keys(definedNameVals),
        key,
        index;
    for (index in keys) {
        key = keys[index];
        if (key === lookupKey) {
            return {
                matchedWith: lookupKey,
                match: definedNameVals[key]
            };
        } else if (!definedNameVals[key].matchKeyCase && (key.toUpperCase() === (lookupKey.toUpperCase()))) {
            return {
                matchedWith: key,
                match: definedNameVals[key]
            };
        }
    }
    return null;
}
537159
def full_name(self, gender: Optional[Gender] = None,
                  reverse: bool = False) -> str:
        
        if gender is None:
            gender = get_random_item(Gender, rnd=self.random)

        if gender and isinstance(gender, Gender):
            gender = gender
        else:
            raise NonEnumerableError(Gender)

        fmt = '{1} {0}' if reverse else '{0} {1}'
        return fmt.format(
            self.name(gender),
            self.surname(gender),
        )
643244
function(match, shortNames, longNames) {
			var names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
				return [ [k, v] ];
			}).sort(function (a, b) {
				return -(a[1].length - b[1].length);
			});
			var index = -1;
			$.each(names, function (i, pair) {
				var name = pair[1];
				if (value.substr(iValue, name.length).toLowerCase() == name.toLowerCase()) {
					index = pair[0];
					iValue += name.length;
					return false;
				}
			});
			if (index != -1)
				return index + 1;
			else
				throw 'Unknown name at position ' + iValue;
		}
162223
function fullnameFormatter( first, last, middle ) {
	return ''.concat(first,
		(last) ? ' '.concat(last) : '',
		(middle) ? ' '.concat(middle) : '');
}
1346672
public void setUsernameStyle(@UsernameStyle int style) {
        if (style == EMAIL || !usernameRequired) {
            setDataType(DataType.EMAIL);
        } else if (style == USERNAME) {
            setDataType(DataType.USERNAME);
            String errorDescription = isCustomDatabase ? getResources().getString(R.string.com_auth0_lock_input_error_username_empty) :
                    getResources().getString(R.string.com_auth0_lock_input_error_username, minUsernameLength, maxUsernameLength);
            setErrorDescription(errorDescription);
        } else if (style == DEFAULT) {
            setDataType(DataType.USERNAME_OR_EMAIL);
        }
    }
378540
function Node(grammar, ctorName, matchLength) {
  this.grammar = grammar;
  this.ctorName = ctorName;
  this.matchLength = matchLength;
}