public void TestApplyStatement()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
ApplyStatement statement = parser.Statement(rc, "APPLY X <- X", true, true) as ApplyStatement;
Assert.IsNotNull(statement);
}
{
ApplyStatement statement = parser.Statement(rc, "APPLY X <- X ON V | X.", true, true) as ApplyStatement;
Assert.IsNotNull(statement);
DerefExpression deref = statement.ConditionExpression as DerefExpression;
Assert.IsNotNull(deref);
ITypedElement element = deref.Arguments[0].Ref as ITypedElement;
Assert.IsNotNull(element);
Assert.AreEqual(element.Type, s1);
}
}
public void TestRefactorNameSpaceName3()
{
Dictionary test = CreateDictionary("Test");
NameSpace n0 = CreateNameSpace(test, "N0");
NameSpace n1 = CreateNameSpace(n0, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Variable v = CreateVariable(n1, "V", "S1");
v.setDefaultValue("S1 { E1 => True }");
Function f = CreateFunction(n1, "f", "S2");
NameSpace n2 = CreateNameSpace(n0, "N2");
RuleCondition rc = CreateRuleAndCondition(n2, "Rule1");
PreCondition p = CreatePreCondition(rc, "N1.f().E2.E1");
Action a = CreateAction(rc, "N1.V <- N1.S1 { E1 => False }");
Refactor(n1, "NewN1");
Assert.AreEqual("S1 { E1 => True }", v.getDefaultValue());
Assert.AreEqual("NewN1.V <- NewN1.S1 { E1 => False }", a.ExpressionText);
Assert.AreEqual("NewN1.f().E2.E1", p.ExpressionText);
RefactorAndRelocate(p);
Assert.AreEqual("NewN1.f().E2.E1", p.ExpressionText);
}
public void NoProposalWhenInstanceIsNull()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Variable v = CreateVariable(n1, "V", "S1");
v.setDefaultValue("N1.S1 { E1 => True }");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
BaseEditorTextBox textBox = new BaseEditorTextBox();
{
// 0123456789
textBox.Text = "V <- N2.";
textBox.Instance = rc;
SortedSet <ObjectReference> choices = textBox.AllChoices(7, "");
Assert.IsNotNull(choices);
Assert.AreEqual(0, choices.Count);
}
}
public override void visit(StructureElement obj, bool visitSubNodes)
{
obj.setDefault("");
obj.setMode(acceptor.VariableModeEnumType.aInternal);
base.visit(obj, visitSubNodes);
}
public void TestFormalParameters()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S2");
CreateParameter(function, "p1", "S1");
Compiler.Compile_Synchronous(true, true);
Case cas = CreateCase(function, "case", "");
BaseEditorTextBox textBox = new BaseEditorTextBox();
{
// 0 1 2
// 012345678901234567890123456789
textBox.Text = "p1.";
textBox.Instance = cas;
SortedSet <ObjectReference> choices = textBox.AllChoices(2, "");
Assert.IsNotNull(choices);
Assert.AreEqual(1, choices.Count);
Assert.IsTrue(Contains(choices, el1));
}
}
public void TestUpdateFunction()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "S");
StructureElement el1 = CreateStructureElement(structure, "A", "Boolean");
RuleCondition condition = CreateRuleAndCondition(structure, "Cond");
Action action = CreateAction(condition, "A <- True");
Procedure procedure = CreateProcedure(structure, "P");
Parameter parameter = CreateParameter(procedure, "V", "Boolean");
RuleCondition condition2 = CreateRuleAndCondition(procedure, "Cond");
Action action2 = CreateAction(condition2, "A <- V");
Dictionary dictionary2 = CreateDictionary("TestUpdate");
dictionary2.setUpdates(dictionary.Guid);
Structure updatedStructure = structure.CreateStructureUpdate(dictionary2);
Compiler.Compile_Synchronous(true);
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(updatedStructure);
Assert.IsNull(ErrorMessage(updatedStructure));
}
public void TestMapExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
MapExpression expression = parser.Expression(rc, "MAP V | X. USING X IN X.E2", null, true, null, true, true) as MapExpression;
Assert.IsNotNull(expression);
DerefExpression deref = expression.Condition as DerefExpression;
Assert.IsNotNull(deref);
ITypedElement element = deref.Arguments[0].Ref as ITypedElement;
Assert.IsNotNull(element);
Assert.AreEqual(element.Type, s1);
}
}
public void TestListExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
VariableUpdateStatement statement = parser.Statement(rc, "V <- [S1 { E1 => Tr", true, true) as VariableUpdateStatement;
Assert.IsNotNull(statement);
UnaryExpression unaryExpression = statement.Expression as UnaryExpression;
Assert.IsNotNull(unaryExpression);
ListExpression listExpression = unaryExpression.Term.LiteralValue as ListExpression;
Assert.IsNotNull(listExpression);
Assert.AreEqual(listExpression.ListElements.Count, 1);
StructExpression structExpression = listExpression.ListElements[0] as StructExpression;
Assert.IsNotNull(structExpression);
}
}
public void TestTemplates()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Variable v = CreateVariable(n1, "V", "S2");
v.setDefaultValue("N1.S1 { E1 => True }");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
BaseEditorTextBox textBox = new BaseEditorTextBox();
{
// 0 1 2
// 012345678901234567890123456789
textBox.Text = "T";
textBox.Instance = rc;
SortedSet <ObjectReference> choices = textBox.AllChoices(0, "T");
Assert.IsNotNull(choices);
Assert.AreEqual(2, choices.Count);
Assert.IsTrue(Contains(choices, "THERE_IS X IN <collection> | <condition>"));
Assert.IsTrue(Contains(choices, "TARGETS"));
}
}
public static void Run()
{
// ExStart:TextStructureElements
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_WorkingDocuments();
// Create Pdf Document
Document document = new Document();
// Get Content for work with TaggedPdf
ITaggedContent taggedContent = document.TaggedContent;
// Set Title and Language for Documnet
taggedContent.SetTitle("Tagged Pdf Document");
taggedContent.SetLanguage("en-US");
// Get Root Structure Elements
StructureElement rootElement = taggedContent.RootElement;
ParagraphElement p = taggedContent.CreateParagraphElement();
// Set Text to Text Structure Element
p.SetText("Paragraph.");
rootElement.AppendChild(p);
// Save Tagged Pdf Document
document.Save(dataDir + "TextStructureElement.pdf");
// ExEnd:TextStructureElements
}
public void TestStructureDereference()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "Struct");
StructureElement el1 = CreateStructureElement(structure, "e1", "Boolean");
Function f = CreateFunction(nameSpace, "f", "Struct");
Variable v = CreateVariable(nameSpace, "v", "Struct");
Variable v2 = CreateVariable(nameSpace, "v2", "Boolean");
Parser parser = new Parser();
{
DerefExpression expression = parser.Expression(nameSpace, "N1.v.e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(v, expression.Arguments[1].Ref);
Assert.AreEqual(el1, expression.Arguments [2].Ref);
}
{
DerefExpression expression = parser.Expression(nameSpace, "N1.f().e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(2, expression.Arguments.Count);
Assert.AreEqual(structure, expression.Arguments [0].Ref);
Assert.AreEqual(el1, expression.Arguments [1].Ref);
}
{
DerefExpression expression = parser.Expression(nameSpace, "N1.Struct.e1") as DerefExpression;
Assert.IsNotNull(expression);
Assert.AreEqual(3, expression.Arguments.Count);
Assert.AreEqual(structure, expression.Arguments[1].Ref);
Assert.AreEqual(el1, expression.Arguments[2].Ref);
}
RuleCondition condition = CreateRuleAndCondition(nameSpace, "Test");
Action action1 = CreateAction(condition, "Struct.e1 <- True");
Action action2 = CreateAction(condition, "v2 <- Struct.e1");
Action action3 = CreateAction(condition, "f().e1 <- True");
Action action4 = CreateAction(condition, "v2 <- f().e1");
Collection collection = CreateCollection(nameSpace, "Col", "Struct", 10);
Variable v3 = CreateVariable(nameSpace, "v3", "Col");
Action action5 = CreateAction(condition, "(FIRST X IN v3).e1 <- True");
RuleCondition ruleCondition2 = CreateRuleAndCondition(structure, "Rule");
Action action6 = CreateAction(ruleCondition2, "THIS.e1 <- True");
Action action7 = CreateAction(ruleCondition2, "v2 <- THIS.e1");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.True(HasMessagePart(action1, "structure should not be used to reference an instance"));
Assert.True(HasMessagePart(action2, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action3, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action4, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action5, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action6, "structure should not be used to reference an instance"));
Assert.False(HasMessagePart(action7, "structure should not be used to reference an instance"));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="enclosing"></param>
/// <param name="structureElement"></param>
public Field(object enclosing, StructureElement structureElement)
{
Enclosing = enclosing;
StructureElement = structureElement;
Value = new DefaultValue(this);
DeclaredElements = null;
}
public void TestMapExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
// 0 1 2
// 012345678901234567890123456
const string text = "MAP V | X. USING X IN X.E1";
MapExpression expression = parser.Expression(rc, text, null, true, null, true, true) as MapExpression;
Assert.IsNotNull(expression);
ContextGrabber grabber = new ContextGrabber();
Assert.IsNull(grabber.GetContext(0, expression));
Assert.IsNull(grabber.GetContext(1, expression));
Assert.IsNull(grabber.GetContext(2, expression));
Assert.IsNull(grabber.GetContext(3, expression));
Assert.AreEqual(v, grabber.GetContext(4, expression));
Assert.AreEqual(v, grabber.GetContext(5, expression));
Assert.IsNull(grabber.GetContext(6, expression));
Assert.IsNull(grabber.GetContext(7, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(8, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(9, expression));
Assert.IsNull(grabber.GetContext(10, expression));
Assert.IsNull(grabber.GetContext(11, expression));
Assert.IsNull(grabber.GetContext(12, expression));
Assert.IsNull(grabber.GetContext(13, expression));
Assert.IsNull(grabber.GetContext(14, expression));
Assert.IsNull(grabber.GetContext(15, expression));
Assert.IsNull(grabber.GetContext(16, expression));
Assert.IsNull(grabber.GetContext(17, expression));
Assert.IsNull(grabber.GetContext(18, expression));
Assert.IsNull(grabber.GetContext(19, expression));
Assert.IsNull(grabber.GetContext(20, expression));
Assert.IsNull(grabber.GetContext(21, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(22, expression));
Assert.AreEqual(expression.IteratorVariable, grabber.GetContext(23, expression));
Assert.AreEqual(el1, grabber.GetContext(24, expression));
Assert.AreEqual(el1, grabber.GetContext(25, expression));
Assert.AreEqual(el1, grabber.GetContext(26, expression));
Assert.IsNull(grabber.GetContext(27, expression));
}
}
public void TestFunctionCall()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Variable v = CreateVariable(n1, "V", "S1");
v.setDefaultValue("N1.S1 { E1 => True }");
Function function = CreateFunction(n1, "f", "S1");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
// 0 1
// 012345678901
const string text = "V <- f().S";
VariableUpdateStatement statement = parser.Statement(rc, text, true, true) as VariableUpdateStatement;
ContextGrabber grabber = new ContextGrabber();
Assert.AreEqual(v, grabber.GetContext(0, statement));
Assert.AreEqual(v, grabber.GetContext(1, statement));
Assert.IsNull(grabber.GetContext(2, statement));
Assert.IsNull(grabber.GetContext(3, statement));
Assert.IsNull(grabber.GetContext(4, statement));
Assert.AreEqual(function, grabber.GetContext(5, statement));
Assert.AreEqual(function, grabber.GetContext(6, statement));
Assert.AreEqual(function, grabber.GetContext(7, statement));
Assert.AreEqual(s1, grabber.GetContext(8, statement));
Assert.IsNull(grabber.GetContext(9, statement));
Assert.IsNull(grabber.GetContext(10, statement));
}
{
// 0
// 0123456789
const string text = "V <- f().";
VariableUpdateStatement statement = parser.Statement(rc, text, true, true) as VariableUpdateStatement;
ContextGrabber grabber = new ContextGrabber();
Assert.AreEqual(v, grabber.GetContext(0, statement));
Assert.AreEqual(v, grabber.GetContext(1, statement));
Assert.IsNull(grabber.GetContext(2, statement));
Assert.IsNull(grabber.GetContext(3, statement));
Assert.IsNull(grabber.GetContext(4, statement));
Assert.AreEqual(function, grabber.GetContext(5, statement));
Assert.AreEqual(function, grabber.GetContext(6, statement));
Assert.AreEqual(function, grabber.GetContext(7, statement));
Assert.AreEqual(s1, grabber.GetContext(8, statement));
Assert.IsNull(grabber.GetContext(9, statement));
}
}
/// <summary>
/// Sets the target box for this arrow
/// </summary>
/// <param name="targetBox"></param>
public override void SetTargetBox(IGraphicalDisplay targetBox)
{
StructureElement structureElement = ReferencedModel as StructureElement;
Type type = targetBox as Type;
if (structureElement != null && type != null)
{
structureElement.Type = type;
Target = targetBox;
}
}
public static void Run()
{
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_WorkingDocuments();
string inFile = dataDir + "TH.pdf";
string outFile = dataDir + "TH_out.pdf";
string logFile = dataDir + "TH_out.xml";
// Open document
Document document = new Document(inFile);
// Gets tagged content and root structure element
ITaggedContent taggedContent = document.TaggedContent;
StructureElement rootElement = taggedContent.RootElement;
// Set title for tagged pdf document
taggedContent.SetTitle("Document with images");
foreach (FigureElement figureElement in rootElement.FindElements <FigureElement>(true))
{
// Set Alternative Text for Figure
figureElement.AlternativeText = "Figure alternative text (technique 2)";
// Create and Set BBox Attribute
StructureAttribute bboxAttribute = new StructureAttribute(AttributeKey.BBox);
bboxAttribute.SetRectangleValue(new Rectangle(0.0, 0.0, 100.0, 100.0));
StructureAttributes figureLayoutAttributes = figureElement.Attributes.GetAttributes(AttributeOwnerStandard.Layout);
figureLayoutAttributes.SetAttribute(bboxAttribute);
}
// Move Span Element into Paragraph (find wrong span and paragraph in first TD)
TableElement tableElement = rootElement.FindElements <TableElement>(true)[0];
SpanElement spanElement = tableElement.FindElements <SpanElement>(true)[0];
TableTDElement firstTdElement = tableElement.FindElements <TableTDElement>(true)[0];
ParagraphElement paragraph = firstTdElement.FindElements <ParagraphElement>(true)[0];
// Move Span Element into Paragraph
spanElement.ChangeParentElement(paragraph);
// Save document
document.Save(outFile);
// Checking PDF/UA Compliance for out document
document = new Document(outFile);
bool isPdfUaCompliance = document.Validate(logFile, PdfFormat.PDF_UA_1);
Console.WriteLine(String.Format("PDF/UA compliance: {0}", isPdfUaCompliance));
}
public void TestSimpleExpression()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Variable v = CreateVariable(n1, "V", "S1");
v.setDefaultValue("N1.S1 { E1 => True }");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
BaseEditorTextBox textBox = new BaseEditorTextBox();
{
// 0123456789
textBox.Text = "V <- N1.S";
textBox.Instance = rc;
SortedSet <ObjectReference> choices = textBox.AllChoices(7, "S");
Assert.IsNotNull(choices);
Assert.AreEqual(2, choices.Count);
Assert.IsTrue(Contains(choices, s1));
Assert.IsTrue(Contains(choices, s2));
}
{
// 0123456789
textBox.Text = "V <- N1.";
textBox.Instance = rc;
SortedSet <ObjectReference> choices = textBox.AllChoices(7, "");
Assert.IsNotNull(choices);
Assert.AreEqual(3, choices.Count);
Assert.IsTrue(Contains(choices, s1));
Assert.IsTrue(Contains(choices, s2));
Assert.IsTrue(Contains(choices, v));
}
{
// 0123456789
textBox.Text = "(F";
textBox.Instance = rc;
SortedSet <ObjectReference> choices = textBox.AllChoices(1, "F");
Assert.IsNotNull(choices);
Assert.AreEqual(4, choices.Count);
Assert.IsTrue(Contains(choices, "FILTER <collection> | <condition> USING X"));
Assert.IsTrue(Contains(choices, "FIRST X IN <collection> | <condition>"));
Assert.IsTrue(Contains(choices, "FORALL X IN <collection> | <condition>"));
Assert.IsTrue(Contains(choices, EfsSystem.Instance.FullDecelerationForTargetPredefinedFunction));
}
}
public static void Run()
{
// ExStart:AccessChildrenElements
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_WorkingDocuments();
// Open Pdf Document
Document document = new Document(dataDir + "StructureElementsTree.pdf");
// Get Content for work with TaggedPdf
ITaggedContent taggedContent = document.TaggedContent;
// Access to root element(s)
ElementList elementList = taggedContent.StructTreeRootElement.ChildElements;
foreach (Element element in elementList)
{
if (element is StructureElement)
{
StructureElement structureElement = element as StructureElement;
// Get properties
string title = structureElement.Title;
string language = structureElement.Language;
string actualText = structureElement.ActualText;
string expansionText = structureElement.ExpansionText;
string alternativeText = structureElement.AlternativeText;
}
}
// Access to children elements of first element in root element
elementList = taggedContent.RootElement.ChildElements[1].ChildElements;
foreach (Element element in elementList)
{
if (element is StructureElement)
{
StructureElement structureElement = element as StructureElement;
// Set properties
structureElement.Title = "title";
structureElement.Language = "fr-FR";
structureElement.ActualText = "actual text";
structureElement.ExpansionText = "exp";
structureElement.AlternativeText = "alt";
}
}
// Save Tagged Pdf Document
document.Save(dataDir + "AccessChildrenElements.pdf");
// ExEnd:AccessChildrenElements
}
private StructureElement GetElement(string name, string num)
{
if (name.HasValue())
{
var elem = new StructureElement
{
Sign = name,
Count = num.HasValue() ? num.ToNaturalOrZero() : 1
};
return(elem);
}
return(null);
}
public void TestRefactorElementStructureName2()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Variable variable = CreateVariable(n1, "A", "S1");
RuleCondition rc1 = CreateRuleAndCondition(n1, "Rule1");
Action action = CreateAction(rc1, "A <- S1 { E1 => False }");
Refactor(el1, "NewE1");
Assert.AreEqual("A <- S1 { NewE1 => False }", action.ExpressionText);
}
public override void visit(Generated.Procedure obj, bool visitSubNodes)
{
Procedure procedure = (Procedure)obj;
StateMachine stateMachine = procedure.StateMachine;
if (stateMachine.States.Count > 0)
{
stateMachine.Name = procedure.Name + "SM";
// Duplicate the process information
stateMachine.setImplemented(procedure.getImplemented());
stateMachine.setVerified(procedure.getVerified());
stateMachine.setNeedsRequirement(procedure.getNeedsRequirement());
foreach (ReqRef reqRef in procedure.Requirements)
{
stateMachine.appendRequirements(reqRef);
}
stateMachine.setComment(procedure.getComment());
NameSpace nameSpace = procedure.Enclosing as NameSpace;
if (nameSpace != null)
{
nameSpace.appendStateMachines(stateMachine);
Variable variable = (Variable)Generated.acceptor.getFactory().createVariable();
variable.Type = stateMachine;
variable.Name = procedure.Name;
variable.Mode = Generated.acceptor.VariableModeEnumType.aInternal;
nameSpace.appendVariables(variable);
nameSpace.removeProcedures(procedure);
}
Structure structure = procedure.Enclosing as Structure;
if (structure != null)
{
structure.appendStateMachines(stateMachine);
StructureElement element = (StructureElement)Generated.acceptor.getFactory().createStructureElement();
element.Type = stateMachine;
element.Name = procedure.Name;
element.Mode = Generated.acceptor.VariableModeEnumType.aInternal;
structure.appendElements(element);
structure.removeProcedures(procedure);
}
}
base.visit(obj, visitSubNodes);
}
public void TestApplyStatement()
{
Dictionary test = CreateDictionary("Test");
NameSpace n1 = CreateNameSpace(test, "N1");
Structure s1 = CreateStructure(n1, "S1");
StructureElement el1 = CreateStructureElement(s1, "E1", "Boolean");
Structure s2 = CreateStructure(n1, "S2");
StructureElement el2 = CreateStructureElement(s2, "E2", "S1");
Function function = CreateFunction(n1, "f", "S1");
Collection collection = CreateCollection(n1, "Col", "S1", 10);
Variable v = CreateVariable(n1, "V", "Col");
Compiler.Compile_Synchronous(true, true);
RuleCondition rc = CreateRuleAndCondition(n1, "Rule1");
Parser parser = new Parser();
{
// 0 1 2
// 012345678901234567890123
const string text = "APPLY X <- X ON V | X.";
ApplyStatement statement = parser.Statement(rc, text, true, true) as ApplyStatement;
Assert.IsNotNull(statement);
ContextGrabber grabber = new ContextGrabber();
Assert.IsNull(grabber.GetContext(0, statement));
Assert.IsNull(grabber.GetContext(1, statement));
Assert.IsNull(grabber.GetContext(2, statement));
Assert.IsNull(grabber.GetContext(3, statement));
Assert.IsNull(grabber.GetContext(4, statement));
Assert.IsNull(grabber.GetContext(5, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(6, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(7, statement));
Assert.IsNull(grabber.GetContext(8, statement));
Assert.IsNull(grabber.GetContext(9, statement));
Assert.IsNull(grabber.GetContext(10, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(11, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(12, statement));
Assert.IsNull(grabber.GetContext(13, statement));
Assert.IsNull(grabber.GetContext(14, statement));
Assert.IsNull(grabber.GetContext(15, statement));
Assert.AreEqual(v, grabber.GetContext(16, statement));
Assert.AreEqual(v, grabber.GetContext(17, statement));
Assert.IsNull(grabber.GetContext(18, statement));
Assert.IsNull(grabber.GetContext(19, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(20, statement));
Assert.AreEqual(statement.IteratorVariable, grabber.GetContext(21, statement));
Assert.IsNull(grabber.GetContext(22, statement));
}
}
public static void Run()
{
// ExStart:TextBlockStructureElements
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_AsposePdf_WorkingDocuments();
// Create Pdf Document
Document document = new Document();
// Get Content for work with TaggedPdf
ITaggedContent taggedContent = document.TaggedContent;
// Set Title and Language for Documnet
taggedContent.SetTitle("Tagged Pdf Document");
taggedContent.SetLanguage("en-US");
// Get Root Structure Element
StructureElement rootElement = taggedContent.RootElement;
HeaderElement h1 = taggedContent.CreateHeaderElement(1);
HeaderElement h2 = taggedContent.CreateHeaderElement(2);
HeaderElement h3 = taggedContent.CreateHeaderElement(3);
HeaderElement h4 = taggedContent.CreateHeaderElement(4);
HeaderElement h5 = taggedContent.CreateHeaderElement(5);
HeaderElement h6 = taggedContent.CreateHeaderElement(6);
h1.SetText("H1. Header of Level 1");
h2.SetText("H2. Header of Level 2");
h3.SetText("H3. Header of Level 3");
h4.SetText("H4. Header of Level 4");
h5.SetText("H5. Header of Level 5");
h6.SetText("H6. Header of Level 6");
rootElement.AppendChild(h1);
rootElement.AppendChild(h2);
rootElement.AppendChild(h3);
rootElement.AppendChild(h4);
rootElement.AppendChild(h5);
rootElement.AppendChild(h6);
ParagraphElement p = taggedContent.CreateParagraphElement();
p.SetText("P. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean nec lectus ac sem faucibus imperdiet. Sed ut erat ac magna ullamcorper hendrerit. Cras pellentesque libero semper, gravida magna sed, luctus leo. Fusce lectus odio, laoreet nec ullamcorper ut, molestie eu elit. Interdum et malesuada fames ac ante ipsum primis in faucibus. Aliquam lacinia sit amet elit ac consectetur. Donec cursus condimentum ligula, vitae volutpat sem tristique eget. Nulla in consectetur massa. Vestibulum vitae lobortis ante. Nulla ullamcorper pellentesque justo rhoncus accumsan. Mauris ornare eu odio non lacinia. Aliquam massa leo, rhoncus ac iaculis eget, tempus et magna. Sed non consectetur elit. Sed vulputate, quam sed lacinia luctus, ipsum nibh fringilla purus, vitae posuere risus odio id massa. Cras sed venenatis lacus.");
rootElement.AppendChild(p);
// Save Tagged Pdf Document
document.Save(dataDir + "TextBlockStructureElements.pdf");
// ExEnd:TextBlockStructureElements
}
public void TestRefactorInterfaceField()
{
Dictionary test = CreateDictionary("Test");
NameSpace n0 = CreateNameSpace(test, "N0");
Structure i1 = CreateStructure(n0, "I1");
i1.setIsAbstract(true);
StructureElement el1 = CreateStructureElement(i1, "E1", "Boolean");
Structure s1 = CreateStructure(n0, "S1");
StructureRef sr = CreateStructureRef(s1, "I1");
StructureElement el2 = CreateStructureElement(s1, "E1", "Boolean");
Refactor(el1, "NewE1");
Assert.AreEqual("NewE1", el2.Name);
}
/// <summary>
/// Actions to be taken when the variable's value changes
/// </summary>
/// <param name="cacheImpact"></param>
public void HandleChange(CacheImpact cacheImpact)
{
StructureValue value = Enclosing as StructureValue;
if (value != null)
{
IVariable variable = value.Enclosing as IVariable;
if (variable != null)
{
variable.HandleChange(cacheImpact);
}
}
StructureElement.HandleChange(cacheImpact);
}
public void TestRefactorNameSpaceName4()
{
Dictionary test = CreateDictionary("Test");
NameSpace n0 = CreateNameSpace(test, "N0");
NameSpace n1 = CreateNameSpace(n0, "N1");
Structure s1 = CreateStructure(n1, "S1");
StateMachine stataMachine = CreateStateMachine(s1, "StateMachine");
StructureElement el1 = CreateStructureElement(s1, "E1", "StateMachine");
NameSpace n2 = CreateNameSpace(n0, "N2");
Refactor(n2, "NewN2");
Assert.AreEqual(stataMachine, el1.Type);
Assert.AreEqual("StateMachine", el1.TypeName);
}
public void TestEnclosing()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace, "S");
StructureElement element = CreateStructureElement(structure, "E", "Integer");
StateMachine stateMachine = CreateStateMachine(structure, "SM");
RuleCondition condition = CreateRuleAndCondition(stateMachine, "Cond");
PreCondition preCondition = CreatePreCondition(condition, "ENCLOSING.E == 0");
RuleCheckerVisitor visitor = new RuleCheckerVisitor(dictionary);
visitor.visit(nameSpace);
Assert.Null(ErrorMessage(preCondition));
}
public void TestRefactorNameSpaceWithStructure()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace1 = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace1, "Test");
StructureElement structureElement = CreateStructureElement(structure, "El1", "Boolean");
Procedure procedure = CreateProcedure(structure, "ValidateEl1");
RuleCondition condition1 = CreateRuleAndCondition(procedure, "Set to True");
Action setTrue = CreateAction(condition1, "THIS.El1 <- True");
Variable variable = CreateVariable(nameSpace1, "V", "N1.Test");
Refactor(nameSpace1, "NameSpace");
Assert.AreEqual(((Action)condition1.Actions[0]).ExpressionText, "THIS.El1 <- True");
}
public void TestRefactorStructureAccessedwithFIRST_IN()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace1 = CreateNameSpace(dictionary, "N1");
Structure structure = CreateStructure(nameSpace1, "Test");
StructureElement element = CreateStructureElement(structure, "El", "Boolean");
Collection collection = CreateCollection(nameSpace1, "TestCol", "Test", 10);
Variable varCol = CreateVariable(nameSpace1, "var", "TestCol");
Function function = CreateFunction(nameSpace1, "TestFun", "Boolean");
Case case1 = CreateCase(function, "Value", "(FIRST X IN var).El");
Refactor(structure, "TestStructure");
Assert.AreEqual(((Case)function.Cases[0]).ExpressionText, "(FIRST X IN var).El");
}
public void TestBugReport669()
{
Dictionary dictionary = CreateDictionary("Test");
NameSpace nameSpace1 = CreateNameSpace(dictionary, "N1");
Enum enumeration = CreateEnum(nameSpace1, "Mode");
Enum enum2 = CreateEnum(enumeration, "M");
Structure structure = CreateStructure(nameSpace1, "Struct");
StructureElement element = CreateStructureElement(structure, "E", "Mode.M");
Function function = CreateFunction(nameSpace1, "F", "Mode.M");
Refactor(enumeration, "ModeEnum");
Assert.AreEqual(element.Type, enum2);
Assert.AreEqual(element.TypeName, "ModeEnum.M");
Assert.AreEqual(function.TypeName, "ModeEnum.M");
}
/// <summary>
/// Indicates if the given structure element is inherited from an interface or not
/// </summary>
/// <param name="anElement"></param>
/// <returns></returns>
public bool StructureElementIsInherited(StructureElement anElement)
{
bool retVal = false;
foreach (Structure inheritedStructure in Interfaces)
{
if (inheritedStructure != null)
{
foreach (StructureElement inheritedElement in inheritedStructure.Elements)
{
if (anElement.Name.Equals(inheritedElement.Name))
{
retVal = true;
break;
}
}
}
}
return retVal;
}
/// <summary>
/// Creates a copy of the structure element in the designated dictionary. The namespace structure is copied over.
/// The new structure element is set to update this one.
/// </summary>
/// <param name="dictionary">The target dictionary of the copy</param>
/// <returns></returns>
public StructureElement CreateStructureElementUpdate(Dictionary dictionary)
{
StructureElement retVal = new StructureElement();
retVal.Name = Name;
retVal.TypeName = TypeName;
retVal.Comment = Comment;
retVal.setUpdates(Guid);
String[] names = FullName.Split('.');
names = names.Take(names.Count() - 1).ToArray();
String[] nameSpaceRef = names.Take(names.Count() - 1).ToArray();
NameSpace nameSpace = dictionary.GetNameSpaceUpdate(nameSpaceRef, Dictionary);
Structure structure = nameSpace.GetStructureUpdate(names.Last(), (NameSpace)nameSpace.Updates);
structure.appendElements(retVal);
return retVal;
}
