private void CompileConcept(DocTemplateUsage concept, DocModelView view, TypeBuilder tb)
{
bool includeconcept = true;
if (this.m_exchange != null)
{
includeconcept = false;
foreach (DocExchangeItem ei in concept.Exchanges)
{
if (ei.Exchange == this.m_exchange && ei.Applicability == DocExchangeApplicabilityEnum.Export &&
(ei.Requirement == DocExchangeRequirementEnum.Mandatory || ei.Requirement == DocExchangeRequirementEnum.Optional))
{
includeconcept = true;
}
}
}
// bool ConceptTemplateA([Parameter1, ...]);
// {
// // for loading reference value:
// .ldfld [AttributeRule]
// .ldelem [Index] // for collection, get element by index
// .castclass [EntityRule] for entity, cast to expected type;
// // for object graphs, repeat the above instructions to load value
//
// for loading constant:
// .ldstr 'value'
//
// for comparison functions:
// .cge
//
// for logical aggregations, repeat each item, pushing 2 elements on stack, then run comparison
// .or
//
// return the boolean value on the stack
// .ret;
// }
// bool[] ConceptA()
// {
// bool[] result = new bool[2];
//
// if parameters are specified, call for each template rule; otherwise call just once
// result[0] = ConceptTemplateA([Parameter1, ...]); // TemplateRule#1
// result[1] = ConceptTemplateA([Parameter1, ...]); // TemplateRule#2
//
// return result;
// }
// compile a method for the template definition, where parameters are passed to the template
#if true
if (includeconcept && concept.Definition != null)
{
MethodInfo methodTemplate = this.RegisterTemplate(concept.Definition);
// verify that definition is compatible with entity (user error)
if (methodTemplate != null && methodTemplate.DeclaringType.IsAssignableFrom(tb))
{
string methodname = DocumentationISO.MakeLinkName(view) + "_" + DocumentationISO.MakeLinkName(concept.Definition);
MethodBuilder method = tb.DefineMethod(methodname, MethodAttributes.Public, CallingConventions.HasThis, typeof(bool[]), null);
ILGenerator generator = method.GetILGenerator();
DocModelRule[] parameters = concept.Definition.GetParameterRules();
if (parameters != null && parameters.Length > 0)
{
// allocate array of booleans, store as local variable
generator.DeclareLocal(typeof(bool[]));
generator.Emit(OpCodes.Ldc_I4, concept.Items.Count);
generator.Emit(OpCodes.Newarr, typeof(bool));
generator.Emit(OpCodes.Stloc_0);
// call for each item with specific parameters
for (int row = 0; row < concept.Items.Count; row++)
{
DocTemplateItem docItem = concept.Items[row];
generator.Emit(OpCodes.Ldloc_0); // push the array object onto the stack, for storage later
generator.Emit(OpCodes.Ldc_I4, row); // push the array index onto the stack for storage later
generator.Emit(OpCodes.Ldarg_0); // push the *this* pointer for the IFC object instance
// push parameters onto stack
for (int col = 0; col < parameters.Length; col++)
{
DocModelRule docParam = parameters[col];
string paramvalue = docItem.GetParameterValue(docParam.Identification);
if (paramvalue != null)
{
DocDefinition docParamType = concept.Definition.GetParameterType(docParam.Identification, this.m_definitions);
if (docParamType is DocDefined)
{
DocDefined docDefined = (DocDefined)docParamType;
switch (docDefined.DefinedType)
{
case "INTEGER":
{
Int64 ival = 0;
Int64.TryParse(paramvalue, out ival);
generator.Emit(OpCodes.Ldc_I8, ival);
generator.Emit(OpCodes.Box);
}
break;
case "REAL":
{
Double dval = 0.0;
Double.TryParse(paramvalue, out dval);
generator.Emit(OpCodes.Ldc_R8, dval);
generator.Emit(OpCodes.Box);
}
break;
case "STRING":
generator.Emit(OpCodes.Ldstr, paramvalue);
break;
default:
generator.Emit(OpCodes.Ldstr, paramvalue);
break;
}
}
else
{
// assume string
generator.Emit(OpCodes.Ldstr, paramvalue);
}
}
else
{
generator.Emit(OpCodes.Ldnull);
}
}
generator.Emit(OpCodes.Call, methodTemplate); // call the validation function for the concept template
generator.Emit(OpCodes.Stelem_I1); // store the result (bool) into an array slot
}
// return the array of boolean results
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
}
else
{
// allocate array of booleans, store as local variable
generator.DeclareLocal(typeof(bool[]));
generator.Emit(OpCodes.Ldc_I4, 1);
generator.Emit(OpCodes.Newarr, typeof(bool));
generator.Emit(OpCodes.Stloc_0);
generator.Emit(OpCodes.Ldloc_0); // push the array object onto the stack, for storage later
generator.Emit(OpCodes.Ldc_I4, 0); // push the array index onto the stack for storage later
// call once
generator.Emit(OpCodes.Ldarg_0); // push the *this* pointer for the IFC object instance
generator.Emit(OpCodes.Call, methodTemplate); // call the validation function for the concept template
generator.Emit(OpCodes.Stelem_I1); // store the result (bool) into an array slot
// return the array of boolean results
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Incompatible template: " + tb.Name + " - " + concept.Definition.Name);
}
}
#endif
// recurse
foreach (DocTemplateUsage docChild in concept.Concepts)
{
CompileConcept(docChild, view, tb);
}
}
private void toolStripButtonTemplateInsert_Click(object sender, EventArgs e)
{
if (this.dataGridViewConceptRules.SelectedRows.Count == 0)
{
return;
}
this.m_editcon = true;
DocPropertySet existingPropertySet = null;
bool isPsetDefined = false;
bool isPropertyDefined = false;
if (this.m_conceptleaf != null)
{
if (this.m_conceptleaf.Definition.Uuid == DocTemplateDefinition.guidTemplatePropertyList || this.m_conceptleaf.Definition.Uuid == DocTemplateDefinition.guidTemplatePropertyBounded ||
this.m_conceptleaf.Definition.Uuid == DocTemplateDefinition.guidTemplatePropertyEnumerated || this.m_conceptleaf.Definition.Uuid == DocTemplateDefinition.guidTemplatePropertyReference ||
this.m_conceptleaf.Definition.Uuid == DocTemplateDefinition.guidTemplatePropertySingle || this.m_conceptleaf.Definition.Uuid == DocTemplateDefinition.guidTemplatePropertyTable)
{
foreach (DocSection docSection in this.Project.Sections)
{
foreach (DocSchema docSchema in docSection.Schemas)
{
foreach (DocPropertySet docPset in docSchema.PropertySets)
{
if (docPset.Name == this.ConceptItem.Name)
{
isPsetDefined = true;
existingPropertySet = docPset;
}
// search properties
foreach (DocProperty docProp in docPset.Properties)
{
for (int i = 0; i < this.dataGridViewConceptRules.SelectedRows.Count; i++)
{
if (dataGridViewConceptRules.SelectedRows[i].Tag is DocTemplateItem)
{
DocTemplateItem propertyItem = (DocTemplateItem)dataGridViewConceptRules.SelectedRows[i].Tag;
if (docProp.Name == propertyItem.GetParameterValue("PropertyName"))
{
isPropertyDefined = true;
}
}
}
}
}
}
}
}
else
{
//this.m_conceptroot.ApplicableItems.RemoveAt(index);
}
if (!isPsetDefined)
{
FormSelectSchema schemaSelect = new FormSelectSchema(this.Project);
schemaSelect.ShowDialog();
DocPropertySet pset = new DocPropertySet();
DocTemplateItem psetItem = (DocTemplateItem)this.ConceptItem;
pset.Name = psetItem.GetParameterValue("PsetName");
if (!isPropertyDefined)
{
for (int i = 0; i < this.dataGridViewConceptRules.SelectedRows.Count; i++)
{
DocProperty property = new DocProperty();
if (dataGridViewConceptRules.SelectedRows[i].Tag is DocTemplateItem)
{
DocTemplateItem propertyItem = (DocTemplateItem)dataGridViewConceptRules.SelectedRows[i].Tag;
property.Name = propertyItem.GetParameterValue("PropertyName");
//if (propertyItem.GetParameterValue("Value") != null)
//{
property.PrimaryDataType = propertyItem.GetParameterValue("Value");
//}
pset.Properties.Add(property);
}
}
}
schemaSelect.Selection.PropertySets.Add(pset);
}
else
{
if (!isPropertyDefined)
{
for (int i = 0; i < this.dataGridViewConceptRules.SelectedRows.Count; i++)
{
DocProperty property = new DocProperty();
if (dataGridViewConceptRules.SelectedRows[i].Tag is DocTemplateItem)
{
DocTemplateItem propertyItem = (DocTemplateItem)dataGridViewConceptRules.SelectedRows[i].Tag;
property.Name = propertyItem.GetParameterValue("PropertyName");
//if (propertyItem.GetParameterValue("Value") != null)
//{
property.PrimaryDataType = propertyItem.GetParameterValue("Value");
//}
existingPropertySet.Properties.Add(property);
}
}
}
}
if (this.ParentForm.Owner is FormEdit)
{
FormEdit ownerForm = (FormEdit)this.ParentForm.Owner;
//ownerForm.i
}
this.m_editcon = false;
}
}