ARCHETYPE_TERM[] VisitArchetypeTerms(ARCHETYPE_TERM[] archetypeTerms)
{
ARCHETYPE_TERM[] result = null;
if (archetypeTerms != null)
{
SortedDictionary<string, ARCHETYPE_TERM> sortedItems = new SortedDictionary<string, ARCHETYPE_TERM>();
foreach (ARCHETYPE_TERM termItem in archetypeTerms)
{
ARCHETYPE_TERM canonicalTerm = new ARCHETYPE_TERM();
canonicalTerm.code = termItem.code;
canonicalTerm.items = VisitStringDictionary(termItem.items);
sortedItems.Add(termItem.code, canonicalTerm);
}
result = new ARCHETYPE_TERM[sortedItems.Count];
sortedItems.Values.CopyTo(result, 0);
}
return result;
}
public void SpecialiseArchetype(string addition_to_concept_name)
{
ARCHETYPE_TERM term = new ARCHETYPE_TERM();
ARCHETYPE_TERM parentTerm = _ontology.TermDefinition(_ontology.PrimaryLanguageCode, _archetype.concept);
term.code = _ontology.NextSpecialisedTermId(parentTerm.code);
term.items = new StringDictionaryItem[parentTerm.items.Length];
for (int i = 0; i < parentTerm.items.Length; i++)
{
term.items[i] = new StringDictionaryItem();
term.items[i].id = parentTerm.items[i].id;
term.items[i].Value = parentTerm.items[i].Value;
}
_ontology.AddTermOrConstraintDefinition(term, false);
if (_archetype.definition.node_id == _archetype.concept)
_archetype.definition.node_id = term.code;
_archetype.concept = term.code;
_archetype.parent_archetype_id = _archetype.archetype_id;
//now add the addition to the concept name in the archetype ID
string[] y = _archetype.archetype_id.value.Split(".".ToCharArray());
_archetype.archetype_id = new ARCHETYPE_ID();
_archetype.archetype_id.value = y[0] + "." + y[1] + "-" + addition_to_concept_name;
for (int i = 2; i < y.Length; i++)
{
_archetype.archetype_id.value += "." + y[i];
}
//don't overwrite the old archetype
_file_name = null;
}
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;
}
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 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);
}
}
}
}
}
public void AddTermOrConstraintDefinition(ARCHETYPE_TERM a_term, bool isLoading)
{
AddTermOrConstraintDefinition(languageCode, a_term, isLoading);
}
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);
}
}
public void ReplaceTermDefinition(string languageCode, ARCHETYPE_TERM term, bool replaceTranslations)
{
string code = term.code.ToLowerInvariant();
System.Diagnostics.Debug.Assert(HasTermCode(code), "Does not have code " + code);
CodeDefinitionSet[] definitions;
if (code.StartsWith("at"))
definitions = _archetype.ontology.term_definitions;
else
definitions = _archetype.ontology.constraint_definitions;
if (definitions != null)
{
ARCHETYPE_TERM termForTranslations = null;
if (replaceTranslations && languageCode == PrimaryLanguageCode)
{
termForTranslations = new ARCHETYPE_TERM
{
code = code,
items = new StringDictionaryItem[term.items.Length]
};
for (int i = 0; i < term.items.Length; i++)
{
termForTranslations.items[i] = new StringDictionaryItem
{
id = term.items[i].id,
Value = "*" + term.items[i].Value + "(" + languageCode + ")"
};
}
}
foreach (CodeDefinitionSet ls in definitions)
{
ARCHETYPE_TERM replacement = ls.language == languageCode ? term : termForTranslations;
if (replacement != null)
{
ARCHETYPE_TERM[] terms = ls.items;
for (int i = 0; i < terms.Length; i++)
{
if (terms[i].code.ToLowerInvariant() == code)
terms[i] = replacement;
}
}
}
}
}
