public TermConversionResult AbbreviateTerm(string term)
{
TermConversionResult r = new TermConversionResult();
r.Input = term;
r.Configuration = TermConverterConfiguration;
if (TermConverterConfiguration.DelimeterForNotFound_Left.Length > 0)
{
term = term.Replace(TermConverterConfiguration.DelimeterForNotFound_Left, "");
}
if (TermConverterConfiguration.DelimeterForNotFound_Right.Length > 0)
{
term = term.Replace(TermConverterConfiguration.DelimeterForNotFound_Right, "");
}
string termRemaining = term;
string abbreviatedTerm = "";
string searchString = term;
string result = "";
string subStringOfsearchString = "";
do
{
if (_TermToAbbreviationDictionary.ContainsKey(searchString.ToUpper()))
{
r.NodesFound.Add(searchString);
result = _TermToAbbreviationDictionary[searchString.ToUpper()];
switch (TermConverterConfiguration.AbbreviationCaseConvention)
{
case CaseConvention.PascalCase:
result = result.ToTitleCase();
break;
case CaseConvention.camelCase:
result = result.ToTitleCase();
break;
case CaseConvention.lowercase:
result = result.ToLower();
break;
case CaseConvention.UPPERCASE:
result = result.ToUpper();
break;
default:
break;
}
if (abbreviatedTerm == "")
{
if (TermConverterConfiguration.AbbreviationCaseConvention == CaseConvention.camelCase)
{
result = result.ToLower();
}
abbreviatedTerm = result;
}
else
{
abbreviatedTerm = abbreviatedTerm + TermConverterConfiguration.AbbreviationDelimeter + result;
}
termRemaining = termRemaining.ReplaceFirstOccurence(searchString, "").TrimStart();
if (termRemaining.StartsWith(TermConverterConfiguration.TermDelimeter))
{
termRemaining = termRemaining.ReplaceFirstOccurence(TermConverterConfiguration.TermDelimeter, "");
}
if (termRemaining.Length != 0)
{
if (termRemaining[0] == '-')
{
termRemaining = termRemaining.ReplaceFirstOccurence("-", "");
}
}
searchString = termRemaining;
}
else
{
int delimeterIndex = searchString.LastIndexOf(TermConverterConfiguration.TermDelimeter);
if (delimeterIndex > -1 && (!TermConverterConfiguration.TreatHyphenAsTermDelimeter || TermConverterConfiguration.TermDelimeter == "-"))
{
subStringOfsearchString = searchString.Substring(0, delimeterIndex);
}
else
{
int hyphenIndex = searchString.LastIndexOf('-');
if (delimeterIndex == hyphenIndex)
{
subStringOfsearchString = "";
}
else if (delimeterIndex > hyphenIndex)
{
subStringOfsearchString = searchString.Substring(0, delimeterIndex);
}
else if (hyphenIndex > delimeterIndex)
{
if (hyphenIndex.Equals(0))
{
subStringOfsearchString = "";
}
else
{
subStringOfsearchString = searchString.Substring(0, hyphenIndex);
}
}
}
if (subStringOfsearchString == "")
{
if (searchString.IsANumber())
{
abbreviatedTerm = abbreviatedTerm
+ TermConverterConfiguration.AbbreviationDelimeter
+ searchString;
}
else
{
r.NodesNotFound.Add(searchString);
switch (TermConverterConfiguration.AbbreviationCaseConvention)
{
case CaseConvention.PascalCase:
if (abbreviatedTerm == string.Empty)
{
abbreviatedTerm = TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToTitleCase();
}
else
{
abbreviatedTerm = abbreviatedTerm + TermConverterConfiguration.AbbreviationDelimeter + TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToTitleCase();
}
break;
case CaseConvention.camelCase:
if (abbreviatedTerm == string.Empty)
{
abbreviatedTerm = TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToLower();
}
else
{
abbreviatedTerm = abbreviatedTerm + TermConverterConfiguration.AbbreviationDelimeter + TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToTitleCase();
}
break;
case CaseConvention.lowercase:
if (abbreviatedTerm == string.Empty)
{
abbreviatedTerm = TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToLower();
}
else
{
abbreviatedTerm = abbreviatedTerm + TermConverterConfiguration.AbbreviationDelimeter + TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToLower();
}
break;
case CaseConvention.UPPERCASE:
if (abbreviatedTerm == string.Empty)
{
abbreviatedTerm = TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToUpper();
}
else
{
abbreviatedTerm = abbreviatedTerm + TermConverterConfiguration.AbbreviationDelimeter + TermConverterConfiguration.DelimeterForNotFound_Left + searchString.ToUpper();
}
break;
default:
break;
}
abbreviatedTerm = abbreviatedTerm + TermConverterConfiguration.DelimeterForNotFound_Right;
}
termRemaining = termRemaining.ReplaceFirstOccurence(searchString, "").TrimStart();
if (termRemaining.Length != 0)
{
if (termRemaining[0] == '-')
{
termRemaining = termRemaining.ReplaceFirstOccurence("-", "");
}
}
searchString = termRemaining;
}
else
{
searchString = subStringOfsearchString;
}
}
} while (termRemaining.Length > 0);
r.Output = abbreviatedTerm;
return(r);
}
public GlossaryComplianceResult CheckCompliance(string term, string abbreviatedTerm)
{
GlossaryComplianceResult r = new GlossaryComplianceResult();
r.Stopwatch.Start();
r.Term = term;
r.Abbreviation = abbreviatedTerm;
TermConversionResult abbreviationToTermResult = ExpandAbbreviation(r.Abbreviation);
TermConversionResult termToAbbreviationResult = AbbreviateTerm(r.Term);
TermConversionResult abbreviationToTermToAbbreviationResult = AbbreviateTerm(abbreviationToTermResult.Output);
TermConversionResult termToAbbreviationToTermResult = ExpandAbbreviation(termToAbbreviationResult.Output);
r.AbbreviationToTermResult = abbreviationToTermResult;
r.TermToAbbreviationResult = termToAbbreviationResult;
r.AbbreviationToTerm = abbreviationToTermResult.Output;
r.TermToAbbreviation = termToAbbreviationResult.Output;
r.TermToAbbreviationToTerm = termToAbbreviationToTermResult.Output;
r.AbbreviationToTermToAbbreviation = abbreviationToTermToAbbreviationResult.Output;
r.AbbreviationExpandsToTermCorrectly = r.AbbreviationToTerm == r.Term;
r.TermAbbreviatesCorrectly = r.TermToAbbreviation == r.Abbreviation;
r.PreferredTermIsUsed = r.AbbreviationExpandsToTermCorrectly &&
r.TermAbbreviatesCorrectly &&
r.AbbreviationToTerm == r.TermToAbbreviationToTerm &&
r.TermToAbbreviation == r.AbbreviationToTermToAbbreviation;
r.SynonymIsUsed = !r.AbbreviationExpandsToTermCorrectly &&
r.TermAbbreviatesCorrectly &&
r.AbbreviationToTerm == r.TermToAbbreviationToTerm &&
r.TermToAbbreviation == r.AbbreviationToTermToAbbreviation;
//if ((strPhysicalName == physicalToLogicalToPhysical && strPhysicalName != logicalToPhysical)
// || (strPhysicalName == RemoveNotFoundDelimeters(physicalToLogicalToPhysical) &&
// strPhysicalName != RemoveNotFoundDelimeters(logicalToPhysical)))
//{
// if (logicalToPhysicalResult.NodesNotFound.Count == 0)
// {
// r.LogicalNameConvertsToPhysical = true;
// }
// if (physicalToLogicalResult.NodesNotFound.Count == 0)
// {
// r.PhysicalNameConvertsToLogical = true;
// }
//}
if (r.AbbreviationToTerm == r.TermToAbbreviationToTerm &&
(r.Abbreviation == r.TermToAbbreviation || r.TermToAbbreviation == r.AbbreviationToTermToAbbreviation) &&
r.Abbreviation != r.AbbreviationToTermToAbbreviation &&
abbreviationToTermResult.NodesNotFound.Count == 0 &&
abbreviationToTermToAbbreviationResult.NodesNotFound.Count == 0)
{
r.CompoundAvailable = true;
}
if (r.Term == r.AbbreviationToTerm &&
r.AbbreviationToTerm == r.TermToAbbreviationToTerm &&
r.Abbreviation != r.TermToAbbreviation &&
r.TermToAbbreviation == r.AbbreviationToTermToAbbreviation)
{
r.HyphenNeededForTerm = true;
}
r.Mismatch = r.TermToAbbreviation != r.Abbreviation || r.AbbreviationToTerm != r.Term;
r.Stopwatch.Stop();
return(r);
}
public TermConversionResult ExpandAbbreviation(string abbreviation)
{
TermConversionResult r = new TermConversionResult();
r.Input = abbreviation;
r.Configuration = TermConverterConfiguration;
if (abbreviation.IsNullOrEmptyString())
{
r.Output = "";
return(r);
}
if (TermConverterConfiguration.DelimeterForNotFound_Left.Length > 0)
{
abbreviation = abbreviation.Replace(TermConverterConfiguration.DelimeterForNotFound_Left, "");
}
if (TermConverterConfiguration.DelimeterForNotFound_Right.Length > 0)
{
abbreviation = abbreviation.Replace(TermConverterConfiguration.DelimeterForNotFound_Right, "");
}
string term = "";
string[] nodes = abbreviation.Split(new string[] { TermConverterConfiguration.AbbreviationDelimeter }, StringSplitOptions.None);
int i = 0;
foreach (string node in nodes)
{
i++;
if (_AbbreviationToTermDictionary.ContainsKey(node.ToUpper()))
{
r.NodesFound.Add(node);
if (i > 1)
{
term = term + TermConverterConfiguration.TermDelimeter;
}
switch (TermConverterConfiguration.TermCaseConvention)
{
case CaseConvention.PascalCase:
term = term + _AbbreviationToTermDictionary[node.ToUpper()].ToTitleCase();
break;
case CaseConvention.camelCase:
if (i == 1)
{
term = term + _AbbreviationToTermDictionary[node.ToUpper()].ToLower();
}
else
{
term = term + _AbbreviationToTermDictionary[node.ToUpper()].ToTitleCase();
}
break;
case CaseConvention.lowercase:
term = term + _AbbreviationToTermDictionary[node.ToUpper()].ToLower();
break;
case CaseConvention.UPPERCASE:
term = term + _AbbreviationToTermDictionary[node.ToUpper()].ToUpper();
break;
default:
break;
}
}
else
{
if (node.IsANumber())
{
term = term + TermConverterConfiguration.TermDelimeter + node;
}
else
{
r.NodesNotFound.Add(node);
term = term + TermConverterConfiguration.TermDelimeter + TermConverterConfiguration.DelimeterForNotFound_Left + node + TermConverterConfiguration.DelimeterForNotFound_Right;
}
}
}
term = term.Trim().Replace(" ", TermConverterConfiguration.TermDelimeter);
if ((TermConverterConfiguration.DelimeterForNotFound_Left + TermConverterConfiguration.DelimeterForNotFound_Right).Length > 0)
{
r.Output = term.Replace(TermConverterConfiguration.DelimeterForNotFound_Left + TermConverterConfiguration.DelimeterForNotFound_Right, "");
}
else
{
if (TermConverterConfiguration.TermDelimeter.Length > 0 &&
term.Substring(0, TermConverterConfiguration.TermDelimeter.Length) == TermConverterConfiguration.TermDelimeter)
{
r.Output = term.ReplaceFirstOccurence(TermConverterConfiguration.TermDelimeter, "");
}
else
{
r.Output = term;
}
}
return(r);
}
