public string[] Conjugate(ENUM_VERB_TYPE verbType)
{
VerbEntry ve;
m_verbWrapper = new VerbWrapper();
List <string> lst = new List <string>();
m_verbInfoContainer.ResetIndex();
while ((ve = m_verbInfoContainer.GetVerbEntry()) != null)
{
m_verbWrapper.SetVerbEntry(ve);
m_verbWrapper.setTensePassivity(ENUM_TENSE_PASSIVITY.ACTIVE);
if (verbType.Has(ENUM_VERB_TYPE.INFINITIVE))
{
lst.AddRange(m_verbWrapper.PrintInfinitive());
}
if (!verbType.Has(ve.verbType))
{
continue;
}
#region Conjugate
foreach (ENUM_TENSE_TIME tm in m_timeList)
{
m_verbWrapper.setTenseTime(tm);
//foreach (ENUM_TENSE_OBJECT obj in Enum.GetValues(typeof(ENUM_TENSE_OBJECT)))
foreach (ENUM_TENSE_POSITIVITY pos in Enum.GetValues(typeof(ENUM_TENSE_POSITIVITY)))
{
m_verbWrapper.setTensePositivity(pos);
if (!m_verbWrapper.IsValidPositivity())
{
continue;
}
foreach (ENUM_TENSE_PERSON person in Enum.GetValues(typeof(ENUM_TENSE_PERSON)))
{
if (person == ENUM_TENSE_PERSON.INVALID || person == ENUM_TENSE_PERSON.UNMACHED_SEGMENT)
{
continue;
}
m_verbWrapper.setTensePerson(person);
if (m_verbWrapper.isValidTense(ENUM_VERB_TRANSITIVITY.INTRANSITIVE))
{
lst.Add(m_verbWrapper.PrintVerb().Split(' ')[0]);
}
}
}
}
#endregion
}
return(lst.Distinct().ToArray());
}
public VerbEntry()
{
this.pastStem = "";
this.presentStem = "";
this.transitivity = ENUM_VERB_TRANSITIVITY.INVALID;
this.verbType = ENUM_VERB_TYPE.INVALID;
this.pishvand = "";
this.felyar = "";
this.harfe_ezafe = "";
}
public VerbEntry(
string past_stem,
string present_stem,
ENUM_VERB_TRANSITIVITY transitivity,
ENUM_VERB_TYPE verb_type,
string _pishvand,
string _felyar,
string h_ezafe)
{
this.SetVerbEntry(past_stem, present_stem, transitivity, verb_type, _pishvand, _felyar, h_ezafe);
}
private void addVerbEntry(
string mazi,
string mozare,
ENUM_VERB_TRANSITIVITY transitivity,
ENUM_VERB_TYPE verb_type,
string _pishvand,
string _felyar,
string h_ezafe)
{
VerbEntry ve = new VerbEntry();
ve.SetVerbEntry(mazi, mozare, transitivity, verb_type, _pishvand, _felyar, h_ezafe);
this.entrys.Add(ve);
}
public VerbInfo[] ConjugateInfo(ENUM_VERB_TYPE verbType)
{
List <VerbInfo> lst = new List <VerbInfo>();
foreach (ENUM_TENSE_PERSON pers in Enum.GetValues(typeof(ENUM_TENSE_PERSON)))
{
if (pers == ENUM_TENSE_PERSON.INVALID || pers == ENUM_TENSE_PERSON.UNMACHED_SEGMENT)
{
continue;
}
lst.AddRange(ConjugateInfo(verbType, pers));
}
return(lst.ToArray());
}
public void SetVerbEntry(
string past_stem,
string present_stem,
ENUM_VERB_TRANSITIVITY transitivity,
ENUM_VERB_TYPE verb_type,
string _pishvand,
string _felyar,
string h_ezafe)
{
this.pastStem = past_stem;
this.presentStem = present_stem;
this.transitivity = transitivity;
this.verbType = verb_type;
this.pishvand = _pishvand;
this.felyar = _felyar;
this.harfe_ezafe = h_ezafe;
this.SetStemAlpha();
}
public GroupPattern GetFelyarPattern(ENUM_VERB_TYPE vtype)
{
GroupPattern gp = new GroupPattern();
List <string> strList = new List <string>();
this.entrys.ForEach(delegate(VerbEntry ve)
{
if ((ve.felyar != "") && (ve.verbType == vtype) && !strList.Contains(ve.felyar))
{
strList.Add(ve.felyar);
}
});
strList.ForEach(delegate(string s)
{
gp.addUnit(s);
});
return(gp);
}
public ENUM_VERB_TYPE getTenseType()
{
Int32 mask = Convert.ToInt32(ENUM_VERB_TYPE.INVALID);
ENUM_VERB_TYPE vtt = (ENUM_VERB_TYPE)(this.ID & mask);
switch (vtt)
{
case ENUM_VERB_TYPE.SADE:
case ENUM_VERB_TYPE.PISHVANDI:
case ENUM_VERB_TYPE.PISHVANDI_MORAKKAB:
case ENUM_VERB_TYPE.MORAKKAB:
case ENUM_VERB_TYPE.EBARATE_FELI:
case ENUM_VERB_TYPE.NAGOZAR:
case ENUM_VERB_TYPE.ESNADI:
case ENUM_VERB_TYPE.GHEIRE_SHAKHSI:
return(vtt);
default:
return(ENUM_VERB_TYPE.INVALID);
}
}
public void setTenseType(ENUM_VERB_TYPE type)
{
this.ID = this.ID & ~Convert.ToInt32(ENUM_VERB_TYPE.INVALID);
this.ID |= Convert.ToInt32(type);
}
public GroupPattern GetStemPatten(STEM_TIME st, STEM_ALPHA vs, ENUM_VERB_TYPE verb_type, ENUM_PATTERN_GENERALITY generality)
{
GroupPattern dp = new GroupPattern();
dp.stemAlpha = vs;
dp.stemTime = st;
string generalVerb = ".{2,4}";
switch (st)
{
case STEM_TIME.MAZI:
switch (vs)
{
case STEM_ALPHA.A_X:
case STEM_ALPHA.A_B:
case STEM_ALPHA.A_A:
if (generality == ENUM_PATTERN_GENERALITY.EXPLICIT)
{
this.entrys.ForEach(delegate(VerbEntry ve)
{
if ((ve.StartingAlpha(STEM_TIME.MAZI) == STEM_ALPHA.A_X) && (ve.verbType == verb_type))
{
dp.addUnit(ve.GetTail(STEM_TIME.MAZI));
}
});
dp.pattern = "[آا](?:" + dp.pattern + ")";
}
else
{
dp.pattern = "[آا](?:" + generalVerb + ")";
}
break;
case STEM_ALPHA.B_X:
case STEM_ALPHA.B_B:
case STEM_ALPHA.B_A:
if (generality == ENUM_PATTERN_GENERALITY.EXPLICIT)
{
this.entrys.ForEach(delegate(VerbEntry ve)
{
if ((ve.StartingAlpha(STEM_TIME.MAZI) == STEM_ALPHA.B_X) && (ve.verbType == verb_type))
{
dp.addUnit(ve.pastStem);
}
});
}
else
{
dp.pattern = generalVerb;
}
break;
default:
break;
}
break;
case STEM_TIME.MOZARE:
switch (vs)
{
case STEM_ALPHA.A_B:
if (generality == ENUM_PATTERN_GENERALITY.EXPLICIT)
{
this.entrys.ForEach(delegate(VerbEntry ve)
{
if ((ve.BoundingAlpha(STEM_TIME.MOZARE) == STEM_ALPHA.A_B) && (ve.verbType == verb_type))
{
dp.addUnit(ve.GetTail(STEM_TIME.MOZARE));
}
});
dp.pattern = "[آا](?:" + dp.pattern + ")";
}
else
{
dp.pattern = "[آا](?:" + generalVerb + ")";
}
break;
case STEM_ALPHA.A_A:
if (generality == ENUM_PATTERN_GENERALITY.EXPLICIT)
{
this.entrys.ForEach(delegate(VerbEntry ve)
{
if ((ve.BoundingAlpha(STEM_TIME.MOZARE) == STEM_ALPHA.A_A) && (ve.verbType == verb_type))
{
dp.addUnit(ve.GetTail(STEM_TIME.MOZARE));
}
});
dp.pattern = "[آا](?:" + dp.pattern + ")";
}
else
{
dp.pattern = "[آا](?:" + generalVerb + ")";
}
break;
case STEM_ALPHA.B_B:
if (generality == ENUM_PATTERN_GENERALITY.EXPLICIT)
{
this.entrys.ForEach(delegate(VerbEntry ve)
{
if ((ve.BoundingAlpha(STEM_TIME.MOZARE) == STEM_ALPHA.B_B) && (ve.verbType == verb_type))
{
dp.addUnit(ve.presentStem);
}
});
}
else
{
dp.pattern = generalVerb;
}
break;
case STEM_ALPHA.B_A:
if (generality == ENUM_PATTERN_GENERALITY.EXPLICIT)
{
this.entrys.ForEach(delegate(VerbEntry ve)
{
if ((ve.BoundingAlpha(STEM_TIME.MOZARE) == STEM_ALPHA.B_A) && (ve.verbType == verb_type))
{
dp.addUnit(ve.presentStem);
}
});
}
else
{
dp.pattern = "[آا](?:" + generalVerb + ")";
}
break;
default:
break;
}
break;
}
return(dp);
}
public bool LoadStemFile(string fileName)
{
this.entrys.Clear();
// Specify file, instructions, and privelegdes
FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read);
// Create a new stream to read from a file
StreamReader sr = new StreamReader(file);
//int startPos = 0;
Regex r = new Regex("([\\d])\\s+([\\d])\\s+([^\\s]+)\\s+([^\\s]+)\\s+([^\\s]+)\\s+([^\\s]+)\\s+([^\\s]+)");
Match m;
string mazi = "";
string mozare = "";
ENUM_VERB_TRANSITIVITY trans = ENUM_VERB_TRANSITIVITY.INVALID;
ENUM_VERB_TYPE vtype = ENUM_VERB_TYPE.INVALID;
string felyar = "";
string pishvand = "";
string h_ezafe = "";
string input = null;
while ((input = sr.ReadLine()) != null)
{
m = r.Match(input);
if (m.Success)
{
// Verb Type
switch (Convert.ToInt32(m.Groups[1].Value))
{
case 1:
vtype = ENUM_VERB_TYPE.SADE;
break;
case 2:
vtype = ENUM_VERB_TYPE.PISHVANDI;
break;
case 3:
vtype = ENUM_VERB_TYPE.MORAKKAB;
break;
case 4:
vtype = ENUM_VERB_TYPE.PISHVANDI_MORAKKAB;
break;
case 5:
vtype = ENUM_VERB_TYPE.EBARATE_FELI;
break;
case 6:
vtype = ENUM_VERB_TYPE.NAGOZAR;
break;
case 7:
break;
default:
vtype = ENUM_VERB_TYPE.INVALID;
break;
}
// Verb Transitivity
if (m.Groups[2].Value == "0")
{
trans = ENUM_VERB_TRANSITIVITY.INTRANSITIVE;
}
else if (m.Groups[2].Value == "1")
{
trans = ENUM_VERB_TRANSITIVITY.TRANSITIVE;
}
else if (m.Groups[2].Value == "2")
{
trans = ENUM_VERB_TRANSITIVITY.BILATERAL;
}
// Verb Stem
mazi = m.Groups[3].Value;
mozare = m.Groups[4].Value;
// Components
felyar = m.Groups[5].Value;
if (felyar == "-")
{
felyar = "";
}
pishvand = m.Groups[6].Value;
if (pishvand == "-")
{
pishvand = "";
}
h_ezafe = m.Groups[7].Value;
if (h_ezafe == "-")
{
h_ezafe = "";
}
this.addVerbEntry(mazi, mozare, trans, vtype, pishvand, felyar, h_ezafe);
}
}
// Close StreamReader
sr.Close();
// Close file
file.Close();
if (this.entrys.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
