/// <summary>
/// Creates a new view digram for the pattern model.
/// </summary>
/// <param name="patternModel">The pattern model</param>
/// <param name="docData">The document window data</param>
/// <returns></returns>
public static Guid CreateNewViewDiagram(PatternModelSchema patternModel, ModelingDocData docData)
{
Guard.NotNull(() => patternModel, patternModel);
Guard.NotNull(() => docData, docData);
// Create a new diagram file
var docView = docData.DocViews.FirstOrDefault() as SingleDiagramDocView;
PatternModelSchemaDiagram diagram = null;
patternModel.Store.TransactionManager.DoWithinTransaction(() =>
{
diagram = PatternModelSerializationHelper.CreatePatternModelSchemaDiagram(
new SerializationResult(),
patternModel.Store.DefaultPartition,
patternModel.Store.GetRootElement(),
string.Empty);
});
if (diagram != null)
{
SetCurrentDiagram(docView, diagram, patternModel.Pattern);
FixUpDiagram(patternModel, patternModel.Pattern, diagram.Id.ToString(),
PresentationViewsSubject.GetPresentation(patternModel.Pattern).OfType<ShapeElement>());
return diagram.Id;
}
return Guid.Empty;
}
private MemoryStream InternalSaveModel2(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(modelRoot != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
serializationResult.Encoding = encoding;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = PatternModelSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
this.WriteRootElement(serializationContext, modelRoot, writer);
}
return newFileContent;
}
/// <summary>
/// Initializes a new instance of the <see cref="PatternModelCloner"/> class.
/// </summary>
/// <param name="sourcePatternModel">The source pattern line.</param>
/// <param name="sourceVersion">The source version.</param>
/// <param name="targetPatternModel">The target pattern line.</param>
public PatternModelCloner(PatternModelSchema sourcePatternModel, Version sourceVersion, PatternModelSchema targetPatternModel)
{
Guard.NotNull(() => sourcePatternModel, sourcePatternModel);
Guard.NotNull(() => sourceVersion, sourceVersion);
Guard.NotNull(() => targetPatternModel, targetPatternModel);
this.SourcePatternModel = sourcePatternModel;
this.SourceVersion = sourceVersion;
this.TargetPatternModel = targetPatternModel;
}
/// <summary>
/// Saves the model.
/// </summary>
/// <param name="modelRoot">The model root.</param>
/// <param name="stream">The stream.</param>
internal void SaveModel(PatternModelSchema modelRoot, Stream stream)
{
Guard.NotNull(() => modelRoot, modelRoot);
Guard.NotNull(() => stream, stream);
var context = new DslModeling.SerializationContext(GetDirectory(modelRoot.Store));
this.InitializeSerializationContext(modelRoot.Partition, context, false);
var settings = CreateXmlWriterSettings(context, false, Encoding.UTF8);
using (var writer = XmlWriter.Create(stream, settings))
{
this.WriteRootElement(context, modelRoot, writer);
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, PatternModelSchema element, global::System.Xml.XmlWriter writer)
{
// PatternModelHasPattern
PatternModelHasPattern thePatternModelHasPatternInstance = PatternModelHasPattern.GetLinkToPattern(element);
if (!serializationContext.Result.Failed && thePatternModelHasPatternInstance != null)
{
global::System.Type typeofPatternModelHasPattern = typeof(PatternModelHasPattern);
if (thePatternModelHasPatternInstance.GetType() != typeofPatternModelHasPattern)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(thePatternModelHasPatternInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + thePatternModelHasPatternInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, thePatternModelHasPatternInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = thePatternModelHasPatternInstance.PatternSchema;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.Write(serializationContext, targetElement, writer);
}
}
}
internal virtual void SaveModelAndDiagram(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string modelFileName, PatternModelSchemaDiagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (string.IsNullOrEmpty(modelFileName))
throw new global::System.ArgumentNullException("modelFileName");
if (diagram == null)
throw new global::System.ArgumentNullException("diagram");
if (string.IsNullOrEmpty(diagramFileName))
throw new global::System.ArgumentNullException("diagramFileName");
#endregion
if (serializationResult.Failed)
return;
// Save the model file first
using (global::System.IO.MemoryStream modelFileContent = this.InternalSaveModel(serializationResult, modelRoot, modelFileName, encoding, writeOptionalPropertiesWithDefaultValue))
{
if (serializationResult.Failed)
return;
using (global::System.IO.MemoryStream diagramFileContent = this.InternalSaveDiagram(serializationResult, diagram, diagramFileName, encoding, writeOptionalPropertiesWithDefaultValue))
{
if (!serializationResult.Failed)
{
// Only write the contents if there's no error encountered during serialization.
if (modelFileContent != null)
{
using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(modelFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None))
{
using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding))
{
writer.Write(modelFileContent.ToArray());
}
}
}
if (diagramFileContent != null)
{
using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(diagramFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None))
{
using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding))
{
writer.Write(diagramFileContent.ToArray());
}
}
}
}
}
}
}
/// <summary>
/// Saves the given diagram to the given file, with default encoding (UTF-8).
/// </summary>
/// <param name="serializationResult">Stores serialization result from the save operation.</param>
/// <param name="modelRoot">PatternModelSchema instance to be saved.</param>
/// <param name="modelFileName">Name of the file in which the CanonicalSampleRoot instance will be saved.</param>
/// <param name="diagram">PatternModelSchemaDiagram to be saved.</param>
/// <param name="diagramFileName">Name of the file in which the diagram will be saved.</param>
/// <param name="writeOptionalPropertiesWithDefaultValue">Whether optional properties with default value will be saved.</param>
internal virtual void SaveModelAndDiagram(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string modelFileName, PatternModelSchemaDiagram diagram, string diagramFileName, bool writeOptionalPropertiesWithDefaultValue)
{
this.SaveModelAndDiagram(serializationResult, modelRoot, modelFileName, diagram, diagramFileName, global::System.Text.Encoding.UTF8, writeOptionalPropertiesWithDefaultValue);
}
/// <summary>
/// Saves the given diagram to the given file, with default encoding (UTF-8), and optional properties with default value will not
/// be written out.
/// </summary>
/// <param name="serializationResult">Stores serialization result from the save operation.</param>
/// <param name="modelRoot">PatternModelSchema instance to be saved.</param>
/// <param name="modelFileName">Name of the file in which the CanonicalSampleRoot instance will be saved.</param>
/// <param name="diagram">PatternModelSchemaDiagram to be saved.</param>
/// <param name="diagramFileName">Name of the file in which the diagram will be saved.</param>
internal virtual void SaveModelAndDiagram(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string modelFileName, PatternModelSchemaDiagram diagram, string diagramFileName)
{
this.SaveModelAndDiagram(serializationResult, modelRoot, modelFileName, diagram, diagramFileName, global::System.Text.Encoding.UTF8, false);
}
/// <summary>
/// Helper method to create and initialize a new PatternModelSchema.
/// </summary>
internal protected virtual PatternModelSchema CreateModelHelper(DslModeling::Partition modelPartition)
{
PatternModelSchema model = new PatternModelSchema(modelPartition);
return model;
}
public PatternModelSchema LoadModel(DslModeling.Store store, Stream stream, DslModeling.ISchemaResolver schemaResolver, DslModeling.ISerializerLocator serializerLocator)
{
Guard.NotNull(() => store, store);
Guard.NotNull(() => stream, stream);
if (!store.DefaultPartition.Store.TransactionActive)
{
throw new InvalidOperationException(PatternModelDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
var directory = this.GetDirectory(store.DefaultPartition.Store);
var modelRootSerializer = directory.GetSerializer(PatternModelSchema.DomainClassId);
var serializationResult = new DslModeling.SerializationResult();
Debug.Assert(modelRootSerializer != null, @"Cannot find serializer for PatternModel!");
if (modelRootSerializer != null)
{
PatternModelSchema modelRoot = null;
var serializationContext = new DslModeling.SerializationContext(directory, string.Empty, serializationResult);
this.InitializeSerializationContext(store.DefaultPartition, serializationContext, true);
var transactionContext = new DslModeling.TransactionContext();
transactionContext.Add(DslModeling.SerializationContext.TransactionContextKey, serializationContext);
using (var tx = store.DefaultPartition.Store.TransactionManager.BeginTransaction(Resources.PatternModelSerializationHelper_TransactionDescriptionLoadingModel, true, transactionContext))
{
try
{
var settings = PatternModelSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
using (var reader = XmlReader.Create(stream, settings))
{
reader.Read();
Encoding encoding;
if (this.TryGetEncoding(reader, out encoding))
{
serializationResult.Encoding = encoding;
}
DslModeling.SerializationUtilities.ResolveDomainModels(reader, serializerLocator, store.DefaultPartition.Store);
reader.MoveToContent();
modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, store.DefaultPartition) as PatternModelSchema;
if (modelRoot != null && !serializationResult.Failed)
{
this.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver);
}
}
}
catch (XmlException ex)
{
DslModeling.SerializationUtilities.AddMessage(serializationContext, DslModeling.SerializationMessageKind.Error, ex);
}
if (modelRoot == null && !serializationResult.Failed)
{
modelRoot = this.CreateModelHelper(store.DefaultPartition);
}
if (tx.IsActive)
{
tx.Commit();
}
}
// Set tracking properties
ResetTrackingProperties(store);
return(modelRoot);
}
return(null);
}
internal static PatternModelSchemaDiagram CreatePatternModelSchemaDiagram(DslModeling.SerializationResult serializationResult, DslModeling.Partition diagramPartition, PatternModelSchema modelRoot, string diagramId)
{
var diagram = new PatternModelSchemaDiagram(
diagramPartition.Store,
new DslModeling.PropertyAssignment(DslDiagrams.Diagram.NameDomainPropertyId, diagramId),
new DslModeling.PropertyAssignment(
DslModeling.ElementFactory.IdPropertyAssignment,
!string.IsNullOrEmpty(diagramId) ? new Guid(diagramId) : Guid.NewGuid()));
diagram.ModelElement = modelRoot;
diagram.PostDeserialization(true);
DoCheckForOrphanedShapes(diagram, serializationResult);
return diagram;
}
/// <summary>
/// Saves the model.
/// </summary>
/// <param name="modelRoot">The model root.</param>
/// <param name="stream">The stream.</param>
internal void SaveModel(PatternModelSchema modelRoot, Stream stream)
{
Guard.NotNull(() => modelRoot, modelRoot);
Guard.NotNull(() => stream, stream);
var context = new DslModeling.SerializationContext(GetDirectory(modelRoot.Store));
this.InitializeSerializationContext(modelRoot.Partition, context, false);
var settings = CreateXmlWriterSettings(context, false, Encoding.UTF8);
using (var writer = XmlWriter.Create(stream, settings))
{
this.WriteRootElement(context, modelRoot, writer);
}
}
protected override void Load(string fileName, bool reload)
{
Guard.NotNullOrEmpty(() => fileName, fileName);
var serializationResult = new SerializationResult();
PatternModelSchema modelRoot = null;
var schemaResolver = new ModelingSchemaResolver(this.ServiceProvider);
PatternModelDomainModel.EnableDiagramRules(this.Store);
this.Store.RuleManager.DisableRule(typeof(FixUpDiagram));
this.Store.RuleManager.EnableRule(typeof(FixUpMultipleDiagram));
var diagramFileNames =
Directory.GetFiles(
Path.GetDirectoryName(fileName), string.Concat("*", DesignerConstants.ModelExtension, DesignerConstants.DiagramFileExtension));
// Run migration rules
this.ExecuteUpgradeRules(fileName, diagramFileNames);
// Load models
modelRoot = PatternModelSerializationHelper.Instance.LoadModelAndDiagrams(
serializationResult,
this.GetModelPartition(),
fileName,
this.GetDiagramPartition(),
diagramFileNames,
schemaResolver,
null /* no load-time validation */,
this.SerializerLocator);
this.SuspendErrorListRefresh();
try
{
foreach (SerializationMessage serializationMessage in serializationResult)
{
this.AddErrorListItem(new SerializationErrorListItem(this.ServiceProvider, serializationMessage));
}
}
finally
{
this.ResumeErrorListRefresh();
}
if (serializationResult.Failed)
{
throw new InvalidOperationException(PatternModelDomainModel.SingletonResourceManager.GetString("CannotOpenDocument"));
}
else
{
this.SetRootElement(modelRoot);
// Attempt to set the encoding
if (serializationResult.Encoding != null)
{
this.ModelingDocStore.SetEncoding(serializationResult.Encoding);
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(this.SetDocDataDirty(0)); // Setting the encoding will mark the document as dirty, so clear the dirty flag.
}
}
this.RehydrateModel();
}
/// <summary>
/// This method deserializes all child model elements.
/// </summary>
/// <remarks>
/// The caller will position the reader at the open tag of the first child XML element to deserialized.
/// This method will read as many child elements as it can. It returns under three circumstances:
/// 1) When an unknown child XML element is encountered. In this case, this method will position the reader at the
/// open tag of the unknown element. This implies that if the first child XML element is unknown, this method
/// should return immediately and do nothing.
/// 2) When all child XML elemnets are read. In this case, the reader will be positioned at the end tag of the parent element.
/// 3) EOF.
/// </remarks>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="reader">XmlReader to read serialized data from.</param>
/// <param name="element">In-memory PatternModelSchema instance that will get the deserialized data.</param>
private static void ReadChildElements(DslModeling::SerializationContext serializationContext, PatternModelSchema element, global::System.Xml.XmlReader reader)
{
if (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element)
{
if (DslModeling::DomainRoleInfo.GetElementLinks<PatternModelHasPattern> (element, PatternModelHasPattern.PatternModelSchemaDomainRoleId).Count == 0)
{
DslModeling::DomainClassXmlSerializer newPatternSchemaOfPatternModelHasPatternSerializer = serializationContext.Directory.GetSerializer(PatternSchema.DomainClassId);
global::System.Diagnostics.Debug.Assert(newPatternSchemaOfPatternModelHasPatternSerializer != null, "Cannot find serializer for PatternSchema!");
PatternSchema newPatternSchemaOfPatternModelHasPattern = newPatternSchemaOfPatternModelHasPatternSerializer.TryCreateInstance(serializationContext, reader, element.Partition) as PatternSchema;
if (newPatternSchemaOfPatternModelHasPattern != null)
{
element.Pattern = newPatternSchemaOfPatternModelHasPattern;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newPatternSchemaOfPatternModelHasPattern.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newPatternSchemaOfPatternModelHasPattern.GetDomainClass().Name + "!");
targetSerializer.Read(serializationContext, newPatternSchemaOfPatternModelHasPattern, reader);
}
else
{
DslModeling::DomainRelationshipXmlSerializer newPatternModelHasPatternSerializer = serializationContext.Directory.GetSerializer(PatternModelHasPattern.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(newPatternModelHasPatternSerializer != null, "Cannot find serializer for PatternModelHasPattern!");
PatternModelHasPattern newPatternModelHasPattern = newPatternModelHasPatternSerializer.TryCreateDerivedInstance (serializationContext, reader, element.Partition) as PatternModelHasPattern;
if (newPatternModelHasPattern != null)
{
DslModeling::DomainRoleInfo.SetRolePlayer (newPatternModelHasPattern, PatternModelHasPattern.PatternModelSchemaDomainRoleId, element);
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newPatternModelHasPattern.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newPatternModelHasPattern.GetDomainClass().Name + "!");
targetSerializer.Read(serializationContext, newPatternModelHasPattern, reader);
}
}
}
}
}
private void LoadDiagram(
DslModeling.SerializationResult serializationResult,
DslModeling.Partition diagramPartition,
PatternModelSchema modelRoot,
DslModeling.DomainXmlSerializerDirectory directory,
DslModeling.DomainClassXmlSerializer diagramSerializer,
string diagramFileName,
DslModeling.ISchemaResolver schemaResolver,
ValidationController validationController)
{
if (diagramSerializer != null)
{
PatternModelSchemaDiagram diagram = null;
using (FileStream fileStream = File.OpenRead(diagramFileName))
{
var serializationContext = new DslModeling.SerializationContext(directory, fileStream.Name, serializationResult);
this.InitializeSerializationContext(diagramPartition, serializationContext, true);
var transactionContext = new DslModeling.TransactionContext();
transactionContext.Add(DslModeling.SerializationContext.TransactionContextKey, serializationContext);
using (var transaction = diagramPartition.Store.TransactionManager.BeginTransaction(Resources.PatternModelSerializationHelper_TransactionDescriptionLoadingDiagram, true, transactionContext))
{
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new diagram to be created and returned
if (fileStream.Length > 5)
{
var settings = PatternModelSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
try
{
using (var reader = XmlReader.Create(fileStream, settings))
{
reader.MoveToContent();
diagram = diagramSerializer.TryCreateInstance(serializationContext, reader, diagramPartition) as PatternModelSchemaDiagram;
if (diagram != null)
{
this.ReadRootElement(serializationContext, diagram, reader, schemaResolver);
}
}
}
catch (XmlException ex)
{
DslModeling.SerializationUtilities.AddMessage(serializationContext, DslModeling.SerializationMessageKind.Error, ex);
}
if (serializationResult.Failed)
{
// Serialization error encountered, rollback the transaction.
diagram = null;
transaction.Rollback();
}
}
if (diagram == null && !serializationResult.Failed)
{
// Create diagram if it doesn't exist
if (diagramFileName.EndsWith(DesignerConstants.DiagramFileExtension, StringComparison.OrdinalIgnoreCase))
{
diagram = new PatternModelSchemaDiagram(
diagramPartition.Store,
new DslModeling.PropertyAssignment(DslDiagrams.Diagram.NameDomainPropertyId, Guid.NewGuid()));
}
else
{
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
}
if (transaction.IsActive)
{
transaction.Commit();
}
} // End inner Tx
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(diagramPartition, ValidationCategories.Load);
}
}
}
if (diagram != null)
{
if (!serializationResult.Failed)
{ // Succeeded.
diagram.ModelElement = modelRoot;
diagram.PostDeserialization(true);
this.CheckForOrphanedShapes(diagram, serializationResult);
}
else
{ // Failed.
diagram.PostDeserialization(false);
}
}
}
}
internal static PatternModelSchemaDiagram CreatePatternModelSchemaDiagram(DslModeling.SerializationResult serializationResult, DslModeling.Partition diagramPartition, PatternModelSchema modelRoot, string diagramId)
{
var diagram = new PatternModelSchemaDiagram(
diagramPartition.Store,
new DslModeling.PropertyAssignment(DslDiagrams.Diagram.NameDomainPropertyId, diagramId),
new DslModeling.PropertyAssignment(
DslModeling.ElementFactory.IdPropertyAssignment,
!string.IsNullOrEmpty(diagramId) ? new Guid(diagramId) : Guid.NewGuid()));
diagram.ModelElement = modelRoot;
diagram.PostDeserialization(true);
DoCheckForOrphanedShapes(diagram, serializationResult);
return(diagram);
}
private MemoryStream InternalSaveModel2(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(modelRoot != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
serializationResult.Encoding = encoding;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = PatternModelSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
this.WriteRootElement(serializationContext, modelRoot, writer);
}
return(newFileContent);
}
/// <summary>
/// Tailors the given pattern line, making this pattern line tailored.
/// </summary>
internal void Tailor(PatternModelSchema basePatternModel, Version baseVersion)
{
this.ClonerFactory(basePatternModel, baseVersion, this).Clone();
this.ApplyTailoringCustomizationRules();
}
/// <summary>
/// Saves the given model root to the given file, with default encoding (UTF-8), and optional properties with default value will not
/// be written out.
/// </summary>
/// <param name="serializationResult">Stores serialization result from the save operation.</param>
/// <param name="modelRoot">PatternModelSchema instance to be saved.</param>
/// <param name="fileName">Name of the file in which the PatternModelSchema instance will be saved.</param>
public virtual void SaveModel(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string fileName)
{
this.SaveModel(serializationResult, modelRoot, fileName, global::System.Text.Encoding.UTF8, false);
}
internal void SaveModelAndDiagrams(
DslModeling.SerializationResult serializationResult,
PatternModelSchema modelRoot,
string modelFileName,
Dictionary<string, PatternModelSchemaDiagram> diagrams,
Encoding encoding,
bool writeOptionalPropertiesWithDefaultValue)
{
Guard.NotNull(() => serializationResult, serializationResult);
Guard.NotNull(() => modelRoot, modelRoot);
Guard.NotNullOrEmpty(() => modelFileName, modelFileName);
Guard.NotNull(() => diagrams, diagrams);
Guard.NotNull(() => encoding, encoding);
if (serializationResult.Failed)
{
return;
}
using (MemoryStream modelFileContent =
this.InternalSaveModel2(serializationResult, modelRoot, modelFileName, encoding, writeOptionalPropertiesWithDefaultValue))
{
if (serializationResult.Failed)
{
return;
}
foreach (var diagram in diagrams)
{
using (MemoryStream diagramFileContent =
this.InternalSaveDiagram2(serializationResult, diagram.Value, diagram.Key, encoding, writeOptionalPropertiesWithDefaultValue))
{
if (!serializationResult.Failed)
{
if (modelFileContent != null)
{
using (FileStream fileStream = new FileStream(modelFileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
using (BinaryWriter writer = new BinaryWriter(fileStream, encoding))
{
writer.Write(modelFileContent.ToArray());
}
}
}
if (diagramFileContent != null)
{
using (FileStream fileStream = new FileStream(diagram.Key, FileMode.Create, FileAccess.Write, FileShare.None))
{
using (BinaryWriter writer = new BinaryWriter(fileStream, encoding))
{
writer.Write(diagramFileContent.ToArray());
}
}
}
}
}
}
}
}
/// <summary>
/// Saves the given model to the given file, with default encoding (UTF-8).
/// </summary>
/// <param name="serializationResult">Stores serialization result from the save operation.</param>
/// <param name="modelRoot">PatternModelSchema instance to be saved.</param>
/// <param name="fileName">Name of the file in which the PatternModelSchema instance will be saved.</param>
/// <param name="writeOptionalPropertiesWithDefaultValue">Whether optional properties with default value will be saved.</param>
public virtual void SaveModel(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string fileName, bool writeOptionalPropertiesWithDefaultValue)
{
this.SaveModel(serializationResult, modelRoot, fileName, global::System.Text.Encoding.UTF8, writeOptionalPropertiesWithDefaultValue);
}
private void LoadDiagram(
DslModeling.SerializationResult serializationResult,
DslModeling.Partition diagramPartition,
PatternModelSchema modelRoot,
DslModeling.DomainXmlSerializerDirectory directory,
DslModeling.DomainClassXmlSerializer diagramSerializer,
string diagramFileName,
DslModeling.ISchemaResolver schemaResolver,
ValidationController validationController)
{
if (diagramSerializer != null)
{
PatternModelSchemaDiagram diagram = null;
using (FileStream fileStream = File.OpenRead(diagramFileName))
{
var serializationContext = new DslModeling.SerializationContext(directory, fileStream.Name, serializationResult);
this.InitializeSerializationContext(diagramPartition, serializationContext, true);
var transactionContext = new DslModeling.TransactionContext();
transactionContext.Add(DslModeling.SerializationContext.TransactionContextKey, serializationContext);
using (var transaction = diagramPartition.Store.TransactionManager.BeginTransaction(Resources.PatternModelSerializationHelper_TransactionDescriptionLoadingDiagram, true, transactionContext))
{
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new diagram to be created and returned
if (fileStream.Length > 5)
{
var settings = PatternModelSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
try
{
using (var reader = XmlReader.Create(fileStream, settings))
{
reader.MoveToContent();
diagram = diagramSerializer.TryCreateInstance(serializationContext, reader, diagramPartition) as PatternModelSchemaDiagram;
if (diagram != null)
{
this.ReadRootElement(serializationContext, diagram, reader, schemaResolver);
}
}
}
catch (XmlException ex)
{
DslModeling.SerializationUtilities.AddMessage(serializationContext, DslModeling.SerializationMessageKind.Error, ex);
}
if (serializationResult.Failed)
{
// Serialization error encountered, rollback the transaction.
diagram = null;
transaction.Rollback();
}
}
if (diagram == null && !serializationResult.Failed)
{
// Create diagram if it doesn't exist
if (diagramFileName.EndsWith(DesignerConstants.DiagramFileExtension, StringComparison.OrdinalIgnoreCase))
{
diagram = new PatternModelSchemaDiagram(
diagramPartition.Store,
new DslModeling.PropertyAssignment(DslDiagrams.Diagram.NameDomainPropertyId, Guid.NewGuid()));
}
else
{
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
}
if (transaction.IsActive)
{
transaction.Commit();
}
} // End inner Tx
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(diagramPartition, ValidationCategories.Load);
}
}
}
if (diagram != null)
{
if (!serializationResult.Failed)
{ // Succeeded.
diagram.ModelElement = modelRoot;
diagram.PostDeserialization(true);
this.CheckForOrphanedShapes(diagram, serializationResult);
}
else
{ // Failed.
diagram.PostDeserialization(false);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PatternModelCloner"/> class.
/// </summary>
/// <param name="sourcePatternModel">The source pattern line.</param>
/// <param name="sourceVersion">The source version.</param>
/// <param name="targetPatternModel">The target pattern line.</param>
public PatternModelCloner(PatternModelSchema sourcePatternModel, Version sourceVersion, PatternModelSchema targetPatternModel)
{
Guard.NotNull(() => sourcePatternModel, sourcePatternModel);
Guard.NotNull(() => sourceVersion, sourceVersion);
Guard.NotNull(() => targetPatternModel, targetPatternModel);
this.SourcePatternModel = sourcePatternModel;
this.SourceVersion = sourceVersion;
this.TargetPatternModel = targetPatternModel;
}
