package org.eclipse.rmf.tests.reqif10.serialization.uc006;
import java.io.IOException;
import java.math.BigInteger;
import java.util.GregorianCalendar;
import org.eclipse.rmf.reqif10.AttributeDefinitionEnumeration;
import org.eclipse.rmf.reqif10.AttributeDefinitionString;
import org.eclipse.rmf.reqif10.AttributeDefinitionXHTML;
import org.eclipse.rmf.reqif10.AttributeValueEnumeration;
import org.eclipse.rmf.reqif10.AttributeValueString;
import org.eclipse.rmf.reqif10.AttributeValueXHTML;
import org.eclipse.rmf.reqif10.DatatypeDefinitionEnumeration;
import org.eclipse.rmf.reqif10.DatatypeDefinitionString;
import org.eclipse.rmf.reqif10.DatatypeDefinitionXHTML;
import org.eclipse.rmf.reqif10.EmbeddedValue;
import org.eclipse.rmf.reqif10.EnumValue;
import org.eclipse.rmf.reqif10.ReqIF10Factory;
import org.eclipse.rmf.reqif10.SpecHierarchy;
import org.eclipse.rmf.reqif10.SpecObject;
import org.eclipse.rmf.reqif10.SpecObjectType;
import org.eclipse.rmf.reqif10.Specification;
import org.eclipse.rmf.reqif10.SpecificationType;
import org.eclipse.rmf.reqif10.XhtmlContent;
import org.eclipse.rmf.reqif10.common.util.ReqIF10XHtmlContentAdapter;
import org.eclipse.rmf.reqif10.common.util.ReqIF10XHtmlContentAdapterFactory;
import org.eclipse.rmf.tests.reqif10.serialization.util.SimpleModelBuilder;
@SuppressWarnings("nls")
public class RichTextModelBuilder extends SimpleModelBuilder {
// Convenience
private static final ReqIF10Factory factory = ReqIF10Factory.eINSTANCE;
private static GregorianCalendar DATE = new GregorianCalendar(2014, 8, 1);
private DatatypeDefinitionString t_kind;
private DatatypeDefinitionXHTML t_xhtml;
private DatatypeDefinitionEnumeration t_recommended;
private DatatypeDefinitionString t_description;
private AttributeDefinitionString ad_kind;
private AttributeDefinitionXHTML ad_xhtml;
private AttributeDefinitionEnumeration ad_recommended;
private AttributeDefinitionString ad_description;
private SpecObjectType specObjecttype;
private SpecificationType specType;
public RichTextModelBuilder() throws Exception {
super("rich-test", "XHTML Test");
getReqIF().getTheHeader().setCreationTime(DATE);
}
/**
* Two datatypes: Enumeration and XHTML
*/
@Override
public void createDatatypes() throws Exception {
createDatatypeKind();
createDatatypeXHTML();
createDatatypeRecommended();
createDatatypeDescription();
}
private void createDatatypeKind() throws Exception {
t_kind = factory.createDatatypeDefinitionString();
t_kind.setLongName("T_Kind");
t_kind.setIdentifier("T_Kind");
t_kind.setLastChange(DATE);
t_kind.setMaxLength(new BigInteger("1000"));
getReqIF().getCoreContent().getDatatypes().add(t_kind);
}
private void createDatatypeXHTML() throws Exception {
t_xhtml = factory.createDatatypeDefinitionXHTML();
t_xhtml.setLongName("T_Xhtml");
t_xhtml.setIdentifier("T_Xhtml");
t_xhtml.setLastChange(DATE);
getReqIF().getCoreContent().getDatatypes().add(t_xhtml);
}
private void createDatatypeRecommended() throws Exception {
t_recommended = factory.createDatatypeDefinitionEnumeration();
t_recommended.setLongName("T_Recommended");
t_recommended.setIdentifier("T_Recommended");
t_recommended.setLastChange(DATE);
addEnum(t_recommended, 1, "Recommended");
addEnum(t_recommended, 2, "---");
getReqIF().getCoreContent().getDatatypes().add(t_recommended);
}
private void createDatatypeDescription() throws Exception {
t_description = factory.createDatatypeDefinitionString();
t_description.setLongName("T_Description");
t_description.setIdentifier("T_Description");
t_description.setLastChange(DATE);
t_description.setMaxLength(new BigInteger("1000"));
getReqIF().getCoreContent().getDatatypes().add(t_description);
}
@Override
public void createSpecObjectTypes() throws Exception {
specObjecttype = factory.createSpecObjectType();
specObjecttype.setIdentifier("RequirementType");
specObjecttype.setLastChange(DATE);
specObjecttype.setLongName("RequirementType");
createKindDefinition();
createXhtmlDefinition();
createRecommendedDefinition();
createDescriptionDefinition();
getReqIF().getCoreContent().getSpecTypes().add(specObjecttype);
}
private void createKindDefinition() {
ad_kind = factory.createAttributeDefinitionString();
ad_kind.setLongName("Kind");
ad_kind.setIdentifier("Kind");
ad_kind.setLastChange(DATE);
ad_kind.setType(t_kind);
specObjecttype.getSpecAttributes().add(ad_kind);
}
private void createXhtmlDefinition() {
ad_xhtml = factory.createAttributeDefinitionXHTML();
ad_xhtml.setLongName("ReqIF.Text");
ad_xhtml.setIdentifier("ReqIF.Text");
ad_xhtml.setLastChange(DATE);
ad_xhtml.setType(t_xhtml);
specObjecttype.getSpecAttributes().add(ad_xhtml);
}
private void createRecommendedDefinition() {
ad_recommended = factory.createAttributeDefinitionEnumeration();
ad_recommended.setLongName("Recommended");
ad_recommended.setIdentifier("Recommended");
ad_recommended.setLastChange(DATE);
ad_recommended.setType(t_recommended);
ad_recommended.setMultiValued(false);
specObjecttype.getSpecAttributes().add(ad_recommended);
}
private void createDescriptionDefinition() {
ad_description = factory.createAttributeDefinitionString();
ad_description.setLongName("Description");
ad_description.setIdentifier("Description");
ad_description.setLastChange(DATE);
ad_description.setType(t_description);
specObjecttype.getSpecAttributes().add(ad_description);
}
@Override
public void createSpecObjects() throws Exception {
createSpecObject("so-01", "Bold Text", getXhtmlContent("<div><b>Bold</b></div>"), true,
"(standard element for bold in XHTML). Represented by using the <b> element.");
createSpecObject("so-02", "Bold Text", getXhtmlContent("<div><strong>Bold</strong></div>"), false,
"Represented by using the <strong> element.");
createSpecObject("so-03", "Italic Text", getXhtmlContent("<div><i>Italic</i></div>"), true, "Represented by using the <i> element.");
createSpecObject("so-04", "Italic Text", getXhtmlContent("<div><em>Italic</em></div>"), false, "Represented by using the <em> element.");
createSpecObject("so-05", "Italic Text", getXhtmlContent("<div><cite>Italic</cite></div>"), false, "Represented by using the <cite> element.");
createSpecObject("so-06", "Underlined Text", getXhtmlContent("<div><span style='text-decoration:underline;'>Underlined</span></div>"), true,
"Represented by using the style attribute set to text-decoration:underline.");
createSpecObject("so-07", "Underlined Text", getXhtmlContent("<div><ins>Underlined</ins></div>"), false,
"Represented by using the <ins> element.");
createSpecObject("so-08", "Strike Through Text",
getXhtmlContent("<div><span style='text-decoration:line-through;'>Strike Through</span></div>"), true,
"(recommended by ReqIF standard). Represented by using the style attribute set to text-decoration:line-through.");
createSpecObject("so-09", "Strike Through Text", getXhtmlContent("<div><del>Strike Through</del></div>"), false,
"Represented by using the <del> element.");
createSpecObject("so-10", "Superscript Text", getXhtmlContent("<div>Normal<sup>Superscript</sup></div>"), true,
"(standard XHTML). Represented by using the <sup> element.");
createSpecObject("so-11", "Subscript Text", getXhtmlContent("<div>Normal<sub>Subscript</sub></div>"), true,
"(standard XHTML). Represented by using the <sub> element.");
createSpecObject(
"so-12",
"Indentation",
getXhtmlContent("<div>The second line<blockquote><div>is indented,<blockquote><div>the third line is indented even further.</div></blockquote></div></blockquote></div>"),
true,
"Represented by using <blockquote> elements. Simple, straight-forward solution that is compatible with ReqIF1.1. It explicitly uses XHTML elements and therefore can be easily processed by XML parsers.");
createSpecObject(
"so-13",
"Indentation",
getXhtmlContent("<div><div>The second line</div><div style='margin-left:10px;'>is indented 10 pixels,</div><div style='margin-left:20px;'>the third line is indented 20 pixels.</div></div>"),
false, "Represented by using the style attribute set to margin-left:<indentation>.");
createSpecObject("so-14", "Unordered List",
getXhtmlContent("<div><ul><li>First Bullet Point</li><li>Second Bullet Point</li><li>Third Bullet Point</li></ul></div>"), true,
"(standard XHTML). Represented by using the <ul> and <li> elements.");
createSpecObject("so-15", "Ordered List", getXhtmlContent("<div><ol><li>Number One</li><li>Number Two</li><li>Number Three</li></ol></div>"),
true, "(standard XHTML). Represented by using the <ol> and <li> elements.");
createSpecObject("so-16", "Colored Text", getXhtmlContent("<div><span style='color:red;'>Red</span></div>"), true,
"(recommended by ReqIF standard). Represented by using the style attribute set to color:<color>");
}
private void createSpecObject(String id, String kind, XhtmlContent xhtml, boolean recommended, String description) throws Exception {
SpecObject obj = factory.createSpecObject();
obj.setIdentifier(id);
obj.setLongName("SpecObject: " + id);
obj.setLastChange(DATE);
obj.setType(specObjecttype);
getReqIF().getCoreContent().getSpecObjects().add(obj);
AttributeValueString kindAV = factory.createAttributeValueString();
kindAV.setDefinition(ad_kind);
kindAV.setTheValue(kind);
obj.getValues().add(kindAV);
AttributeValueXHTML xhtmlAV = factory.createAttributeValueXHTML();
xhtmlAV.setDefinition(ad_xhtml);
xhtmlAV.setTheValue(xhtml);
obj.getValues().add(xhtmlAV);
AttributeValueEnumeration recommendedAV = factory.createAttributeValueEnumeration();
recommendedAV.setDefinition(ad_recommended);
if (recommended) {
recommendedAV.getValues().add(t_recommended.getSpecifiedValues().get(0));
} else {
recommendedAV.getValues().add(t_recommended.getSpecifiedValues().get(1));
}
obj.getValues().add(recommendedAV);
AttributeValueString descriptionAV = factory.createAttributeValueString();
descriptionAV.setDefinition(ad_description);
descriptionAV.setTheValue(description);
obj.getValues().add(descriptionAV);
}
@Override
public void createSpecificationTypes() throws Exception {
specType = factory.createSpecificationType();
specType.setIdentifier("specType");
specType.setLongName("specType");
specType.setLastChange(DATE);
getReqIF().getCoreContent().getSpecTypes().add(specType);
}
@Override
public void createSpecifications() throws Exception {
Specification spec = factory.createSpecification();
spec.setIdentifier("specification");
spec.setLongName("specification");
spec.setLastChange(DATE);
spec.setType(specType);
getReqIF().getCoreContent().getSpecifications().add(spec);
for (SpecObject object : getReqIF().getCoreContent().getSpecObjects()) {
SpecHierarchy sh = factory.createSpecHierarchy();
sh.setObject(object);
sh.setIdentifier("sh-" + object.getIdentifier());
sh.setLongName("sh-" + object.getIdentifier());
sh.setLastChange(DATE);
spec.getChildren().add(sh);
}
}
private void addEnum(DatatypeDefinitionEnumeration enumeration, long key, String value) {
EnumValue enumValue = factory.createEnumValue();
enumValue.setIdentifier("id-" + key);
enumValue.setLongName(value);
enumValue.setLastChange(DATE);
EmbeddedValue embeddedValue = factory.createEmbeddedValue();
embeddedValue.setKey(BigInteger.valueOf(key));
embeddedValue.setOtherContent("otherContent-" + key);
enumValue.setProperties(embeddedValue);
enumeration.getSpecifiedValues().add(enumValue);
}
public static XhtmlContent getXhtmlContent(String html) throws IOException {
ReqIF10XHtmlContentAdapterFactory factory = new ReqIF10XHtmlContentAdapterFactory();
XhtmlContent xhtmlContent = ReqIF10Factory.eINSTANCE.createXhtmlContent();
ReqIF10XHtmlContentAdapter adapter = (ReqIF10XHtmlContentAdapter) factory.adapt(xhtmlContent, ReqIF10XHtmlContentAdapter.class);
adapter.setXhtmlString(html);
return xhtmlContent;
}
}