Reference Guide#

Introduction #

Use Name Object to increase response rates with personalized messages, merge individual components into form documents, identify gender makeup of your list for more targeted marketing, and reduce waste on fraudulent entries.

Name Object takes a string containing one or two full names, such as “John James Smith” or “Mr. John J. Smith and Ms. Mary Jones,” and breaks it into first, middle and last names, as well as any titles, generational suffixes, or other information.

Name Object will also indicate the gender of the person based on the first name, if possible. For instance, “James” would return an “M” for male, “Cheryl” an “F” for female, but names like “Chris” or “Tracy” can be either male or female and would return “N” for “neutral.” Name Object can be configured to give preference to either male or female for lists that have a strong bias toward one gender or another.

Name Object will also flag names containing possible vulgar words to help you screen out possible hoaxes, pranks, nuisance names (“Mickey Mouse”) and possible Company Names (“Microsoft, Inc”). It can also create salutations, such as “Dear Mr. Jones,” using the parsed name information (Salutation uses the first person’s name if two full names are present).

Name Object automates the handling of name data, making it simple to send personalized business mail, tailored specifically to the gender of the people in your mailing list, while screening out vulgar or obviously false names.

Parse full names into first, middle, and last names, as well as prefixes like “Dr.” and suffixes like “Jr.”
Handle name strings that include two names, such as “John and Mary Jones.”
Correct misspelled first names.
Flag vulgar names and names that are obviously false.
Validate first and last names against a database of 100,000 first names and 90,000 last names, covering 99% of the U.S. population.
Assign gender based on the first name. This can be done as part of parsing or by itself.
Select how aggressively Name Object determines the gender of names, based on the known gender bias of the mailing list, if any.
Create personalized salutations for business mail. This can be done as part of parsing or by itself.
Add your own names, misspellings, vulgar words, and matching patterns.

Setup and List of Files #

To see how to set up the Name Object, the list of files that will be downloaded and used, and the system requirements to run the Object, please visit the GitHub Sample Code.

Methods #

Initialize Name Object - Set #

These functions initialize Name Object and connect it to its data files.

InitializeDataFiles #

Syntax:: InitializeDataFiles();
Returns:: Initialization Status
Return Type:: ProgramStatus

The InitializeDataFiles function opens the needed data files and prepares the Name Object for use.

Remarks

Before calling this function, you must have successfully called the SetPathToNameFiles function. If not using an environment variable, you must also call the SetLicenseString function.

Check the return value of the GetInitializeErrorString function to retrieve the result of the initialization call. Any result other than “No Error” means the initialization failed for some reason.

Return Value

This function returns a value of the enumerated type ProgramStatus.

Code	Description
0 - NoError	No error - initialization was successful.
1 - ConfigFile	Could not find mdName.dat.
2 - LicenseExpired	License key has expired.
3 - Unknown	An unknown error has occurred.

If any other value other than NoError is returned, check the GetInitializeErrorString function to see the reason for the error.

SetLicenseString #

Syntax:: SetLicenseString(String License);
Returns:: Is License Valid
Return Type:: Boolean

The License String is a software key (supplied by the developer) that unlocks the full functionality of Name Object.

Remarks

The license string is included with the documentation you received. If you have not purchased a license, call Melissa Data toll free at 1-800-MELISSA (1-800-635-4772) or send an email to sales@MelissaData.com.

If the SetLicenseString function is not called or an incorrect license string is used, Name Object will not operate.

The license string is normally set using an environment variable, either MD_LICENSE or MD_LICENSE_DEMO. Calling SetLicenseString is an alternative method for setting the license string, but applications developed for a production environment should only use the environment variable.

When using an environment variable, it is not necessary to call the SetLicenseString function.

For more information on setting the environment variable, see page 2 of this guide.

If a valid license string function is not set, Name Object will not operate.

Input Parameters

The SetLicenseString function has one parameter:

LicenseString:: A string value representing the software license key.

Return Value

The SetLicenseString function returns a Boolean value of 0 (FALSE) or 1 (TRUE). It will return a FALSE Boolean value if the license string provided is incorrect.

SetPathToNameFiles #

Syntax:: SetPathToNameFiles(String FilePath);
Returns:: Void

This function accepts a string value parameter that sets the path to the folder containing the mdName.dat file.

Remarks: This function must be set before calling the InitializeDataFiles function.

Initialize Name Object - Get #

The following functions get values related to the initialization process.

GetBuildNumber #

Syntax:: GetBuildNumber();
Returns:: Build Number
Return Type:: String

The GetBuildNumber function returns the current development release build number of Name Object.

GetDatabaseDate #

Syntax:: GetDatabaseDate();
Returns:: Database Date
Return Type:: String

The GetDatabaseDate function returns a string value that represents the revision date of your Name Object data files.

GetDatabaseExpirationDate #

Syntax:: GetDatabaseExpirationDate();
Returns:: Database Expiration Date
Return Type:: String

This function returns a string value indicating the expiration date of the current database file (mdName.dat).

GetInitializeErrorString #

Syntax:: GetInitializeErrorString();
Returns:: Error Description
Return Type:: String

This function returns a descriptive string value to describe the error from the InitializeDataFiles function.

Remarks: The GetInitializeErrorString function returns a string value describing the error caused when the InitializeDataFiles function cannot be called successfully

GetLicenseExpirationDate #

Syntax:: GetLicenseExpirationDate();
Returns:: License Expiration Date
Return Type:: String

This function returns a string value containing the expiration date of the current license string.

Remarks: Call this function to determine when your current license will expire. After this date, Name Object will no longer function.

Configure Name Object Options #

These functions select, enable or disable the various options of Name Object.

AddSalutation #

Syntax:: AddSalutation(enum Salutations);
Return Type:: Void

This function sets the order of precedence for formats to use when creating a salutation.

Remarks

Use this function to select the preferred format or formats to use when generating salutations via the Parse or Salutate function.

There are four possible formats to use for creating salutations. The options are:

Format	Example
Formal	Dear Mr. Smith:
Informal	Dear John:
First/Last	Dear John Smith:
Slug	Dear Valued Customer:
Blank	No Salutation

If the AddSalutation function has not been called, Name Object will attempt to create a salutation using the following order. Formal, Informal, First/Last, and Slug. In other words, Name Object will attempt to create a formal salutation and, if unable to genderize the name, will attempt to use the informal salutation next.

This function allows you to set your own order and excluded unwanted salutation formats.

Example

The following Visual Basic code would switch the preference order of the Informal and First/Last salutation.

NameObj->AddSalutation(Formal)
NameObj->AddSalutation(FirstLast)
NameObj->AddSalutation(Informal)
NameObj->AddSalutation(Slug)

Name Object only considers the first four calls to the AddSalutation function will be recognized. Any more will be ignored.

Values

The AddSalutation function uses an enumerated value of the type Salutations.

Option	Value
Formal	0
Informal	1
First/Last	2
Slug	3
Blank	4

ClearProperties #

Syntax:: ClearProperties();
Return Type:: Void

This function clears both the return values and parameters of the various name string functions.

Remarks

This function resets the following functions to empty strings:

SetPrefix      SetPrefix2      SetFirstName  SetFirstName2
SetLastName    SetSuffix       SetSuffix2    SetFullName
GetPrefix      SetPrefix       GetFirstName  GetMiddleName
GetLastName    GetSuffix       GetGender     GetPrefix2
GetFirstName2  GetMiddleName2  GetLastName2  GetSuffix2
GetGender2     GetSalutation   GetResults

This prevents values from the previous call to the Parse, Genderize or Salutate function from persisting and potentially causing confusion with values from the current call.

SetFirstNameSpellingCorrection #

Syntax:: SetFirstNameSpellingCorrection(int);
Return Type:: Void

This function accepts an integer value that enables or disables spelling correction of first names during parsing.

Remarks

Name Object uses a database of common misspelled given names to correct the return values of GetFirstName and GetFirstName2 functions.

Set this function to 1 to enable this feature. Set it to 0 to disable

SetGenderAggression #

Syntax:: SetGenderAggression(int);
Return Type:: Void

This function sets how aggressively Name Object will attempt to genderize neutral first names.

Remarks

Normally, Name Object will assign a value of “N” when attempting to genderize a first name that can easily be male or female, such as “Pat,” “Chris” or “Tracy.” Every name is assigned a score from 7 to 1, with 7 being always male, 4 being completely neutral, and 1 being always female.

Using this function in conjunction with the SetGenderPopulation function, you can instruct Name Object how much preference it gives to one gender or the other when assigning a gender to a normally neutral name. This function can accept the following values.

Definition
Aggressive
Neutral
Conservative

This table shows how the settings for SetGenderAgression and SetGenderPopulation affect genderizing.

SetGenderPopulation #

Syntax:: SetGenderPopulation(enum );
Return Type:: Void

This function sets the gender balance of the source data, either predominantly male, predominantly female or neutral.

Remarks

If you know that a mailing will be comprised of predominantly one gender or the other, use this function to set the gender bias to use when genderizing names, either via the Parse or Genderize function.

SetGenderPopulation accepts an enumerated value. The possible values for this function are:

Value	Definition
Male	Bias toward male
Mixed	Evenly split.
Female	Bias toward female

See SetGenderAggression for more information on how Name Object assigns gender to a first name.

SetMiddleNameLogic #

Syntax:: SetMiddleNameLogic(enum MiddleNameLogic);
Return Type:: Void

This function controls the settings for how Name Object deals with middle names.

Remarks

Some names can be ambiguous with regards to the middle word of a full name. It may be a middle name or it may be the first part of a hyphenated last name, but the hyphen has been omitted for some reason.

Normally, Name Object assumes that, in the absence of a hyphen, recognizable last names in the middle of a full name are treated as part of a hyphenated last name. “Mary O’Malley Kelly” is parsed into first name “Mary” and last name “O’Malley-Kelly.”

On the other hand, “Colleen Marie Sullivan” is parsed into first name “Colleen,” middle name “Marie,” and last name “Sullivan.”

This function accepts an enumerated value of the type MiddleNameLogic. The value of the enumerated parameter determines the setting for the middle name logic.

Enum Value	Val	Setting
ParseLogic	0	Default value. Name Object behaves as described above. This is how Name Object behaves if this function is not called.
HypenatedLast	1	The middle word is assumed to be part of the last name. “Matthew Edward Jones” is treated as “Matthew Edward Jones.”
MiddleName	2	The middle word is assumed to be a middle name. For the name “Mary O’Malley Kelly,” O’Malley is assumed to be the middle name.

When a hyphen is present, the hyphenated word is always treated as the last name, regardless of content

SetPrimaryNameHint #

Syntax:: SetPrimaryNameHint(int nameHintVal);
Return Type:: Void

This function sets an integer value indicating the most likely format of the value passed to the SetFullName function.

Remarks

This setting helps the name parser in cases when the order and formatting of the SetFullName function value are unclear.

Full or normal name order is <Prefix> <FirstName> <MiddleName> <LastName> <Suffix>.

Inverse name order is <LastName> <Suffix>, <Prefix> <FirstName> <MiddleName>.

The default is 4 (“Varying”). The possible values are:

Code	Meaning	Setting
1	DefinitelyFull	Name will always be treated as normal name order, regardless of formatting or punctuation.
2	VeryLikelyFull	Name will be treated as normal name order unless inverse order is clearly indicated by formatting or punctuation.
3	ProbablyFull	If necessary, statistical logic will be employed to determine name order, with a bias toward normal name order.
4	Varying	If necessary, statistical logic will be employed to determine name order, with no bias toward either name order.
5	ProbablyInverse	If necessary, statistical logic will be employed to determine name order, with a bias toward inverse name order.
6	VeryLikelyInverse	Name will be treated as inverse name order unless normal order is clearly indicated by formatting or punctuation.
7	Definitely Inverse	Name will always be treated as inverse name order, regardless of formatting or punctuation.
8	MixedFirstName	Name field is expected to only contain prefixes, first, and middle names.
9	MixedLastName	Name field is expected to only contain last names and suffixes.

SetSalutationPrefix #

Syntax:: SetSalutationPrefix(String salutationPrefix);
Return Type:: Void

Accepts a string value and sets the text preceding the name for salutations generated by the Parse and Salutate functions.

Remarks: This function lets you set the preferred text that you want before the proper name in salutations generated by the Parse and Salutate functions. The default = “Dear.”

SetSalutationSlug #

Syntax:: SetSalutationSlug(String salutationSlug);
Return Type:: Void

Accepts a string value and sets the text that will be substituted for a name into salutations generated by the Parse and Salutate functions, when no parsed or parseable name are present in the required functions.

Remarks

If the value passed to the SetFullName function cannot be parsed by the Parse function, or there is insufficient information in the return values of the SetPrefix, SetFirstName, SetLastName and SetSuffix functions for the Salutate function to successfully generate a salutation, this string will be substituted for the name.

The default value is “Valued Customer.”

SetSalutationSuffix #

Syntax:: SetSalutationSuffix(String salutationSuffix);
Return Type:: Void

Accepts a string value and sets the text that follows the name for salutations generated by the Parse and Salutate functions.

Remarks: This function lets you set the preferred text that you want after the proper name in salutations generated by the Parse and Salutate functions. The default = “;”

Set Input Values #

The following functions populate the values to be processed by the Parse, Genderize and Salutate functions.

SetFirstName #

Syntax:: SetFirstName(String firstName);
Return Type:: Void

This function sets the first name prior to a call to either the Genderize or Salutate function.

Remarks: This function passes a pre-parsed first name prior to a call to either the Genderize or Salutate function.

SetFirstName2 #

Syntax:: SetFirstName2(String firstName2);
Return Type:: Void

This function sets a second first name prior to a call to the Genderize function.

Remarks: This function passes an optional second pre-parsed first name prior to a call to the Genderize function.

SetFullName #

Syntax:: SetFullName(String fullName);
Return Type:: Void

This function sets the full name to be processed by the Parse function.

Remarks

This function passes the text to be processed by a call to the Parse function. It must be populated before the Parse function can be called.

This function can contain one or two names. The following strings are all valid.

“Mr. John Q. Smith, Jr.”
“Ms. Mary S. Jones”
“John Q. and Mary S. Smith”
“John Q. Smith and Mary S. Jones”
“Smith, John Q. and Mary S.”

These are just examples and not the only valid formats for full name strings.

SetLastName #

Syntax:: SetLastName(String lastName);
Return Type:: Void

This function sets the last name prior to a call to the Salutate function.

Remarks: Use this function to pass a pre-parsed last name prior to a call to the Salutate function.

SetPrefix #

Syntax:: SetPrefix(String prefix);
Return Type:: Void

This function sets the name prefix prior to a call to the Salutate or Genderize function.

Remarks: Use this function to pass a pre-parsed prefix prior to a call to the Salutate or Genderize function.

SetPrefix2 #

Syntax:: SetPrefix2(String prefix2);
Return Type:: Void

This function sets the second name prefix prior to a call to the Genderize function.

Remarks: Use this function to pass a pre-parsed prefix prior to a call to the Genderize function.

SetSuffix #

Syntax:: SetSuffix(String suffix);
Return Type:: Void

This function sets the first name suffix prior to a call to the Salutate or Genderize function.

Remarks: Use this function to pass a pre-parsed suffix prior to a call to the Salutate or Genderize function.

SetSuffix2 #

Syntax:: SetSuffix2(String suffix2);
Return Type:: Void

This function sets the second name suffix prior to a call to the Salutate or Genderize function.

Remarks: Use this function to pass a pre-parsed suffix prior to a call to the Genderize function.

Process the Name Data #

The following functions parse a full name, genderize one or two first names or construct a salutation.

Genderize #

Syntax:: Genderize();
Returns:: Is Successful
Return Type:: Integer

This function determines the gender from pre-parsed data passed to the SetPrefix, SetFirstName, and/or SetSuffix function and (if set) the SetPrefix2, SetFirstName2, and/or SetSuffix2 function.

Remarks

Genderizing is primarily based on gender data for first names, but Name Object will also use Prefix or Suffix information to improve accuracy. For example, a suffix of “Ms.” would clearly indicate a woman’s name, even if the name was predominantly male (such as “Michael,” which can be a woman’s name), while a suffix of “Sr.” or “Jr.” would suggest a man’s name, even if the first name was normal female or indeterminate (such as “Chris” or “Kim”).

None of the functions above are specifically required. Genderizing can be done solely on the basis of suffix values, if necessary. Obviously, at least some information is required for genderizing to take place.

After values have been passed to any of the above functions, the Genderize function will attempt to assign a gender to each name. Use the GetGender and GetGender2 functions respectively to retrieve the gender information

If you are working with unparsed full names, you should used the Parse function instead.

Parse #

Syntax:: Parse();
Returns:: Is Successful
Return Type:: Integer

This function parses the string value passed to the SetFullName function and extracts prefix, first name, middle name, last name, and suffix information for up to two names. It also genderizes the first names and generates a salutation for one of the full names extracted.

Remarks

The Parse function analyzes the contents of the SetFullName function, populating the return values of as many of the following functions as possible:

GetPrefix        SetPrefix         GetFirstName    GetMiddleName
GetLastName      GetSuffix         GetGender       GetPrefix2
GetFirstName2    GetMiddleName2    GetLastName2    GetSuffix2
GetGender2       GetSalutation     GetResults

The SetFullName function must be called before the Parse function is called. The InitializeDataFiles function must also have been successfully called before invoking the Parse function.

If more than one name is present in the parameter of the SetFullName function, the Parse function will create a salutation for the first name listed only. In other words, if the value of the SetFullName function contains “John and Mary Smith,” the GetSalutation function will return “Mr. Smith” only.

After a Parse function call, the GetResults function will return an “NS01” code if the parsing was successful, “NS02” otherwise.

Salutate #

Syntax:: Salutate();
Returns:: Is Successful
Return Type:: Integer

This function creates a salutation from the pre-parsed values passed to the SetPrefix, SetFirstName, SetLastName, and SetSuffix functions and populates the value returned by the GetSalutation function.

Remarks

If you already have parsed name data, you can use this function to automatically generate a salutation, using the salutation setting established in the AddSalutation function.

The Salutate function only uses the values passed via the SetPrefix, SetFirstName, SetLastName, and SetSuffix functions. At the very minimum The SetFirstName and SetLastName functions must be called prior to calling the Salutate function.

If you are working with unparsed full names, you should use the Parse function instead.

StandardizeCompany #

Syntax:: StandardizeCompany();
Returns:: Standardized Company Name
Return Type:: String

This function standardizes a company name using common abbreviations and capitalization.

Remarks

This function accepts a single string value containing a company and returns a string value containing the same company name with standard abbreviations, punctuation and capitalization rules applied.

Standard words are shortened. “Incorporated” would become “Inc.” and “Corporation” would be shortened to “Corp.”

Unrecognized words four characters or shorter are assumed to be acronyms or initialisms and converted to all upper case.

All other words would be capitalized.

Retrieve Status Information #

The following functions return information on the results of the last call to the Parse, Genderize or Salutate function.

GetResults #

Syntax:: GetResults();
Returns:: Result Codes
Return Type:: String

This function returns a comma-delimited string of four-character codes which detail the success of the last function call and the cause of any errors any errors that occurred during the last call to the Parse, Genderize or Salutate function.

Remarks

The GetResults function replaces the GetStatusCode (Deprecated) and GetErrorCode (Deprecated) functions, providing a single source of information about the last call and eliminating the need to call multiple functions.

The function returns one or more of the following codes in a comma-delimited list.

Result Codes

GetResultCodeDescription #

Syntax:: GetResultCodeDescription(String ResultCode, enum ResultCdDescOpt);
Returns:: Result Code Description
Return Type:: String

This function returns the description of the inputted Result Code. It can only be used through the Standard DLL.

It requires two values to be passed in, a Result Code and an enumerated option. If a string of Result Codes are inputted, only the first code will be used. The enumerated option will determine whether a short or long description will be returned.

Enumerated Value	Val	Description
ResultCodeDescriptionLong	0	Returns a detailed description of the inputted result code.
ResultCodeDescriptionShort	1	Returns a brief description of the inputted result code

Retrieve the Processed Name Data #

These function return the parsed and genderized name data, as well as any generated salutations.

GetFirstName #

Syntax:: GetFirstName();
Returns:: First Name
Return Type:: String

This function returns the first name from a full name parsed by the Parse function.

Remarks: This function will return the first name after a successful call to the Parse function. If the parameter passed to the SetFullName function only contained a single name prior to calling the Parse function, the first name will be returned here. If two names were parsed, the first of the two first names will be returned by this function.

GetFirstName2 #

Syntax:: GetFirstName2();
Returns:: First Name
Return Type:: String

This function returns the second first name from a full name parsed by the Parse function

Remarks: This function will return the second first name after a successful call to the Parse function, if the parameter passed to that function contained two names.

GetGender #

Syntax:: GetGender();
Returns:: Gender
Return Type:: String

This function returns the gender name if one could be determined by either the Parse or Genderize function.

Remarks

This function returns a one-character string indicating the gender of the first name found in the parameter passed to the SetFullName function by a call to the Parse function.

This function will also return the results of a call to the Genderize function. Genderizing is primarily based on gender data for first names, but Name Object will also use Prefix or Suffix information to improve accuracy. For example, a suffix of “Ms.” would clearly indicate a woman’s name, even if the name was predominantly male, while a suffix of “Sr.” or “Jr.” would suggest a man’s name.

The possible values returned by this function are:

Code	Description
M	Male
F	Female
U	Unknown first name or no first name present
N	A neutral first name

GetGender2 #

Syntax:: GetGender2();
Returns:: Gender
Return Type:: String

This function returns the gender of any second name if one could be determined by either the Parse or Genderize function

Remarks

This function returns a one-character string value indicating the gender of any second name found in the parameters passed to the SetFullName function by a call to the Parse function.

This function would also return the gender based on second set of name data after a call Genderize function.

More information on genderizing and the possible values returned by this function found in the section about the GetGender function.

GetLastName #

Syntax:: GetLastName();
Returns:: Last Name
Return Type:: String

This function returns the last name from a full name parsed by the Parse function.

Remarks: This function will return the last name after a successful call to the Parse function. If the parameter passed to the SetFullName function only contained a single name prior to calling the Parse function, the last name will be returned here. If two names were parsed, the first of the two last names will be returned by this function.

GetLastName2 #

Syntax:: GetLastName2();
Returns:: Last Name
Return Type:: String

This function returns the second last name from a full name parsed by the Parse function.

Remarks: This function will return the second last name after a successful call to the Parse function if the parameter passed to the SetFullName function contained two names prior to calling the Parse function.

GetMiddleName #

Syntax:: GetMiddleName();
Returns:: Middle Name
Return Type:: String

This function returns the first middle name from a full name parsed by the Parse function.

Remarks: This function will return the middle name after a successful call to the Parse function. If the parameter passed to the SetFullName function only contained a single name prior to calling the Parse function, the middle name, if any, will be returned here. If two names were parsed, the first of the two middle names will be returned by this function.

GetMiddleName2 #

Syntax:: GetMiddleName2();
Returns:: Middle Name
Return Type:: String

This function returns the second middle name from a full name parsed by the Parse function.

Remarks: This function will return the second middle name after a successful call to the Parse function if the parameter passed to the SetFullName function contained two names prior to calling the Parse function.

GetPrefix #

Syntax:: GetPrefix();
Returns:: Prefix
Return Type:: String

This function returns the first prefix (such as “Mr.” or “Dr.”) from a full name parsed by the Parse function.

Remarks: This function will return the prefix after a successful call to the Parse function. If the parameter passed to the SetFullName function only contained a single name prior to calling the Parse function, the prefix, if any, will be returned here. If two names were parsed, the first of the two prefixes will be returned by this function.

GetPrefix2 #

Syntax:: GetPrefix2();
Returns:: Prefix
Return Type:: String

This function returns the second prefix (such as “Mr.” or “Dr.”) from a full name parsed by the Parse function.

Remarks: This function will return the second prefix after a successful call to the Parse function if the parameter passed to the SetFullName function contained two names prior to calling the Parse function.

GetSalutation #

Syntax:: GetSalutation();
Returns:: Salutation
Return Type:: String

This function returns a generated salutation string value after a successful call to the Parse or Salutate function.

Remarks: The GetSalutation function returns the contents of the salutation string generated according to the preferences set by the SetSalutationPrefix, SetSalutationSlug, and SetSalutationSuffix functions. The return value of this function is set by successful calls to either the Parse or Salutate function.

GetSuffix #

Syntax:: GetSuffix();
Returns:: Suffix
Return Type:: String

This function returns the first suffix (such as “Jr.” or “III.”) from a full name parsed by the Parse function.

Remarks: This function will return the suffix after a successful call to the Parse function. If the parameter passed to the SetFullName function only contained a single name prior to calling the Parse function, the suffix, if any, will be returned here. If two names were parsed, the first of the two suffixes will be returned by this function.

GetSuffix2 #

Syntax:: GetSuffix2();
Returns:: Suffix
Return Type:: String

This function returns the second suffix (such as “Sr.” or “IV.”) from a full name parsed by the Parse function.

Remarks: This function will return the second suffix after a successful call to the Parse function the parameter passed to the SetFullName function contained two names prior to calling the Parse function.

Deprecated Functions #

The following functions are recorded here for compatability and archiving purposes. Alternative functions should be used in practice.

GetChangeCode (Deprecated)#

Syntax:: GetChangeCode();
Returns:: Change Code
Return Type:: String

This function has been deprecated. You should use the GetResults function instead.

This function returns a string indicating whether the contents of the GetFirstName function, the GetFirstName2 function, or both, were corrected from the original SetFullName function.

Remarks

If First Name spell correction is enabled, this function will indicate if one or both parsed first names were changed during the Parsing process due to a misspelled first name.

This function can return one of the following values:

Value	Description
1	Spelling of the value passed to SetFirstName function was corrected.
2	Spelling of the value passed to SetFirstName2 function was corrected.
B	Both names were corrected.

If neither field is changed, or First Name spell correction was disabled, this function will return an empty string.

GetErrorCode (Deprecated)#

Syntax:: GetErrorCode();
Returns:: Error Code
Return Type:: String

This function has been deprecated. You should use the GetResults function instead.

This function returns a one-character string value containing a code describing an error caused by a call to the Parse, Genderize or Salutate function.

Remarks

If the Parse, Genderize or Salutate function return a value other than zero, an error has occurred. Check this function to determine the reason. The possible return values are listed below.

Code	Reason
D	Two names were detected but the value passed to the SetFullName function was not in a recognized format.
F	Multiple first names — could not accurately genderize.
P	A vulgarity was detected in the name.
S	The name contained words found on the list of nuisance names (such as “Mickey Mouse”)
C	The name contained words normally found in a company name.
A	The named contained a non-alphabetic character

GetStatusCode (Deprecated)#

Syntax:: GetStatusCode();
Returns:: Status Code
Return Type:: String

This function has been deprecated. You should use the GetResults function instead.

This function returns a one character string value indicating the success or failure of the most recent call to the Parse function.

Remarks

The GetStatusCode function returns one of two possible string values:

Value	Description
V	Parsing was successful
X	There was an error. Check the GetErrorCode function.

Result Codes #

For details of all result codes please visit here

NS - Name Status #

Code	Short Description	Long Description
`NS01`	Parsing Successful	Name parsing was successful.
`NS02`	Error Parsing	An error was detected. Please check for a name error code.
`NS03`	First Name Spelling Corrected	The spelling in the first name field was corrected.
`NS04`	First Name 2 Spelling Corrected	The spelling in the second first name field was corrected.
`NS05`	First Name 1 Found	FirstName1 was found in our census table of names. Very likely to be a real first name.
`NS06`	Last Name 1 Found	LastName1 was found in our census table of names. Very likely to be a real last name.
`NS07`	First Name 2 Found	FirstName2 was found in our census table of names. Very likely to be a real first name.
`NS08`	Last Name 2 Found	LastName2 was found in our census table of names. Very likely to be a real last name.

NE - Name Error #

Code	Short Description	Long Description
`NE01`	Unrecognized Format	Format of Input string was not recognized or too long to represent a valid name.
`NE02`	Multiple First Names Detected	Multiple first names were detected and could not be accurately genderized.
`NE03`	Vulgarity Detected	A vulgarity was detected in the name.
`NE04`	Suspicious Word Detected	The name contained words found on the list of nuisance names, such as “Mickey Mouse.”
`NE05`	Company Name Detected	The name contained words normally found in a company name.
`NE06`	Non-Alphabetic Character Detected	The name contained a non-alphabetic character.

Reference Guide

Contents

Reference Guide#