public DisposeHandler ParseParagraph()
{
CurrentParagraph = new ParagraphParseContext(previousElement, ++currentParagraphIndex);
return(new DisposeHandler(() =>
{
CurrentHierarchy.AddParagraphResult(CurrentParagraph.ParseResult);
previousElement = CurrentParagraph;
}));
}
/// <summary>
/// <para>Adds the <see cref="SymmetricStorageEncryptionProviderNode"/> to the current <see cref="CacheStorageNode"/>.
/// If the Cryptography Application Block configuration is not added to the current application, it is also added.</para>
/// </summary>
/// <param name="e"><para>An <see cref="EventArgs"/> containing the event data.</para></param>
protected override void OnExecuted(EventArgs e)
{
base.OnExecuted(e);
SymmetricStorageEncryptionProviderNode node = ChildNode as SymmetricStorageEncryptionProviderNode;
Debug.Assert(null != node, "Expected a SymmetricStorageEncryptionNode");
if (null == CurrentHierarchy.FindNodeByType(typeof(CryptographySettingsNode)))
{
new AddCryptographySettingsNodeCommand(ServiceProvider).Execute(CurrentHierarchy.RootNode);
}
}
/// <summary>
/// <para>Adds the <see cref="DataCacheStorageNode"/> to the current <see cref="CacheManagerNode"/>. If the Data Application Block configuration is not added to the current application, it is also added.</para>
/// </summary>
/// <param name="e"><para>An <see cref="EventArgs"/> containing the event data.</para></param>
protected override void OnExecuted(EventArgs e)
{
base.OnExecuted(e);
DataCacheStorageNode node = ChildNode as DataCacheStorageNode;
Debug.Assert(null != node, "Expected a DataCacheStorageNode");
if (null == CurrentHierarchy.FindNodeByType(typeof(DatabaseSectionNode)))
{
new AddDatabaseSectionNodeCommand(ServiceProvider).Execute(CurrentHierarchy.RootNode);
}
}
protected override void OnExecuted(EventArgs e)
{
base.OnExecuted(e);
LoggingExceptionHandlerNode node = ChildNode as LoggingExceptionHandlerNode;
if (null == node)
{
return;
}
if (null == CurrentHierarchy.FindNodeByType(typeof(LoggingSettingsNode)))
{
ConfigurationApplicationNode applicationNode = (ConfigurationApplicationNode)CurrentHierarchy.FindNodeByType(typeof(ConfigurationApplicationNode));
new AddLoggingSettingsNodeCommand(ServiceProvider).Execute(applicationNode);
}
}
protected override void ExecuteCore(ConfigurationNode node)
{
ConfigurationSectionCollectionNode configurationSectionCollectionNode = CurrentHierarchy.FindNodeByType(typeof(ConfigurationSectionCollectionNode)) as ConfigurationSectionCollectionNode;
if (configurationSectionCollectionNode == null)
{
return;
}
IXmlIncludeTypeService service = XmlIncludeTypeService;
Type[] types = null;
XmlSerializerTransformerNode transformerNode = null;
foreach (ConfigurationNode configurationNode in configurationSectionCollectionNode.Nodes)
{
transformerNode = CurrentHierarchy.FindNodeByType(configurationNode, typeof(XmlSerializerTransformerNode)) as XmlSerializerTransformerNode;
if (transformerNode == null)
{
continue;
}
types = service.GetXmlIncludeTypes(configurationNode.Name);
if (types == null)
{
continue;
}
ArrayList nodesToRemove = new ArrayList();
foreach (Type t in types)
{
if (!FindNodTypeToDataTypeMatchRecursive(node, t))
{
continue;
}
foreach (XmlIncludeTypeNode xmlIncludeTypeNode in transformerNode.Nodes)
{
Type includeType = Type.GetType(xmlIncludeTypeNode.TypeName, false, true);
if (includeType.Equals(t))
{
nodesToRemove.Add(xmlIncludeTypeNode);
}
}
}
foreach (ConfigurationNode nodeToRemove in nodesToRemove)
{
nodeToRemove.Remove();
}
}
}
protected override void OnExecuted(EventArgs e)
{
base.OnExecuted(e);
LoggingDatabaseNode node = ChildNode as LoggingDatabaseNode;
if (null == node)
{
return;
}
if (null == CurrentHierarchy.FindNodeByType(typeof(LoggingSettingsNode)))
{
new AddLoggingSettingsNodeCommand(ServiceProvider).Execute(CurrentHierarchy.RootNode);
}
if (null == CurrentHierarchy.FindNodeByType(typeof(DatabaseSectionNode)))
{
new AddDatabaseSectionNodeCommand(ServiceProvider).Execute(CurrentHierarchy.RootNode);
}
}
public void ExitHierarchyElement()
{
CurrentHierarchy.Parsed = true;
if (CurrentHierarchy.ElementType == ElementType.TableCell)
{
var hierarchyInfo = (TableHierarchyInfo)CurrentHierarchy.ParentHierarchy.ParentHierarchy.HierarchyInfo;
if (hierarchyInfo.CurrentRow == 0)
{
hierarchyInfo.FirstRowParseContexts.Add(CurrentHierarchy);
}
if (hierarchyInfo.CurrentColumn == 0)
{
hierarchyInfo.FirstColumnParseContexts.Add(CurrentHierarchy);
}
}
else if (CurrentHierarchy.ElementType == ElementType.Title)
{
SetTitleVerse(CurrentHierarchy.ChapterEntry);
}
var valuableHierarchyResult = CurrentHierarchy.ParseResult.GetValuableHierarchyResult();
previousElement = CurrentHierarchy;
CurrentHierarchy = CurrentHierarchy.ParentHierarchy;
if (valuableHierarchyResult != null)
{
if (CurrentHierarchy != null)
{
CurrentHierarchy.AddHierarchyResult(valuableHierarchyResult);
}
else
{
if (DocumentParseResult.RootHierarchyResult != null)
{
throw new InvalidOperationException("DocumentParseResult.RootHierarchyResult != null");
}
DocumentParseResult.RootHierarchyResult = valuableHierarchyResult;
}
}
}
private void SaveHierarchy()
{
CurrentHierarchy.Save();
CheckAndDisplayErrors();
}
private bool SaveHierarchy()
{
CurrentHierarchy.Save();
return(CheckAndDisplayErrors());
}
private bool OtherNodeTypesExists(ConfigurationNode node)
{
ConfigurationNode[] nodes = CurrentHierarchy.FindNodesByType(node.GetType());
return(nodes != null && nodes.Length > 0);
}
protected override void OnExecuted(EventArgs e)
{
DatabaseSectionNode node = ChildNode as DatabaseSectionNode;
Debug.Assert(null != node, "Expected DatabaseSectionNode");
if (addDefaultConnectionString)
{
new AddConnectionStringsSectionNodeCommand(ServiceProvider).Execute(node);
ConnectionStringSettingsNode defaultDatabaseNode = (ConnectionStringSettingsNode)CurrentHierarchy.FindNodeByType(node, typeof(ConnectionStringSettingsNode));
node.DefaultDatabase = defaultDatabaseNode;
}
node.AddNode(new ProviderMappingsNode());
}
