/// <summary>
/// Formats the specified begin token.
/// </summary>
/// <param name="beginToken">The begin token.</param>
/// <returns>The token in serialized form.</returns>
protected override string Format(BeginToken beginToken)
{
var dict = new Dictionary <string, string> {
{ "name", beginToken.Name },
{ "id", beginToken.Id.ToString() }
};
return(CreateNodeStart(typeCache[beginToken.TypeId], dict));
}
/// <summary>
/// Formats the specified begin token.
/// </summary>
/// <param name="beginToken">The begin token.</param>
/// <returns>The token in serialized form.</returns>
protected override string Format(BeginToken beginToken)
{
var dict = new Dictionary <string, string> {
{ "name", beginToken.Name },
{ "typeId", beginToken.TypeId.ToString() },
{ "id", beginToken.Id.ToString() }
};
AddTypeInfo(beginToken.TypeId, dict);
return(CreateNodeStart(XmlStringConstants.COMPOSITE, dict));
}
public override bool IsValue(string term, string term2 = null)
{
if (BeginToken != null)
{
return(BeginToken.IsValue(term, term2));
}
else
{
return(false);
}
}
private void CompositeStartHandler(BeginToken token)
{
InstantiateParent();
Type type = typeIds[(int)token.TypeId];
try {
parentStack.Push(new Midwife(type, (ICompositeSerializer)serializerMapping[type], token.Id));
} catch (Exception e) {
if (e is InvalidCastException || e is KeyNotFoundException)
{
throw new PersistenceException(String.Format(
"Invalid composite serializer configuration for type \"{0}\".",
type.AssemblyQualifiedName), e);
}
else
{
throw new PersistenceException(String.Format(
"Unexpected exception while trying to compose object of type \"{0}\".",
type.AssemblyQualifiedName), e);
}
}
}
/// <summary>
/// Formats the specified begin token.
/// </summary>
/// <param name="beginToken">The begin token.</param>
/// <returns>The token in serialized form.</returns>
protected override string Format(BeginToken beginToken)
{
StringBuilder sb = new StringBuilder();
if (isSepReq)
{
sb.Append(", ");
}
if (!string.IsNullOrEmpty(beginToken.Name))
{
sb.Append(beginToken.Name);
if (beginToken.Id != null && showRefs)
{
sb.Append('[');
sb.Append(beginToken.Id);
sb.Append(']');
}
}
sb.Append("(");
isSepReq = false;
return(sb.ToString());
}
public override string GetNormalCaseText(Pullenti.Morph.MorphClass mc = null, Pullenti.Morph.MorphNumber num = Pullenti.Morph.MorphNumber.Undefined, Pullenti.Morph.MorphGender gender = Pullenti.Morph.MorphGender.Undefined, bool keepChars = false)
{
Pullenti.Ner.Core.GetTextAttr attr = Pullenti.Ner.Core.GetTextAttr.No;
if (num == Pullenti.Morph.MorphNumber.Singular)
{
attr |= Pullenti.Ner.Core.GetTextAttr.FirstNounGroupToNominativeSingle;
}
else
{
attr |= Pullenti.Ner.Core.GetTextAttr.FirstNounGroupToNominative;
}
if (keepChars)
{
attr |= Pullenti.Ner.Core.GetTextAttr.KeepRegister;
}
if (BeginToken == EndToken)
{
return(BeginToken.GetNormalCaseText(mc, num, gender, keepChars));
}
else
{
return(Pullenti.Ner.Core.MiscHelper.GetTextValue(BeginToken, EndToken, attr));
}
}
/// <summary> /// Formats the specified begin token. /// </summary> /// <param name="beginToken">The begin token.</param> /// <returns>The token in serialized form.</returns> protected abstract T Format(BeginToken beginToken);
public Token GetToken()
{
State = LexicAnalyserState.Initial;
Value = HasNext ? Character.ToString() : "";
Token token = null;
while (HasNext && token == null)
{
switch (State)
{
case LexicAnalyserState.Initial:
HandleInitial();
break;
case LexicAnalyserState.NonTerminal:
token = new NonTerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Space:
token = new SpaceToken();
CurrentIndex++;
break;
case LexicAnalyserState.Terminal:
token = new TerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Empty:
token = new EmptyToken();
CurrentIndex++;
break;
case LexicAnalyserState.NewLine:
token = new NewLineToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Identifier:
token = new IdentifierToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Number:
token = new NumberToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Var:
token = new VarToken();
CurrentIndex++;
break;
case LexicAnalyserState.Write:
token = new WriteToken();
CurrentIndex++;
break;
case LexicAnalyserState.Read:
token = new ReadToken();
CurrentIndex++;
break;
case LexicAnalyserState.If:
token = new IfToken();
CurrentIndex++;
break;
case LexicAnalyserState.End:
token = new EndToken();
CurrentIndex++;
break;
case LexicAnalyserState.Then:
token = new ThenToken();
CurrentIndex++;
break;
case LexicAnalyserState.Begin:
token = new BeginToken();
CurrentIndex++;
break;
case LexicAnalyserState.While:
token = new WhileToken();
CurrentIndex++;
break;
case LexicAnalyserState.Do:
token = new DoToken();
CurrentIndex++;
break;
case LexicAnalyserState.SemiColon:
token = new SemiColonToken();
CurrentIndex++;
break;
case LexicAnalyserState.OpenParentheses:
token = new OpenParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.CloseParentheses:
token = new CloseParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.Plus:
token = new PlusToken();
CurrentIndex++;
break;
case LexicAnalyserState.Sub:
token = new SubToken();
CurrentIndex++;
break;
case LexicAnalyserState.Great:
token = new GreatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Less:
token = new LessToken();
CurrentIndex++;
break;
case LexicAnalyserState.Equal:
token = new EqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.Repeat:
token = new RepeatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Until:
token = new UntilToken();
CurrentIndex++;
break;
case LexicAnalyserState.Attribution:
token = new AttributionToken();
CurrentIndex++;
break;
case LexicAnalyserState.NotEqual:
token = new NotEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.GreatOrEqual:
token = new GreatOrEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.LessOrEqual:
token = new LessOrEqualToken();
CurrentIndex++;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(token);
}
public override string GetNormalCaseText(Pullenti.Morph.MorphClass mc = null, Pullenti.Morph.MorphNumber num = Pullenti.Morph.MorphNumber.Undefined, Pullenti.Morph.MorphGender gender = Pullenti.Morph.MorphGender.Undefined, bool keepChars = false)
{
if ((BeginToken is Pullenti.Ner.ReferentToken) && BeginToken == EndToken)
{
return(BeginToken.GetNormalCaseText(mc, num, gender, keepChars));
}
string res = null;
int maxCoef = 0;
int defCoef = -1;
foreach (Pullenti.Morph.MorphBaseInfo it in Morph.Items)
{
NounPhraseItemTextVar v = it as NounPhraseItemTextVar;
if (v == null)
{
continue;
}
if (v.UndefCoef > 0 && (((v.UndefCoef < maxCoef) || defCoef >= 0)))
{
continue;
}
if (num == Pullenti.Morph.MorphNumber.Singular && v.SingleNumberValue != null)
{
if (mc != null && ((gender == Pullenti.Morph.MorphGender.Neuter || gender == Pullenti.Morph.MorphGender.Feminie)) && mc.IsAdjective)
{
Pullenti.Morph.MorphBaseInfo bi = new Pullenti.Morph.MorphBaseInfo()
{
Class = new Pullenti.Morph.MorphClass()
{
Value = mc.Value
}, Gender = gender, Number = Pullenti.Morph.MorphNumber.Singular, Case = Pullenti.Morph.MorphCase.Nominative, Language = Morph.Language
};
string str = Pullenti.Morph.MorphologyService.GetWordform(v.SingleNumberValue, bi);
if (str != null)
{
res = str;
}
}
else
{
res = v.SingleNumberValue;
}
if (v.UndefCoef == 0)
{
break;
}
maxCoef = v.UndefCoef;
continue;
}
if (string.IsNullOrEmpty(v.NormalValue))
{
continue;
}
if (char.IsDigit(v.NormalValue[0]) && mc != null && mc.IsAdjective)
{
int val;
if (int.TryParse(v.NormalValue, out val))
{
string str = Pullenti.Ner.Core.NumberHelper.GetNumberAdjective(val, gender, (num == Pullenti.Morph.MorphNumber.Singular || val == 1 ? Pullenti.Morph.MorphNumber.Singular : Pullenti.Morph.MorphNumber.Plural));
if (str != null)
{
res = str;
if (v.UndefCoef == 0)
{
break;
}
maxCoef = v.UndefCoef;
continue;
}
}
}
string res1 = (it as NounPhraseItemTextVar).NormalValue;
if (num == Pullenti.Morph.MorphNumber.Singular)
{
if (res1 == "ДЕТИ")
{
res1 = "РЕБЕНОК";
}
else if (res1 == "ЛЮДИ")
{
res1 = "ЧЕЛОВЕК";
}
}
maxCoef = v.UndefCoef;
if (v.UndefCoef > 0)
{
res = res1;
continue;
}
int defCo = 0;
if (mc != null && mc.IsAdjective && v.UndefCoef == 0)
{
}
else if (((BeginToken is Pullenti.Ner.TextToken) && res1 == (BeginToken as Pullenti.Ner.TextToken).Term && it.Case.IsNominative) && it.Number == Pullenti.Morph.MorphNumber.Singular)
{
defCo = 1;
}
if (num == Pullenti.Morph.MorphNumber.Plural && ((v.Number & Pullenti.Morph.MorphNumber.Plural)) == Pullenti.Morph.MorphNumber.Plural)
{
defCo += 3;
}
if (res == null || defCo > defCoef)
{
res = res1;
defCoef = defCo;
if (defCo > 0)
{
break;
}
}
}
if (res != null)
{
return(this._corrChars(res, keepChars));
}
if (res == null && BeginToken == EndToken)
{
res = BeginToken.GetNormalCaseText(mc, num, gender, keepChars);
}
else if (res == null)
{
res = BeginToken.GetNormalCaseText(mc, num, gender, keepChars);
if (res == null)
{
res = Pullenti.Ner.Core.MiscHelper.GetTextValueOfMetaToken(this, (keepChars ? Pullenti.Ner.Core.GetTextAttr.KeepRegister : Pullenti.Ner.Core.GetTextAttr.No));
}
else
{
res = string.Format("{0} {1}", res, Pullenti.Ner.Core.MiscHelper.GetTextValue(BeginToken.Next, EndToken, (keepChars ? Pullenti.Ner.Core.GetTextAttr.KeepRegister : Pullenti.Ner.Core.GetTextAttr.No)));
}
}
return(res ?? "?");
}
public override bool IsValue(string term, string termUA = null)
{
return(BeginToken.IsValue(term, termUA));
}
