CodeDefinitionSet[] VisitCodeDefinitions(CodeDefinitionSet[] codeDefinitions)
{
CodeDefinitionSet[] result = null;
if (codeDefinitions != null)
{
SortedDictionary <string, CodeDefinitionSet> sortedCodeDefinitions = new SortedDictionary <string, CodeDefinitionSet>();
foreach (CodeDefinitionSet codeDefinitionItem in codeDefinitions)
{
string language = codeDefinitionItem.language;
if (!string.IsNullOrEmpty(language))
{
CodeDefinitionSet canonicalItem = new CodeDefinitionSet();
canonicalItem.language = language;
// Canonicalise code definitions items
canonicalItem.items = VisitArchetypeTerms(codeDefinitionItem.items);
sortedCodeDefinitions.Add(language, canonicalItem);
}
}
result = new CodeDefinitionSet[sortedCodeDefinitions.Count];
sortedCodeDefinitions.Values.CopyTo(result, 0);
}
return(result);
}
public CodeDefinitionSet GetConstraintLanguageSet(string language)
{
CodeDefinitionSet result = null;
if (!string.IsNullOrEmpty(language))
{
int i = 0;
CodeDefinitionSet[] definitions = _archetype.ontology.constraint_definitions;
if (definitions != null)
{
foreach (CodeDefinitionSet ls in definitions)
{
if (ls.language == language)
{
result = ls;
}
}
i = definitions.Length;
}
if (result == null)
{
Array.Resize(ref definitions, i + 1);
definitions[i] = result = new CodeDefinitionSet();
result.language = language;
_archetype.ontology.constraint_definitions = definitions;
}
}
return(result);
}
protected override void CleanUpCodeDefinitionSet(CodeDefinitionSet codeDefinitionSet)
{
foreach (ARCHETYPE_TERM term in codeDefinitionSet.items)
{
foreach (StringDictionaryItem item in term.items)
{
if (item.id == "text")
{
item.Value = item.Value.Trim();
break;
}
}
}
}
protected void AddTermOrConstraintDefinitionForLanguage(CodeDefinitionSet ls, ARCHETYPE_TERM term)
{
if (ls.items == null)
{
ls.items = new ARCHETYPE_TERM[1];
}
else
{
ARCHETYPE_TERM[] t = ls.items;
Array.Resize(ref t, t.Length + 1);
ls.items = t;
}
ls.items[ls.items.Length - 1] = term;
}
public ARCHETYPE_TERM ConstraintDefinition(string a_language_code, string a_code)
{
CodeDefinitionSet ls = ConstraintDefinitions(a_language_code);
if (ls != null)
{
foreach (ARCHETYPE_TERM at in ls.items)
{
if (at.code == a_code)
{
return(at);
}
}
}
return(null);
}
private void RemoveUnusedTerms(CodeDefinitionSet languageSet, ArrayList termsUsed)
{
if (languageSet != null && languageSet.items != null)
{
int archetypeSpecialisationDepth = NumberOfSpecialisations;
ArrayList items = new ArrayList();
foreach (ARCHETYPE_TERM term in languageSet.items)
{
if (termsUsed.Contains(term.code) || term.code.Split('.').Length - 1 < archetypeSpecialisationDepth)
{
items.Add(term);
}
}
languageSet.items = (ARCHETYPE_TERM[])items.ToArray(typeof(ARCHETYPE_TERM));
}
}
public void AddTermOrConstraintDefinition(string language, ARCHETYPE_TERM term, bool isLoading)
{
CodeDefinitionSet definition = null;
CodeDefinitionSet[] definitions = null;
string code = term.code.ToLowerInvariant();
if (code.StartsWith("at"))
{
definition = GetTermLanguageSet(language);
definitions = _archetype.ontology.term_definitions;
}
else if (code.StartsWith("ac"))
{
definition = GetConstraintLanguageSet(language);
definitions = _archetype.ontology.constraint_definitions;
}
else
{
System.Diagnostics.Debug.Assert(false, "Error in code " + code);
}
if (definition != null && definitions != null)
{
//Add the term to that language - ensures there is a language set for the language
AddTermOrConstraintDefinitionForLanguage(definition, term);
if (!isLoading && definitions != null && definitions.Length > 1) // if there is more than one language then add the term to those
{
foreach (CodeDefinitionSet ls in definitions)
{
if (ls.language != language)
{
foreach (StringDictionaryItem di in term.items)
{
di.Value = string.Format("{0}{1}({2})", "*", di.Value, language);
}
AddTermOrConstraintDefinitionForLanguage(ls, term);
}
}
}
}
}
protected virtual CodeDefinitionSet[] CloneCodeDefinitions(EiffelStructures.table.HASH_TABLE_REFERENCE_REFERENCE o)
{
CodeDefinitionSet[] result = null;
if (o != null)
{
result = new CodeDefinitionSet[o.count()];
o.start();
for (int i = 1; i <= result.Length; i++)
{
CodeDefinitionSet codeDefinitionSet = new CodeDefinitionSet();
codeDefinitionSet.language = o.key_for_iteration().ToString();
EiffelStructures.table.Impl.HASH_TABLE_REFERENCE_REFERENCE adlTerms = o.item_for_iteration() as EiffelStructures.table.Impl.HASH_TABLE_REFERENCE_REFERENCE;
SortedList <string, ARCHETYPE_TERM> localTerms = new SortedList <string, ARCHETYPE_TERM>();
adlTerms.start();
for (int j = 1; j <= adlTerms.count(); j++)
{
openehr.openehr.am.archetype.ontology.Impl.ARCHETYPE_TERM term = adlTerms.item_for_iteration() as openehr.openehr.am.archetype.ontology.Impl.ARCHETYPE_TERM;
ARCHETYPE_TERM localTerm = new ARCHETYPE_TERM();
localTerm.code = term.code().ToString();
localTerm.items = CloneHashTableAny(term.items());
localTerms.Add(localTerm.code, localTerm);
adlTerms.forth();
}
codeDefinitionSet.items = new ARCHETYPE_TERM[localTerms.Count];
localTerms.Values.CopyTo(codeDefinitionSet.items, 0);
CleanUpCodeDefinitionSet(codeDefinitionSet);
result[i - 1] = codeDefinitionSet;
o.forth();
}
}
return(result);
}
public void AddLanguage(string language)
{
if (!string.IsNullOrEmpty(language) && !_languages_available.Contains(language))
{
_languages_available.Add(language);
if (_languages_available.Count > 1)
{
//populate a translation set from the original language
CodeDefinitionSet ls = TermDefinitions(_archetype.original_language.code_string);
CodeDefinitionSet new_ls = GetTermLanguageSet(language);
ARCHETYPE_TERM[] new_terms = Array.CreateInstance(typeof(ARCHETYPE_TERM), ls.items.Length) as ARCHETYPE_TERM[];
for (int i = 0; i < ls.items.Length; i++)
{
ARCHETYPE_TERM at = ls.items[i];
ARCHETYPE_TERM new_at = new ARCHETYPE_TERM();
new_at.code = at.code;
StringDictionaryItem[] new_items = Array.CreateInstance(typeof(StringDictionaryItem), at.items.Length) as StringDictionaryItem[];
for (int j = 0; j < at.items.Length; j++)
{
StringDictionaryItem di = at.items[j];
StringDictionaryItem new_di = new StringDictionaryItem();
new_di.id = di.id;
new_di.Value = string.Format("{0}{1}({2})", "*", di.Value, _archetype.original_language.code_string);
new_items[j] = new_di;
}
new_at.items = new_items;
new_terms[i] = new_at;
}
new_ls.items = new_terms;
//now get a translation set for constraint definitions
ls = ConstraintDefinitions(_archetype.original_language.code_string);
if (ls != null) //May not be any Constraint definitions
{
new_ls = GetConstraintLanguageSet(language);
new_terms = Array.CreateInstance(typeof(ARCHETYPE_TERM), ls.items.Length) as ARCHETYPE_TERM[];
for (int i = 0; i < ls.items.Length; i++)
{
ARCHETYPE_TERM ac = ls.items[i];
ARCHETYPE_TERM new_ac = new ARCHETYPE_TERM();
new_ac.code = ac.code;
StringDictionaryItem[] new_items = Array.CreateInstance(typeof(StringDictionaryItem), ac.items.Length) as StringDictionaryItem[];
for (int j = 0; j < ac.items.Length; j++)
{
StringDictionaryItem di = ac.items[j];
StringDictionaryItem new_di = new StringDictionaryItem();
new_di.id = di.id;
new_di.Value = string.Format("{0}{1}({2})", "*", di.Value, _archetype.original_language.code_string);
new_items[j] = new_di;
}
new_ac.items = new_items;
new_terms[i] = new_ac;
}
new_ls.items = new_terms;
}
}
//populate a new description by raising an event
LanguageAdded(this, language, _archetype.original_language.terminology_id.value);
}
}
protected virtual void CleanUpCodeDefinitionSet(CodeDefinitionSet codeDefinitionSet)
{
}
