public void TwoNoBlankLine()
{
var document = TestUtils.Test("definitionlist_two_noblankline");
Assert.Equal(1, document.Elements.Count);
DefinitionList list = (DefinitionList)document.Elements[0];
Assert.Equal(2, list.Items.Count);
{
DefinitionListItem item = list.Items[0];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("term 1", term.TextAreas[0].Content.Text);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("definition 1 (no blank line below)\n", paragraph.TextAreas[0].Content.Text);
}
{
DefinitionListItem item = list.Items[1];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("term 2", term.TextAreas[0].Content.Text);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("definition 2\n", paragraph.TextAreas[0].Content.Text);
}
}
public void ClassifierMultipleInlineMarkup()
{
var document = TestUtils.Test("definitionlist_classifier_multiple_inlinemarkup");
Assert.Equal(1, document.Elements.Count);
DefinitionList list = (DefinitionList)document.Elements[0];
Assert.Equal(1, list.Items.Count);
DefinitionListItem item = list.Items[0];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("Term", term.TextAreas[0].Content.Text);
Assert.Equal(2, item.Classifiers.Count);
Assert.Equal(ElementType.Strong, item.Classifiers[0].TextAreas[0].TypeCode);
Assert.Equal("classifier one", item.Classifiers[0].TextAreas[0].Content.Text);
Assert.Equal("classifier two", item.Classifiers[1].TextAreas[0].Content.Text);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("Definition\n", paragraph.TextAreas[0].Content.Text);
}
public void Paragraph()
{
var document = TestUtils.Test("definitionlist_paragraph");
Assert.Equal(2, document.Elements.Count);
DefinitionList list = (DefinitionList)document.Elements[0];
Assert.Equal(1, list.Items.Count);
DefinitionListItem item = list.Items[0];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("term", term.TextAreas[0].Content.Text);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("definition\n", paragraph.TextAreas[0].Content.Text);
var paragraph2 = (Paragraph)document.Elements[1];
Assert.Equal("paragraph\n", paragraph2.TextAreas[0].Content.Text);
}
public void AddCSharpCode(string key, string data)
{
if (!DefinitionList.ContainsKey(key))
{
DefinitionList.Add(key, data);
}
}
public void Classifier()
{
var document = TestUtils.Test("definitionlist_classifier");
Assert.Equal(1, document.Elements.Count);
DefinitionList list = (DefinitionList)document.Elements[0];
Assert.Equal(1, list.Items.Count);
DefinitionListItem item = list.Items[0];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("Term", term.TextAreas[0].Content.Text);
var classifier = item.Classifiers[0];
Assert.Equal(1, classifier.TextAreas.Count);
Assert.Equal(ElementType.Text, classifier.TextAreas[0].TypeCode);
Assert.Equal("classifier", classifier.TextAreas[0].Content.Text);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("The ' : ' indicates a classifier in\n", paragraph.TextAreas[0].Content.Text);
Assert.Equal("definition list item terms only.\n", paragraph.TextAreas[1].Content.Text);
}
protected SimpleObjectSerializationBase(object Value, DefinitionList defs) :
this(defs)
{
this.Object = Value;
if (Value == null)
{
return;
}
var type = Value.GetType();
if (type.IsArray)
{
IsArray = true;
type = type.GetElementType();
}
this.TypeCode = Type.GetTypeCode(type);
if (TypeCode == TypeCode.Object)
{
TypeRef = defs.RegisterType(type);
}
if (NeedRegister)
{
defs.Register(Object, this);
}
}
public string GetKey(int index)
{
if (index < DefinitionList.Count)
{
return((string)DefinitionList.ElementAt(index).Key);
}
return(string.Empty);
}
public string GetCSharpSyntax(int index)
{
if (index < DefinitionList.Count)
{
return((string)DefinitionList.ElementAt(index).Value);
}
return(string.Empty);
}
public Node DefList()
{
var defList = new DefinitionList();
while (Current == TokenCategory.VAR || Current == TokenCategory.IDENTIFIER)
{
defList.Add(Def());
}
return(defList);
}
private void TextBox_KeyUp(object sender, System.Windows.Input.KeyEventArgs e)
{
if (e.Key == System.Windows.Input.Key.Enter)
{
if ((sender as TextBox).Text.Trim() != "")
{
fvm.getDef(InputTextBox.Text.Trim());
}
DefinitionList.Focus();
}
}
/// <summary>
/// deserialization constructor
/// </summary>
protected SimpleObjectSerializationBase(BinaryReader b, DefinitionList defs)
: this(defs)
{
var by = b.ReadByte();
while (true)
{
if (by == TypeCodeCompressedStringCollection)
{
defs.Strings.Deserialize(b);
}
else if (by == TypeCodeTypeCollection)
{
defs.DeserializeTypes(b);
}
else if (by == TypeCodePreviousObject)
{
ObjectIndex = b.ReadUInt16();
var po = defs.Objects[ObjectIndex];
Object = po.Object;
TypeCode = po.Serializer.TypeCode;
IsArray = po.Serializer.IsArray;
return;
}
else
{
break;
}
by = b.ReadByte();
}
if ((by & CommandArraySpecifier) > 0)
{
IsArray = true;
by ^= CommandArraySpecifier;
}
if (by == 0)
{
return;
}
TypeCode = (TypeCode)by;
if (TypeCode == TypeCode.Object)
{
var tn = b.ReadUInt16();
TypeRef = defs.GetType(tn);
}
this.Object = Restore(b);
}
public Node DefList()
{
var defList = new DefinitionList()
{
};
while (firstOfDeclaration.Contains(CurrentToken))
{
defList.Add(Def());
}
return(defList);
}
public void WithoutClassifier()
{
var document = TestUtils.Test("definitionlist_classifier_without");
Assert.Equal(1, document.Elements.Count);
DefinitionList list = (DefinitionList)document.Elements[0];
Assert.Equal(3, list.Items.Count);
{
DefinitionListItem item = list.Items[0];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("Term: not a classifier", term.TextAreas[0].Content.Text);
Assert.Equal(0, item.Classifiers.Count);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("Because there\'s no space before the colon.\n", paragraph.TextAreas[0].Content.Text);
}
{
DefinitionListItem item = list.Items[1];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("Term :not a classifier", term.TextAreas[0].Content.Text);
Assert.Equal(0, item.Classifiers.Count);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("Because there\'s no space after the colon.\n", paragraph.TextAreas[0].Content.Text);
}
{
DefinitionListItem item = list.Items[2];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Text, term.TextAreas[0].TypeCode);
Assert.Equal("Term \\: not a classifier", term.TextAreas[0].Content.Text);
Assert.Equal(0, item.Classifiers.Count);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("Because the colon is escaped.\n", paragraph.TextAreas[0].Content.Text);
}
}
public Node Program()
{
var defList = new DefinitionList();
while (firstOfDefinition.Contains(CurrentToken))
{
defList.Add(Definition());
}
var result = new Program()
{
defList
};
result.AnchorToken = Expect(TokenCategory.EOF);
return(result);
}
public void DefinitionList()
{
var document = TestUtils.Test("blockquote_definitionlist");
Assert.Equal(6, document.Elements.Count);
{
Paragraph paragraph = (Paragraph)document.Elements[0];
Assert.Equal("Paragraph.\n", paragraph.TextAreas[0].Content.Text);
BlockQuote element = (BlockQuote)document.Elements[1];
Paragraph paragraph2 = (Paragraph)element.Elements[0];
Assert.Equal("-- Not an attribution\n", paragraph2.TextAreas[0].Content.Text);
Assert.Null(element.Attribution);
}
{
Paragraph paragraph = (Paragraph)document.Elements[2];
Assert.Equal("Paragraph.\n", paragraph.TextAreas[0].Content.Text);
BlockQuote element = (BlockQuote)document.Elements[3];
Paragraph paragraph2 = (Paragraph)element.Elements[0];
Assert.Equal("Block quote.\n", paragraph2.TextAreas[0].Content.Text);
Assert.Null(element.Attribution);
Paragraph paragraph3 = (Paragraph)element.Elements[1];
Assert.Equal("\\-- Not an attribution\n", paragraph3.TextAreas[0].Content.Text);
}
{
Paragraph paragraph = (Paragraph)document.Elements[4];
Assert.Equal("Paragraph.\n", paragraph.TextAreas[0].Content.Text);
BlockQuote element = (BlockQuote)document.Elements[5];
Paragraph paragraph2 = (Paragraph)element.Elements[0];
Assert.Equal("Block quote.\n", paragraph2.TextAreas[0].Content.Text);
Assert.Null(element.Attribution);
DefinitionList list = (DefinitionList)element.Elements[1];
var item1 = list.Items[0];
Assert.Equal("-- Not an attribution line one", item1.Term.TextAreas[0].Content.Text);
var list2 = (DefinitionList)item1.Definition.Elements[0];
var item2 = list2.Items[0];
Assert.Equal("and line two", item2.Term.TextAreas[0].Content.Text);
Assert.Equal("and line three\n", item2.Definition.Elements[0].TextAreas[0].Content.Text);
}
}
public void ClassifierLiteral()
{
var document = TestUtils.Test("definitionlist_classifier_literal");
Assert.Equal(1, document.Elements.Count);
DefinitionList list = (DefinitionList)document.Elements[0];
Assert.Equal(1, list.Items.Count);
DefinitionListItem item = list.Items[0];
var term = item.Term;
Assert.Equal(1, term.TextAreas.Count);
Assert.Equal(ElementType.Literal, term.TextAreas[0].TypeCode);
Assert.Equal("Term : not a classifier", term.TextAreas[0].Content.Text);
Assert.Equal(0, item.Classifiers.Count);
var definition = item.Definition;
Assert.Equal(1, definition.Elements.Count);
var paragraph = (Paragraph)definition.Elements[0];
Assert.Equal("Because the ' : ' is inside an inline literal.\n", paragraph.TextAreas[0].Content.Text);
}
private string FormatDefinitionList(DefinitionList comment)
{
return formatInlineList(comment.Items, "<dl>{0}</dl>", "{0}{1}", "<dt>{0}</dt>", "<dd>{0}</dd>");
}
private string FormatDefinitionList(DefinitionList comment)
{
return(formatInlineList(comment.Items, "<dl>{0}</dl>", "{0}{1}", "<dt>{0}</dt>", "<dd>{0}</dd>"));
}
public string Visit(DefinitionList node)
{
return(VisitChildren(node));
}
//-----------------------------------------------------------
public void Visit(DefinitionList node)
{
VisitChildren(node);
}
public override DefinitionList VisitDefinitionList(DefinitionList definitionList)
{
definitionList = definitionListDelegate?.Invoke(definitionList) ?? definitionList;
return(base.VisitDefinitionList(definitionList));
}
SimpleObjectSerializationBase(DefinitionList defs)
{
this.defs = defs;
}
private SimpleObjectDeserializer(BinaryReader b, DefinitionList types)
: base(b, types)
{
}
private SimpleObjectSerializer(object Value, SimpleObjectFieldSerializationMode FieldMode, DefinitionList Types)
: base(Value, Types)
{
this.FieldMode = FieldMode;
if (IsEmpty)
{
return;
}
if (IsArray)
{
Children = GetArrayValues().ToArray();
}
else if (TypeCode == TypeCode.Object)
{
this.CustomSerializer = Object as ICustomSerializer;
if (CustomSerializer != null && CustomSerializer.Initialize(this))
{
return;
}
Children = GetFields().ToArray();
}
else if (TypeCode == TypeCode.String)
{
StringIndex = defs.Strings.Add((string)Value);
}
}
