private static void ConvertAntonyms(IMeaning meaning, SqlCeConnection conn, Guid meaning_id)
{
using (SqlCeCommand cmd = conn.CreateCommand())
{
cmd.CommandText = "INSERT INTO Relations (MeaningId, Relation, Position, WordId) VALUES (@MeaningId, @Relation, @Position, @WordId)";
cmd.Parameters.Add(new SqlCeParameter("MeaningId", meaning_id));
cmd.Parameters.Add(new SqlCeParameter("Relation", SqlDbType.NVarChar));
cmd.Parameters.Add(new SqlCeParameter("Position", SqlDbType.SmallInt));
cmd.Parameters.Add(new SqlCeParameter("WordId", SqlDbType.UniqueIdentifier));
cmd.Prepare();
int position = 0;
foreach (IWord word in meaning.Antonyms)
{
Console.Write("synonym [{0}]...", word.Text);
cmd.Parameters["Relation"].Value = "A";
cmd.Parameters["Position"].Value = ++position;
cmd.Parameters["WordId"].Value = GetWordId(word, conn);
cmd.ExecuteNonQuery();
Console.WriteLine("ok");
}
}
}
protected void Dump(IMeaning meaning)
{
Dump(meaning.Translations);
// Dump(meaning.Synonyms);
// Dump(meaning.Antonyms);
Console.Out.WriteLine(meaning.Example);
Console.Out.WriteLine(meaning.Definition);
}
private static void ConvertMeaningCategories(IMeaning meaning, SqlCeConnection conn, Guid meaningId)
{
using (SqlCeCommand cmd = conn.CreateCommand())
{
cmd.CommandText = "INSERT INTO MeaningsCategories (MeaningId, CategoryId) VALUES (@MeaningId, @CategoryId)";
cmd.Parameters.Add(new SqlCeParameter("MeaningId", meaningId));
cmd.Parameters.Add(new SqlCeParameter("CategoryId", SqlDbType.UniqueIdentifier));
foreach (String category in meaning.Categories)
{
Guid categoryId = GetCategoryId(category, conn);
if (categoryId != Guid.Empty)
{
cmd.Parameters["CategoryId"].Value = categoryId;
cmd.ExecuteNonQuery();
}
}
}
}
protected MeaningValidator(IWord word, IMeaning meaning)
{
Debug.Assert(word != null);
this.word = word;
Debug.Assert(meaning != null);
this.meaning = meaning;
Hook(meaning.Translations);
Hook(meaning.Synonyms);
Hook(meaning.Antonyms);
Hook(meaning.Categories);
Hook(meaning);
}
protected internal InsertMeaningWordLookupValidator(IWord parentWord, IMeaning meaning, WordCollection childrenWords, LookupData lookup)
: base(parentWord, meaning, childrenWords, lookup)
{
Validate();
}
protected internal InsertMeaningValidator(IWord word, IMeaning meaning)
: base(word, meaning)
{
Validate();
}
protected internal EditMeaningWordLookupValidator(IWord parentWord, IMeaning meaning, WordCollection childrenWords, LookupData lookup)
: base(parentWord, meaning, childrenWords, lookup)
{
WordItem item = (WordItem)this.lookup.Data;
this.originalWord = item.Word;
Validate();
}
protected internal EditMeaningValidator(IWord word, IMeaning meaning, IMeaning meaningOriginal)
: base(word, meaning)
{
Debug.Assert(meaningOriginal != null);
this.meaningOriginal = meaningOriginal;
Validate();
}
public TranslationItem(String text, IMeaning meaning)
{
Debug.Assert(text != null);
Debug.Assert(meaning != null);
this.text = text;
this.meaning = meaning;
}
private void VerifyDuplicateItem(IMeaning item)
{
Debug.Assert(this.IndexOf(item) < 0);
if (this.IndexOf(item) >= 0)
{
throw new InternalDataException();
}
}
protected override void SetItem(int index, IMeaning item)
{
throw new InvalidOperationException();
}
protected override void InsertItem(int index, IMeaning item)
{
VerifySameVocabulary(item);
VerifyDuplicateItem(item);
this.CollectionChanged += new NotifyCollectionChangedEventHandler((item as MeaningImpl).OnMeaningsCollectionChanged);
base.InsertItem(index, item);
(item as VocabularyObject).Parent = this.word;
}
public IStatistics GetStatistics(IMeaning meaning)
{
MeaningImpl meaningImpl = (MeaningImpl)meaning;
StatisticsImpl statistics = null;
int index = this.statistics.BinarySearch(0, this.statistics.Count, meaningImpl, new Statistics_vs_MeaningComparer());
if (index < 0)
{
statistics = new StatisticsImpl(this, meaningImpl.Guid);
this.statistics.Insert(~index, statistics);
}
else
{
statistics = (StatisticsImpl)this.statistics[index];
}
return statistics;
}
public IStatistics this[IMeaning meaning]
{
get
{
return this.GetStatistics(meaning);
}
}
protected IMeaning FindSameMeaning(IMeaning meaning)
{
IMeaning same = null;
foreach (IMeaning m in this.word.Meanings)
{
if (m.Translations.Count == meaning.Translations.Count)
{
int i = 0;
for (i = 0; i < m.Translations.Count; ++i)
{
if (m.Translations[i] != meaning.Translations[i])
{
break;
}
}
if (i >= m.Translations.Count)
{
same = m;
break;
}
}
}
return same;
}
private void VerifySameVocabulary(IMeaning item)
{
Debug.Assert(item.Vocabulary == this.word.Vocabulary);
if (item.Vocabulary != this.word.Vocabulary)
{
throw new InternalDataException();
}
}
protected internal MeaningWordLookupValidator(IWord parentWord, IMeaning meaning, WordCollection childrenWords, LookupData lookup)
: base(lookup)
{
Debug.Assert(parentWord != null);
Debug.Assert(meaning != null);
Debug.Assert(childrenWords != null);
this.parentWord = parentWord;
this.meaning = meaning;
this.childrenWords = childrenWords;
}
private static void ConvertTranslations(IMeaning meaning, SqlCeConnection conn, Guid meaning_id)
{
using (SqlCeCommand cmd = conn.CreateCommand())
{
cmd.CommandText = "INSERT INTO Translations (MeaningId, Position, Translation) VALUES (@MeaningId, @Position, @Translation)";
cmd.Parameters.Add(new SqlCeParameter("MeaningId", meaning_id));
cmd.Parameters.Add(new SqlCeParameter("Position", SqlDbType.SmallInt));
cmd.Parameters.Add(new SqlCeParameter("Translation", SqlDbType.NVarChar));
cmd.Prepare();
int position = 0;
foreach (String translation in meaning.Translations)
{
Console.Write("MeaningId [{0}]...", translation);
cmd.Parameters["Position"].Value = ++position;
cmd.Parameters["Translation"].Value = translation;
cmd.ExecuteNonQuery();
Console.WriteLine("ok");
}
}
}
