Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Query / InternalTrees / Rule.cs / 1305376 / Rule.cs
//---------------------------------------------------------------------- //// Copyright (c) Microsoft Corporation. All rights reserved. // // // @owner [....] // @backupOwner [....] //--------------------------------------------------------------------- using System; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; namespace System.Data.Query.InternalTrees { ////// A Rule - more specifically, a transformation rule - describes an action that is to /// be taken when a specific kind of subtree is found in the tree /// internal abstract class Rule { ////// The "callback" function for each rule. /// Every callback function must return true if the subtree has /// been modified (or a new subtree has been returned); and must return false /// otherwise. If the root of the subtree has not changed, but some internal details /// of the subtree have changed, it is the responsibility of the rule to update any /// local bookkeeping information. /// /// The rule processing context /// the subtree to operate on /// possibly transformed subtree ///transformation status - true, if there was some change; false otherwise internal delegate bool ProcessNodeDelegate(RuleProcessingContext context, Node subTree, out Node newSubTree); #region private state private ProcessNodeDelegate m_nodeDelegate; private OpType m_opType; #endregion #region Constructors ////// Basic constructor /// /// The OpType we're interested in processing /// The callback to invoke protected Rule(OpType opType, ProcessNodeDelegate nodeProcessDelegate) { Debug.Assert(nodeProcessDelegate != null, "null process delegate"); Debug.Assert(opType != OpType.NotValid, "bad OpType"); Debug.Assert(opType != OpType.Leaf, "bad OpType - Leaf"); m_opType = opType; m_nodeDelegate = nodeProcessDelegate; } #endregion #region protected methods #endregion #region public methods ////// Does the rule match the current node? /// /// the node in question ///true, if a match was found internal abstract bool Match(Node node); ////// We need to invoke the specified callback on the subtree in question - but only /// if the match succeeds /// /// Current rule processing context /// The node (subtree) to process /// the (possibly) modified subtree ///true, if the subtree was modified internal bool Apply(RuleProcessingContext ruleProcessingContext, Node node, out Node newNode) { // invoke the real callback return m_nodeDelegate(ruleProcessingContext, node, out newNode); } ////// The OpType we're interested in transforming /// internal OpType RuleOpType { get { return m_opType; } } #if DEBUG ////// The method name for the rule /// internal string MethodName { get { return m_nodeDelegate.Method.Name; } } #endif #endregion } ////// A SimpleRule is a rule that specifies a specific OpType to look for, and an /// appropriate action to take when such an Op is identified /// internal sealed class SimpleRule : Rule { #region private state #endregion #region constructors ////// Basic constructor. /// /// The OpType we're interested in /// The callback to invoke when we see such an Op internal SimpleRule(OpType opType, ProcessNodeDelegate processDelegate) : base(opType, processDelegate) { } #endregion #region overriden methods internal override bool Match(Node node) { return node.Op.OpType == this.RuleOpType; } #endregion } ////// A PatternMatchRule allows for a pattern to be specified to identify interesting /// subtrees, rather than just an OpType /// internal sealed class PatternMatchRule: Rule { #region private state private Node m_pattern; #endregion #region constructors ////// Basic constructor /// /// The pattern to look for /// The callback to invoke when such a pattern is identified internal PatternMatchRule(Node pattern, ProcessNodeDelegate processDelegate) : base(pattern.Op.OpType, processDelegate) { Debug.Assert(pattern != null, "null pattern"); Debug.Assert(pattern.Op != null, "null pattern Op"); m_pattern = pattern; } #endregion #region private methods private bool Match(Node pattern, Node original) { if (pattern.Op.OpType == OpType.Leaf) return true; if (pattern.Op.OpType != original.Op.OpType) return false; if (pattern.Children.Count != original.Children.Count) return false; for (int i = 0; i < pattern.Children.Count; i++) if (!Match(pattern.Children[i], original.Children[i])) return false; return true; } #endregion #region overridden methods internal override bool Match(Node node) { return Match(m_pattern, node); } #endregion } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. //---------------------------------------------------------------------- //// Copyright (c) Microsoft Corporation. All rights reserved. // // // @owner [....] // @backupOwner [....] //--------------------------------------------------------------------- using System; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; namespace System.Data.Query.InternalTrees { ////// A Rule - more specifically, a transformation rule - describes an action that is to /// be taken when a specific kind of subtree is found in the tree /// internal abstract class Rule { ////// The "callback" function for each rule. /// Every callback function must return true if the subtree has /// been modified (or a new subtree has been returned); and must return false /// otherwise. If the root of the subtree has not changed, but some internal details /// of the subtree have changed, it is the responsibility of the rule to update any /// local bookkeeping information. /// /// The rule processing context /// the subtree to operate on /// possibly transformed subtree ///transformation status - true, if there was some change; false otherwise internal delegate bool ProcessNodeDelegate(RuleProcessingContext context, Node subTree, out Node newSubTree); #region private state private ProcessNodeDelegate m_nodeDelegate; private OpType m_opType; #endregion #region Constructors ////// Basic constructor /// /// The OpType we're interested in processing /// The callback to invoke protected Rule(OpType opType, ProcessNodeDelegate nodeProcessDelegate) { Debug.Assert(nodeProcessDelegate != null, "null process delegate"); Debug.Assert(opType != OpType.NotValid, "bad OpType"); Debug.Assert(opType != OpType.Leaf, "bad OpType - Leaf"); m_opType = opType; m_nodeDelegate = nodeProcessDelegate; } #endregion #region protected methods #endregion #region public methods ////// Does the rule match the current node? /// /// the node in question ///true, if a match was found internal abstract bool Match(Node node); ////// We need to invoke the specified callback on the subtree in question - but only /// if the match succeeds /// /// Current rule processing context /// The node (subtree) to process /// the (possibly) modified subtree ///true, if the subtree was modified internal bool Apply(RuleProcessingContext ruleProcessingContext, Node node, out Node newNode) { // invoke the real callback return m_nodeDelegate(ruleProcessingContext, node, out newNode); } ////// The OpType we're interested in transforming /// internal OpType RuleOpType { get { return m_opType; } } #if DEBUG ////// The method name for the rule /// internal string MethodName { get { return m_nodeDelegate.Method.Name; } } #endif #endregion } ////// A SimpleRule is a rule that specifies a specific OpType to look for, and an /// appropriate action to take when such an Op is identified /// internal sealed class SimpleRule : Rule { #region private state #endregion #region constructors ////// Basic constructor. /// /// The OpType we're interested in /// The callback to invoke when we see such an Op internal SimpleRule(OpType opType, ProcessNodeDelegate processDelegate) : base(opType, processDelegate) { } #endregion #region overriden methods internal override bool Match(Node node) { return node.Op.OpType == this.RuleOpType; } #endregion } ////// A PatternMatchRule allows for a pattern to be specified to identify interesting /// subtrees, rather than just an OpType /// internal sealed class PatternMatchRule: Rule { #region private state private Node m_pattern; #endregion #region constructors ////// Basic constructor /// /// The pattern to look for /// The callback to invoke when such a pattern is identified internal PatternMatchRule(Node pattern, ProcessNodeDelegate processDelegate) : base(pattern.Op.OpType, processDelegate) { Debug.Assert(pattern != null, "null pattern"); Debug.Assert(pattern.Op != null, "null pattern Op"); m_pattern = pattern; } #endregion #region private methods private bool Match(Node pattern, Node original) { if (pattern.Op.OpType == OpType.Leaf) return true; if (pattern.Op.OpType != original.Op.OpType) return false; if (pattern.Children.Count != original.Children.Count) return false; for (int i = 0; i < pattern.Children.Count; i++) if (!Match(pattern.Children[i], original.Children[i])) return false; return true; } #endregion #region overridden methods internal override bool Match(Node node) { return Match(m_pattern, node); } #endregion } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DbProviderServices.cs
- StylusPointPropertyInfo.cs
- AsymmetricSignatureDeformatter.cs
- RectAnimationBase.cs
- unitconverter.cs
- OdbcStatementHandle.cs
- StateMachine.cs
- ConfigXmlText.cs
- SqlErrorCollection.cs
- Debug.cs
- PathData.cs
- HostingEnvironment.cs
- SqlBulkCopy.cs
- NullableBoolConverter.cs
- VisualStyleInformation.cs
- PassportIdentity.cs
- Point3DAnimationUsingKeyFrames.cs
- EmptyStringExpandableObjectConverter.cs
- PersonalizationDictionary.cs
- XamlFigureLengthSerializer.cs
- ByteAnimationUsingKeyFrames.cs
- SecUtil.cs
- QueryLifecycle.cs
- CodeConstructor.cs
- DependencyObjectValidator.cs
- WarningException.cs
- CurrentChangingEventArgs.cs
- InternalSafeNativeMethods.cs
- ClientRoleProvider.cs
- BackgroundWorker.cs
- SystemIPGlobalStatistics.cs
- ActivityDelegate.cs
- DateTimeSerializationSection.cs
- LoginUtil.cs
- LogWriteRestartAreaAsyncResult.cs
- DbModificationClause.cs
- XPathNode.cs
- StorageMappingItemLoader.cs
- EntityContainerEntitySet.cs
- ToolStripCustomTypeDescriptor.cs
- RangeValuePattern.cs
- BrushValueSerializer.cs
- XmlSerializerImportOptions.cs
- ConnectionStringSettings.cs
- ActivityTypeDesigner.xaml.cs
- XmlStringTable.cs
- SchemaObjectWriter.cs
- PageCache.cs
- QuadraticBezierSegment.cs
- ProtocolsConfiguration.cs
- Location.cs
- IPPacketInformation.cs
- FloatUtil.cs
- CodeNamespaceImportCollection.cs
- XsltArgumentList.cs
- RemotingService.cs
- HijriCalendar.cs
- DataGridTextBox.cs
- GenericIdentity.cs
- SmtpReplyReader.cs
- TableRow.cs
- ZeroOpNode.cs
- Compiler.cs
- XmlC14NWriter.cs
- SqlDataSourceQueryConverter.cs
- ComplexLine.cs
- GetChildSubtree.cs
- ListViewInsertedEventArgs.cs
- ThumbAutomationPeer.cs
- HandoffBehavior.cs
- WebPartActionVerb.cs
- __Error.cs
- GenericIdentity.cs
- WebConfigurationManager.cs
- StructuralCache.cs
- FileCodeGroup.cs
- WebZone.cs
- WebPartConnectionCollection.cs
- ValidateNames.cs
- OleDbConnection.cs
- ThaiBuddhistCalendar.cs
- CheckBoxBaseAdapter.cs
- MergePropertyDescriptor.cs
- SecurityState.cs
- XamlBrushSerializer.cs
- Propagator.cs
- DbConnectionOptions.cs
- PointAnimationUsingPath.cs
- PropertyToken.cs
- NameSpaceExtractor.cs
- uribuilder.cs
- PolyQuadraticBezierSegment.cs
- ObjectPersistData.cs
- XmlArrayItemAttribute.cs
- ReachFixedPageSerializerAsync.cs
- SafeHandles.cs
- PropertyBuilder.cs
- IssuerInformation.cs
- WebPartConnectionCollection.cs
- StructuralCache.cs