Extends

• ArchBaseCoreObject

Members

static, readonly displayTypeName :string

Returns the display type name string 'ArchLanguage'.

static, readonly isArchLanguage :boolean

Returns true indicating that this is an ArchLanguage instance.

readonly hasFlowCreationTTS :boolean

Returns whether or not the language has flow creation default text to speech text.

readonly isArchBaseCoreObject :boolean

Returns true indicating that this is an ArchBaseCoreObject instance.

Inherited From:

• ArchBaseCoreObject#isArchBaseCoreObject

readonly label :string

A localized display label for the language such as "English (United States)"

readonly logStr :string

Returns a string suitable for logging information about this language.

Overrides:

• ArchBaseCoreObject#logStr

readonly logStrTypeOnly :string

This is a string suitable for logging information about this object where it's just the object's type. This is normally used when logging errors that occur in constructor parameter checking because the scripting object isn't set up and the normal logging str contents wouldn't be set up.

Inherited From:

• ArchBaseObject#logStrTypeOnly

readonly supportsCase :boolean

Returns whether or not the language supports case which means it supports at least one of the following case properties:

• caseArticle
• caseAccusative
• caseDative
• caseGenitive
• caseNominative

readonly supportsCaseAccusative :boolean

Returns whether or not the language supports the concept of accusative case.

readonly supportsCaseArticle :boolean

Returns whether or not the language supports the concept of article case.

readonly supportsCaseDative :boolean

Returns whether or not the language supports the concept of dative case.

readonly supportsCaseGenitive :boolean

Returns whether or not the language supports the concept of genitive case.

readonly supportsCaseNominative :boolean

Returns whether or not the language supports the concept of nominative case.

readonly supportsGender :boolean

Returns whether or not the language supports gender which means it supports at least one of the following gender properties:

• genderCommon
• genderFeminine
• genderNeuter
• genderMasculine

readonly supportsGenderCommon :boolean

Returns whether or not the language supports the concept of common gender.

readonly supportsGenderFeminine :boolean

Returns whether or not the language supports the concept of feminine gender.

readonly supportsGenderMasculine :boolean

Returns whether or not the language supports the concept of masculine gender.

readonly supportsGenderNeuter :boolean

Returns whether or not the language supports the concept of neuter gender.

readonly tag :string

The IETF language tag for this language. Remember when dealing with language tag strings that your code should treat them case insensitively.

readonly ttsEngines :Array.<ArchTtsEngine>

Returns the text to speech engines that support this language. If the areTtsEnginesAndVoicesAvailable property returns false, nothing will be returned. Accessing this property when the Architect Scripting session is not connected or if the organization does not support text to speech engine / voice information available will throw. You can access areTtsEnginesAndVoicesAvailable to see if text to speech engine and voice information is available on an organization.

Properties:

Name	Type	Description
ttsEngines

See:

• ArchLanguage#getTtsEnginesForFlowType

Methods

getDefaultTtsEngine() → {ArchTtsEngine}

Returns the default text to speech engine that is available for this language. If this language does not have a default text to speech engine, nothing is returned. Remember that a default TTS engine may not always be available for a given flow type.

Throws:

Calling this method when the Architect Scripting session is not connected will throw.

Returns:

ArchTtsEngine

getDefaultTtsEngineVoice() → {ArchTtsVoice}

This is a helper function that calls ArchLanguage#getDefaultTtsEngine to get the default text to speech engine for this language. If there is one returned, execution then calls ArchTtsEngine#getDefaultVoiceForLanguage on that engine and passes in this language to get the default voice if there is one configured on the default engine.

Throws:

Calling this method when the Architect Scripting session is not connected will throw.

Returns:

ArchTtsVoice

getTtsEnginesForFlowType(flowType) → {Array.<ArchTtsEngine>}

Returns an array of text to speech engines that are valid for this language and the supplied flow type. If the supplied flow type is not available for the organization, an empty array will be returned.

Parameters:

Name	Type	Description
flowType	string	the flow type to check. ArchEnums#FLOW_TYPES lists valid flow type strings.

Throws:

Calling this method when the Architect Scripting session is not connected will throw.

Returns:

Array.<ArchTtsEngine>

See:

• ArchLanguage#ttsEngines

isFilterMatch(archFilterObject) → {boolean}

Returns whether or not this Architect Scripting object is a match for the supplied ArchFilterObject instance.

Parameters:

Name	Type	Description
archFilterObject	ArchFilterObject	the object filter to use to determine if it's a match.

Returns:

boolean

Inherited From:

• ArchBaseObject#isFilterMatch

isRuntimeDataPlaybackSupported(flowType) → {boolean}

Returns whether or not the language has runtime data playback support.

Parameters:

Name	Type	Description
flowType	string	the flow type to check. ArchEnums#FLOW_TYPES lists valid flow type strings.

Returns:

boolean

isSpeechRecSupported(flowType) → {boolean}

Returns whether or not the language has speech recognition support.

Parameters:

Name	Type	Description
flowType	string	the flow type to check. ArchEnums#FLOW_TYPES lists valid flow type strings.

Returns:

boolean

isTextToSpeechSupported(flowType) → {boolean}

Returns whether or not the language has text to speech support.

Parameters:

Name	Type	Description
flowType	string	the flow type to check. ArchEnums#FLOW_TYPES lists valid flow type strings.

Returns:

boolean

logError(errorStr)

Logs an error to the logging service with a log header from this object's logStr property value when ArchLogging#logErrors is true.

Parameters:

Name	Type	Description
errorStr	string	the error string to log.

Inherited From:

• ArchBaseObject#logError

logErrorAndThrow(errorStr)

Logs an error to the logging service with a log header from this object's logStr property value when ArchLogging#logErrors is true and then throws the string in the errorStr parameter.

Parameters:

Name	Type	Description
errorStr	string	the error string to log. This should be a non-blank string.

Throws:

• Throws the submitted error string.

Inherited From:

• ArchBaseObject#logErrorAndThrow

logNote(noteStr)

Logs a note to the logging service with a log header from this object's logStr property value when ArchLogging#logNotes is true.

Parameters:

Name	Type	Description
noteStr	string	the note string to log. This should be a non-blank string.

Inherited From:

• ArchBaseObject#logNote

logNoteVerbose(noteStr)

Logs a note to the logging service with a log header from this object's logStr property value when ArchLogging#logNotesVerbose is true.

Parameters:

Name	Type	Description
noteStr	string	the note string to log. This should be a non-blank string.

Inherited From:

• ArchBaseObject#logNoteVerbose

logWarning(warningStr)

Logs a warning to the logging service with a log header from this object's logStr property value when ArchLogging#logWarnings is true.

Parameters:

Name	Type	Description
warningStr	string	the warning string to log. This should be a non-blank string.

Inherited From:

• ArchBaseObject#logWarning

traverse(callbackFunction, traverseFilteropt) → {number}

This method iterates over this object and ArchBaseCoreObject instances within it. For each object it will call the ArchBaseObject#isFilterMatch method with a filter and call the supplied callback function if isMatch returns true. The callback will be passed an ArchTraverseInfo with details about the match such as the match object itself along with current contextual information such as the object hierarchy for the match object relative to the object on which this traverse call is being made.

The traverse filter is one which you can create by calling ArchFactoryFilters#createFilterObject and then add desired clauses or clause containers to it. If not specified, this function will use a default filter.

Here is an example that does a simple flow traversal using the default filter and logs information about objects in the callback from the traverse object that's passed back:

archInboundCallFlow.traverse(function(traverseInfo) {
   archLogging.logNote('  Object     : ' + traverseInfo.matchObject.logStr);
   archLogging.logNote('    Hierarchy: ' + traverseInfo.context.hierarchyStr);
});

This might be enough for most uses and you can check various aspects about the object in the callback such as "is this an Architect action?" by seeing if traverseInfo.matchObject.isArchBaseAction is true. You can specify a filter for the traversal code to use as well and only have it call your callback when the object's ArchBaseCoreObject#isFilterMatch method returns true for the filter. Here's an example that creates a filter for callbacks on any type of transfer action, any decision action or objects whose name property case insensitively matches the word 'foo'. While this could all be done with one property callback clause the example will use multiple clauses for the sake of simplicity:

const myTraverseFilter = filterFactory.createFilterObject(archEnums.FILTER_CONTAINER_OPERATORS.or);
myTraverseFilter.addClausePropertyValueEquals('isArchBaseActionTransfer', true);
myTraverseFilter.addClausePropertyValueEquals('isArchActionDecision',     true);
myTraverseFilter.addClausePropertyCallback('name', function(propValue, archContainingObject, propName) {
      // We fully spelled out the function signature above but archContainingObject and propName are
      // not needed in this case.  The archContainingObject is the object that contains the
      // property and propName is the property name itself.  We pass in propName because the same
      // function could be used for multiple property callback clauses.
      // Remember to return a boolean true, false or undefined from ths callback.  :)
      return propValue && propValue.toLowerCase() === 'foo';
});
archTask.traverse(function(traverseContext) {
   // You will only be called back here for ArchBaseCoreObject instances that
   // have the isArchBaseActionTransfer or isArchActionDecision property values equal to true.
}, myTraverseFilter);

If you supply a filter with no clauses, this tells the traverse method to call the supplied callback function for every ArchBaseCoreObject it traverses.

If you want traversal itself to stop after a callback, simply return boolean false from the callback function you supply to the traverse call.

The traverse method does not process deprecated property names such as orgId, orgName or languageSettings. Additionally it does not traverse in to properties that would "jump out" of the current traversal. An example of this would be if the code was traversing an ArchActionJumpToMenu action that it would not start traversing in to the menu that it jumps to. Another example would be a ArchActionChangeState action where it would not traverse in to the target state of the action. This also means traversal does not traverse in to the ArchBaseValue#flowLevelDefault property.

And lastly, as Scripting evolves over time with new versions, you can expect to get callbacks for new object types such as new actions or new properties on objects. As such, it's important not to assume any particular order in callbacks to keep code most compatible with traversal callbacks. Or if you use inequality checks in filter clauses remember that new "stuff" may satisfy an inequality check which may or may not be anticipated in your logic.

Note: This traverse method is a helper method and is very handy for iterating over Architect Scripting objects and their properties in a generic fashion with filtering capabilities. Obviously you can write your own custom traversal code if this implementation doesn't cut it for some reason. :)

This function returns the number of times it called the callback function.

Parameters:

Name	Type	Attributes	Default	Description
callbackFunction	callbackTraverseInfo			the callback function to call for objects that match the traverse filter.
traverseFilter	ArchFilterObject	<optional>	ArchFactoryFilters#createFilterTraverseDefault	the filter to use when performing the traversal to determine which ArchBaseCoreObject instances you wish to be called back for. If no filter is specified, this function will call ArchFactoryFilters#createFilterTraverseDefault and use that traversal default filter. The wantArchBaseValues parameter on that call is set to true.

Returns:

number

Inherited From:

• ArchBaseCoreObject#traverse