///-------------------------------------------------------------------------------- /// <summary>This method assigns a value to a property, and updates corresponding /// forward and reverse engineering data.</summary> /// /// <param name="propertyName">The property name.</param> /// <param name="propertyValue">The property value.</param> ///-------------------------------------------------------------------------------- public override bool AssignProperty(string propertyName, object propertyValue) { if (this.SetPropertyValue(propertyName, propertyValue) == true) { if (ReverseInstance == null) { ReverseInstance = new CodeTemplate(); ReverseInstance.TransformDataFromObject(this, null, false); } else { ReverseInstance.SetPropertyValue(propertyName, propertyValue); } if (ForwardInstance != null) { this.TransformDataFromObject(ForwardInstance, null, false, true); } } else { return(false); } #region protected #endregion protected return(true); }
///-------------------------------------------------------------------------------- /// <summary>This property returns a copy of the forward engineering data for the solution.</summary> ///-------------------------------------------------------------------------------- public new CodeTemplate GetForwardInstance(Solution forwardSolution) { bool isCustomized = false; CodeTemplate forwardItem = new CodeTemplate(); if (ForwardInstance != null) { forwardItem.TransformDataFromObject(ForwardInstance, null, false); isCustomized = true; } else if (IsAutoUpdated == false) { forwardItem.TransformDataFromObject(this, null, false); isCustomized = true; } else { forwardItem.TemplateID = TemplateID; } if (isCustomized == false) { return(null); } forwardItem.SpecSourceName = DefaultSourceName; if (forwardSolution.ReferencedModelIDs.Find("ItemName", forwardItem.SpecSourceName) == null) { forwardSolution.ReferencedModelIDs.Add(CreateIDReference()); } #region protected #endregion protected return(forwardItem); }
///-------------------------------------------------------------------------------- /// <summary>This method copies changed metadata between the input /// instance and the current instance.</summary> /// /// <param name="inputCodeTemplate">The codetemplate to get metadata.</param> ///-------------------------------------------------------------------------------- public void CopyChangedMetadata(CodeTemplate inputCodeTemplate) { SpecificationDirectory = inputCodeTemplate.SpecificationDirectory; #region protected #endregion protected }
///-------------------------------------------------------------------------------- /// <summary>This method determines whether or not any metadata is /// different between the input instance and the current instance.</summary> /// /// <param name="inputCodeTemplate">The codetemplate to compare metadata.</param> ///-------------------------------------------------------------------------------- public bool IsIdenticalMetadata(CodeTemplate inputCodeTemplate) { if (SpecificationDirectory.GetString() != inputCodeTemplate.SpecificationDirectory.GetString()) { return(false); } #region protected #endregion protected return(true); }
///-------------------------------------------------------------------------------- /// <summary>This method adds a tag to TagList.</summary> ///-------------------------------------------------------------------------------- public override void AddTag(string tagName) { if (ReverseInstance == null && IsAutoUpdated == true) { ReverseInstance = new CodeTemplate(); ReverseInstance.TransformDataFromObject(this, null, false); IsAutoUpdated = false; } base.AddTag(tagName); if (ForwardInstance == null) { ForwardInstance = new CodeTemplate(); ForwardInstance.TemplateID = TemplateID; } if (ForwardInstance.TagList.Find(t => t.TagName == tagName) == null) { ForwardInstance.TagList.Add(new Tag(Guid.NewGuid(), tagName)); } }
///-------------------------------------------------------------------------------- /// <summary>This method determines whether the input instance metadata is /// effectively empty.</summary> /// /// <param name="inputCodeTemplate">The codetemplate to compare metadata.</param> ///-------------------------------------------------------------------------------- public bool IsEmptyMetadata(CodeTemplate inputCodeTemplate) { if (inputCodeTemplate == null) { return(true); } if (inputCodeTemplate.TagList.Count > 0) { return(false); } if (!String.IsNullOrEmpty(inputCodeTemplate.SpecificationDirectory)) { return(false); } #region protected #endregion protected return(true); }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="parentTemplateContext">The associated parent template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="parameterModelContext">The associated model context for parameters.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, ITemplate parentTemplateContext, IDomainEnterpriseObject modelContext, IDomainEnterpriseObject parameterModelContext, bool appendToTemplateContext) { try { ITemplate template = null; if (TemplateName == LanguageTerms.TemplateProperty && modelContext is Project) { if (templateContext is SpecTemplate) { template = new SpecTemplate(); } else { template = new CodeTemplate(); } template.FilePath = (modelContext as Project).TemplateAbsolutePath; template.LoadTemplateFileData(false); string templateName = template.TemplateName; string code = String.Empty; if (templateContext is SpecTemplate) { template = solutionContext.SpecTemplates[templateContext.GetTemplateKey(modelContext, templateName)] as SpecTemplate; } else { template = solutionContext.CodeTemplates[templateContext.GetTemplateKey(modelContext, templateName)] as CodeTemplate; } } else { if (templateContext is SpecTemplate) { template = solutionContext.SpecTemplates[templateContext.GetTemplateKey(modelContext, TemplateName)] as SpecTemplate; } else { template = solutionContext.CodeTemplates[templateContext.GetTemplateKey(modelContext, TemplateName)] as CodeTemplate; } } // add parameters foreach (TemplateParameterNode parameter in Parameters) { ParameterValues[parameter.VariableName] = parameter.Parameter.GetObjectValue(solutionContext, parentTemplateContext, parameterModelContext, interpreterType); } if (interpreterType == InterpreterTypeCode.Output) { if (template != null) { template.GenerateOutput(solutionContext, templateContext, modelContext, appendToTemplateContext, ParameterValues); } } else { if (template != null) { template.GenerateContent(solutionContext, templateContext, modelContext, appendToTemplateContext, ParameterValues); } else { templateContext.ContentCodeBuilder.Append("<" + TemplateName + ">"); LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Message_TemplateNotFoundError, TemplateName, interpreterType)); } } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to get the associated template and interpret the content and output.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="parameterModelContext">The associated model context for parameters.</param> ///-------------------------------------------------------------------------------- public void InterpretContentAndOutput(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, IDomainEnterpriseObject parameterModelContext) { InterpreterTypeCode interpreterType = InterpreterTypeCode.Content; try { ITemplate template = null; if (TemplateName == LanguageTerms.TemplateProperty && modelContext is Project) { if (templateContext is SpecTemplate) { template = new SpecTemplate(); } else { template = new CodeTemplate(); } template.FilePath = (modelContext as Project).TemplateAbsolutePath; template.LoadTemplateFileData(false); string templateName = template.TemplateName; string code = String.Empty; if (templateContext is SpecTemplate) { template = solutionContext.SpecTemplates[templateContext.GetTemplateKey(modelContext, templateName)] as SpecTemplate; } else { template = solutionContext.CodeTemplates[templateContext.GetTemplateKey(modelContext, templateName)] as CodeTemplate; } } else { if (templateContext is SpecTemplate) { template = solutionContext.SpecTemplates[templateContext.GetTemplateKey(modelContext, TemplateName)] as SpecTemplate; } else { template = solutionContext.CodeTemplates[templateContext.GetTemplateKey(modelContext, TemplateName)] as CodeTemplate; } } if (template != null) { template.MessageBuilder.Clear(); template.PopCount = 0; template.PushModelContext(modelContext); template.ContentCodeBuilder.Clear(); template.CurrentTabIndent = templateContext.CurrentTabIndent; InterpretNode(interpreterType, solutionContext, template, templateContext, modelContext, parameterModelContext, false); template.PopCount = 0; template.PushModelContext(modelContext); template.OutputCodeBuilder.Clear(); template.CurrentTabIndent = templateContext.CurrentTabIndent; interpreterType = InterpreterTypeCode.Output; InterpretNode(interpreterType, solutionContext, template, templateContext, modelContext, parameterModelContext, false); templateContext.AddToTemplateCalls(template); template.AddToTemplateCalledBy(templateContext); if (ParameterValues.Count > 0) { int parameterCount = 0; string parameters = String.Empty; foreach (string parameter in ParameterValues.AllKeys) { if (parameterCount > 0) { parameters += ", "; } parameters += parameter; parameterCount++; } if (parameterCount > 1) { LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Message_TemplateParametersNotFoundError, parameters, TemplateName), interpreterType); } else { LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Message_TemplateParameterNotFoundError, parameters, TemplateName), interpreterType); } } if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append(template.MessageBuilder.ToString()); } } else { LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Message_TemplateNotFoundError, TemplateName), interpreterType); } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>This method gets the content for a watch expression.</summary> /// /// <param name="watchExpression">Expression to evaluate.</param> /// <param name="parentModelContext">The parent model context from which to generate code.</param> /// /// <returns>A string representing the generated code for the watch expression.</returns> ///-------------------------------------------------------------------------------- public string GetWatchContent(string watchExpression, IDomainEnterpriseObject parentModelContext) { try { CodeTemplate template = Solution.CodeTemplates[TemplateKey] as CodeTemplate; if (template == null) { return(String.Empty); } // handle special cases if (String.IsNullOrEmpty(watchExpression)) { return(String.Empty); } if (watchExpression == LanguageTerms.TextProperty) { return(template.ContentCodeBuilder.ToString()); } if (watchExpression == LanguageTerms.PathProperty) { return(template.OutputCodeBuilder.ToString()); } // create temporary template CodeTemplate watchTemplate = new CodeTemplate(); watchTemplate.Solution = Solution; watchTemplate.NodeName = parentModelContext.GetType().Name; watchTemplate.IsWatchTemplate = true; // wrap input expression into a template with a single property watchTemplate.TemplateContent = LanguageTerms.PropOpenTag + watchExpression + LanguageTerms.CloseTag; // push parameters and variables onto watch template if (template != null) { foreach (string key in template.Parameters.AllKeys) { watchTemplate.Parameters[key] = template.Parameters[key]; } foreach (string key in template.Variables.AllKeys) { watchTemplate.Variables[key] = template.Variables[key]; } } // push template context stack onto watch template as needed if (template != null && template.ModelContextStack.Count > 1) { for (int i = template.ModelContextStack.Count - 1; i > 0; i--) { watchTemplate.PushModelContext(template.ModelContextStack[i]); } } // get expression value string watchValue = watchTemplate.GetContent(parentModelContext, watchExpression); if (watchTemplate.HasErrors == true) { watchValue = DisplayValues.Exception_WatchExpression; } return(watchValue); } catch (ApplicationAbortException ex) { return(ex.Message); } catch (System.Exception ex) { return(ex.Message); } }