Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Query / PlanCompiler / PropertyRef.cs / 1305376 / PropertyRef.cs
//----------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
//using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...
using System.Globalization;
using System.Data.Common;
using md = System.Data.Metadata.Edm;
//
// The PropertyRef class (and its subclasses) represent references to a property
// of a type.
// The PropertyRefList class represents a list of expected properties
// where each property from the type is described as a PropertyRef
//
// These classes are used by the StructuredTypeEliminator module as part of
// eliminating all structured types. The basic idea of this module is that all
// structured types are flattened out into a single level. To avoid a large amount
// of potentially unnecessary information, we try to identify what pieces of information
// are really necessary at each node of the tree. This is where PropertyRef comes in.
// A PropertyRef (and more generally, a PropertyRefList) identifies a list of
// properties, and can be attached to a node/var to indicate that these were the
// only desired properties.
//
namespace System.Data.Query.PlanCompiler
{
///
/// A PropertyRef class encapsulates a reference to one or more properties of
/// a complex instance - a record type, a complex type or an entity type.
/// A PropertyRef may be of the following kinds.
/// - a simple property reference (just a reference to a simple property)
/// - a typeid reference - applies only to entitytype and complextypes
/// - an entitysetid reference - applies only to ref and entity types
/// - a nested property reference (a reference to a nested property - a.b)
/// - an "all" property reference (all properties)
///
internal abstract class PropertyRef
{
///
/// trivial constructor
///
internal PropertyRef() { }
///
/// Create a nested property ref, with "p" as the prefix.
/// The best way to think of this function as follows.
/// Consider a type T where "this" describes a property X on T. Now
/// consider a new type S, where "p" is a property of S and is of type T.
/// This function creates a PropertyRef that describes the same property X
/// from S.p instead
///
/// the property to prefix with
/// the nested property reference
internal virtual PropertyRef CreateNestedPropertyRef(PropertyRef p)
{
return new NestedPropertyRef(p, this);
}
///
/// Create a nested property ref for a simple property. Delegates to the function
/// above
///
/// the simple property
/// a nestedPropertyRef
internal PropertyRef CreateNestedPropertyRef(md.EdmMember p)
{
return CreateNestedPropertyRef(new SimplePropertyRef(p));
}
///
/// Creates a nested property ref for a rel-property. Delegates to the function above
///
/// the rel-property
/// a nested property ref
internal PropertyRef CreateNestedPropertyRef(InternalTrees.RelProperty p)
{
return CreateNestedPropertyRef(new RelPropertyRef(p));
}
///
/// The tostring method for easy debuggability
///
///
/// A "simple" property ref - represents a simple property of the type
///
internal class SimplePropertyRef : PropertyRef
{
private md.EdmMember m_property;
///
/// Simple constructor
///
/// the property metadata
internal SimplePropertyRef(md.EdmMember property)
{
m_property = property;
}
///
/// Gets the property metadata
///
internal md.EdmMember Property { get { return m_property; } }
///
/// Overrides the default equality function. Two SimplePropertyRefs are
/// equal, if they describe the same property
///
///
///
/// Overrides the default hashcode function.
/// Simply returns the hashcode for the property instead
///
///
///
///
///
/// A TypeId propertyref represents a reference to the TypeId property
/// of a type (complex type, entity type etc.)
///
internal class TypeIdPropertyRef : PropertyRef
{
private TypeIdPropertyRef() : base() { }
///
/// Gets the default instance of this type
///
internal static TypeIdPropertyRef Instance = new TypeIdPropertyRef();
///
/// Friendly string for debugging.
///
public override string ToString()
{
return "TYPEID";
}
}
///
/// An NullSentinel propertyref represents the NullSentinel property for
/// a row type.
/// As with TypeId, this class is a singleton instance
///
internal class NullSentinelPropertyRef : PropertyRef
{
private static NullSentinelPropertyRef s_singleton = new NullSentinelPropertyRef();
private NullSentinelPropertyRef() : base() { }
///
/// Gets the singleton instance
///
internal static NullSentinelPropertyRef Instance
{
get { return s_singleton; }
}
///
///
///
///
/// An EntitySetId propertyref represents the EntitySetId property for
/// an entity type or a ref type.
/// As with TypeId, this class is a singleton instance
///
internal class EntitySetIdPropertyRef : PropertyRef
{
private EntitySetIdPropertyRef() : base() { }
///
/// Gets the singleton instance
///
internal static EntitySetIdPropertyRef Instance = new EntitySetIdPropertyRef();
///
///
///
///
/// A nested propertyref describes a nested property access - think "a.b.c"
///
internal class NestedPropertyRef : PropertyRef
{
private readonly PropertyRef m_inner;
private readonly PropertyRef m_outer;
///
/// Basic constructor.
/// Represents the access of property "propertyRef" within property "property"
///
/// the inner property
/// the outer property
internal NestedPropertyRef(PropertyRef innerProperty, PropertyRef outerProperty)
{
PlanCompiler.Assert(!(innerProperty is NestedPropertyRef), "innerProperty cannot be a NestedPropertyRef");
m_inner = innerProperty;
m_outer = outerProperty;
}
///
/// the nested property
///
internal PropertyRef OuterProperty { get { return m_outer; } }
///
/// the parent property
///
internal PropertyRef InnerProperty { get { return m_inner; } }
///
/// Overrides the default equality function. Two NestedPropertyRefs are
/// equal if the have the same property name, and the types are the same
///
///
///
/// Overrides the default hashcode function. Simply adds the hashcodes
/// of the "property" and "propertyRef" fields
///
///
///
///
///
/// A reference to "all" properties of a type
///
internal class AllPropertyRef : PropertyRef
{
private AllPropertyRef() : base() { }
///
/// Get the singleton instance
///
internal static AllPropertyRef Instance = new AllPropertyRef();
///
/// Create a nested property ref, with "p" as the prefix
///
/// the property to prefix with
/// the nested property reference
internal override PropertyRef CreateNestedPropertyRef(PropertyRef p)
{
return p;
}
///
///
///
///
/// A rel-property ref - represents a rel property of the type
///
internal class RelPropertyRef : PropertyRef
{
#region private state
private InternalTrees.RelProperty m_property;
#endregion
#region constructor
///
/// Simple constructor
///
/// the property metadata
internal RelPropertyRef(InternalTrees.RelProperty property)
{
m_property = property;
}
#endregion
#region public apis
///
/// Gets the property metadata
///
internal InternalTrees.RelProperty Property { get { return m_property; } }
///
/// Overrides the default equality function. Two RelPropertyRefs are
/// equal, if they describe the same property
///
/// the other object to compare to
/// true, if the objects are equal
public override bool Equals(object obj)
{
RelPropertyRef other = obj as RelPropertyRef;
return (other != null &&
m_property.Equals(other.m_property));
}
///
/// Overrides the default hashcode function.
/// Simply returns the hashcode for the property instead
///
/// hashcode for the relpropertyref
public override int GetHashCode()
{
return m_property.GetHashCode();
}
///
/// debugging support
///
///
/// Represents a collection of property references
///
internal class PropertyRefList
{
private Dictionary m_propertyReferences;
private bool m_allProperties;
///
/// Get something that represents "all" property references
///
internal static PropertyRefList All = new PropertyRefList(true);
///
/// Trivial constructor
///
internal PropertyRefList() : this(false) {}
private PropertyRefList(bool allProps)
{
this.m_propertyReferences = new Dictionary();
if (allProps)
{
MakeAllProperties();
}
}
private void MakeAllProperties()
{
m_allProperties = true;
m_propertyReferences.Clear();
m_propertyReferences.Add(AllPropertyRef.Instance, AllPropertyRef.Instance);
}
///
/// Add a new property reference to this list
///
/// new property reference
internal void Add(PropertyRef property)
{
if (m_allProperties)
return;
else if (property is AllPropertyRef)
MakeAllProperties();
else
m_propertyReferences[property] = property;
}
///
/// Append an existing list of property references to myself
///
/// list of property references
internal void Append(PropertyRefList propertyRefs)
{
if (m_allProperties)
return;
foreach (PropertyRef p in propertyRefs.m_propertyReferences.Keys)
{
this.Add(p);
}
}
///
/// Do I contain "all" properties?
///
internal bool AllProperties { get { return m_allProperties; } }
///
/// Create a clone of myself
///
/// a clone of myself
internal PropertyRefList Clone()
{
PropertyRefList newProps = new PropertyRefList(m_allProperties);
foreach (PropertyRef p in this.m_propertyReferences.Keys)
newProps.Add(p);
return newProps;
}
///
/// Do I contain the specifed property?
///
/// The property
/// true, if I do
internal bool Contains(PropertyRef p)
{
return m_allProperties || m_propertyReferences.ContainsKey(p);
}
///
/// Get the list of all properties
///
internal IEnumerable Properties
{
get { return m_propertyReferences.Keys; }
}
///
///
///
///
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
using System;
using System.Collections.Generic;
//using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...
using System.Globalization;
using System.Data.Common;
using md = System.Data.Metadata.Edm;
//
// The PropertyRef class (and its subclasses) represent references to a property
// of a type.
// The PropertyRefList class represents a list of expected properties
// where each property from the type is described as a PropertyRef
//
// These classes are used by the StructuredTypeEliminator module as part of
// eliminating all structured types. The basic idea of this module is that all
// structured types are flattened out into a single level. To avoid a large amount
// of potentially unnecessary information, we try to identify what pieces of information
// are really necessary at each node of the tree. This is where PropertyRef comes in.
// A PropertyRef (and more generally, a PropertyRefList) identifies a list of
// properties, and can be attached to a node/var to indicate that these were the
// only desired properties.
//
namespace System.Data.Query.PlanCompiler
{
///
/// A PropertyRef class encapsulates a reference to one or more properties of
/// a complex instance - a record type, a complex type or an entity type.
/// A PropertyRef may be of the following kinds.
/// - a simple property reference (just a reference to a simple property)
/// - a typeid reference - applies only to entitytype and complextypes
/// - an entitysetid reference - applies only to ref and entity types
/// - a nested property reference (a reference to a nested property - a.b)
/// - an "all" property reference (all properties)
///
internal abstract class PropertyRef
{
///
/// trivial constructor
///
internal PropertyRef() { }
///
/// Create a nested property ref, with "p" as the prefix.
/// The best way to think of this function as follows.
/// Consider a type T where "this" describes a property X on T. Now
/// consider a new type S, where "p" is a property of S and is of type T.
/// This function creates a PropertyRef that describes the same property X
/// from S.p instead
///
/// the property to prefix with
/// the nested property reference
internal virtual PropertyRef CreateNestedPropertyRef(PropertyRef p)
{
return new NestedPropertyRef(p, this);
}
///
/// Create a nested property ref for a simple property. Delegates to the function
/// above
///
/// the simple property
/// a nestedPropertyRef
internal PropertyRef CreateNestedPropertyRef(md.EdmMember p)
{
return CreateNestedPropertyRef(new SimplePropertyRef(p));
}
///
/// Creates a nested property ref for a rel-property. Delegates to the function above
///
/// the rel-property
/// a nested property ref
internal PropertyRef CreateNestedPropertyRef(InternalTrees.RelProperty p)
{
return CreateNestedPropertyRef(new RelPropertyRef(p));
}
///
/// The tostring method for easy debuggability
///
///
/// A "simple" property ref - represents a simple property of the type
///
internal class SimplePropertyRef : PropertyRef
{
private md.EdmMember m_property;
///
/// Simple constructor
///
/// the property metadata
internal SimplePropertyRef(md.EdmMember property)
{
m_property = property;
}
///
/// Gets the property metadata
///
internal md.EdmMember Property { get { return m_property; } }
///
/// Overrides the default equality function. Two SimplePropertyRefs are
/// equal, if they describe the same property
///
///
///
/// Overrides the default hashcode function.
/// Simply returns the hashcode for the property instead
///
///
///
///
///
/// A TypeId propertyref represents a reference to the TypeId property
/// of a type (complex type, entity type etc.)
///
internal class TypeIdPropertyRef : PropertyRef
{
private TypeIdPropertyRef() : base() { }
///
/// Gets the default instance of this type
///
internal static TypeIdPropertyRef Instance = new TypeIdPropertyRef();
///
/// Friendly string for debugging.
///
public override string ToString()
{
return "TYPEID";
}
}
///
/// An NullSentinel propertyref represents the NullSentinel property for
/// a row type.
/// As with TypeId, this class is a singleton instance
///
internal class NullSentinelPropertyRef : PropertyRef
{
private static NullSentinelPropertyRef s_singleton = new NullSentinelPropertyRef();
private NullSentinelPropertyRef() : base() { }
///
/// Gets the singleton instance
///
internal static NullSentinelPropertyRef Instance
{
get { return s_singleton; }
}
///
///
///
///
/// An EntitySetId propertyref represents the EntitySetId property for
/// an entity type or a ref type.
/// As with TypeId, this class is a singleton instance
///
internal class EntitySetIdPropertyRef : PropertyRef
{
private EntitySetIdPropertyRef() : base() { }
///
/// Gets the singleton instance
///
internal static EntitySetIdPropertyRef Instance = new EntitySetIdPropertyRef();
///
///
///
///
/// A nested propertyref describes a nested property access - think "a.b.c"
///
internal class NestedPropertyRef : PropertyRef
{
private readonly PropertyRef m_inner;
private readonly PropertyRef m_outer;
///
/// Basic constructor.
/// Represents the access of property "propertyRef" within property "property"
///
/// the inner property
/// the outer property
internal NestedPropertyRef(PropertyRef innerProperty, PropertyRef outerProperty)
{
PlanCompiler.Assert(!(innerProperty is NestedPropertyRef), "innerProperty cannot be a NestedPropertyRef");
m_inner = innerProperty;
m_outer = outerProperty;
}
///
/// the nested property
///
internal PropertyRef OuterProperty { get { return m_outer; } }
///
/// the parent property
///
internal PropertyRef InnerProperty { get { return m_inner; } }
///
/// Overrides the default equality function. Two NestedPropertyRefs are
/// equal if the have the same property name, and the types are the same
///
///
///
/// Overrides the default hashcode function. Simply adds the hashcodes
/// of the "property" and "propertyRef" fields
///
///
///
///
///
/// A reference to "all" properties of a type
///
internal class AllPropertyRef : PropertyRef
{
private AllPropertyRef() : base() { }
///
/// Get the singleton instance
///
internal static AllPropertyRef Instance = new AllPropertyRef();
///
/// Create a nested property ref, with "p" as the prefix
///
/// the property to prefix with
/// the nested property reference
internal override PropertyRef CreateNestedPropertyRef(PropertyRef p)
{
return p;
}
///
///
///
///
/// A rel-property ref - represents a rel property of the type
///
internal class RelPropertyRef : PropertyRef
{
#region private state
private InternalTrees.RelProperty m_property;
#endregion
#region constructor
///
/// Simple constructor
///
/// the property metadata
internal RelPropertyRef(InternalTrees.RelProperty property)
{
m_property = property;
}
#endregion
#region public apis
///
/// Gets the property metadata
///
internal InternalTrees.RelProperty Property { get { return m_property; } }
///
/// Overrides the default equality function. Two RelPropertyRefs are
/// equal, if they describe the same property
///
/// the other object to compare to
/// true, if the objects are equal
public override bool Equals(object obj)
{
RelPropertyRef other = obj as RelPropertyRef;
return (other != null &&
m_property.Equals(other.m_property));
}
///
/// Overrides the default hashcode function.
/// Simply returns the hashcode for the property instead
///
/// hashcode for the relpropertyref
public override int GetHashCode()
{
return m_property.GetHashCode();
}
///
/// debugging support
///
///
/// Represents a collection of property references
///
internal class PropertyRefList
{
private Dictionary m_propertyReferences;
private bool m_allProperties;
///
/// Get something that represents "all" property references
///
internal static PropertyRefList All = new PropertyRefList(true);
///
/// Trivial constructor
///
internal PropertyRefList() : this(false) {}
private PropertyRefList(bool allProps)
{
this.m_propertyReferences = new Dictionary();
if (allProps)
{
MakeAllProperties();
}
}
private void MakeAllProperties()
{
m_allProperties = true;
m_propertyReferences.Clear();
m_propertyReferences.Add(AllPropertyRef.Instance, AllPropertyRef.Instance);
}
///
/// Add a new property reference to this list
///
/// new property reference
internal void Add(PropertyRef property)
{
if (m_allProperties)
return;
else if (property is AllPropertyRef)
MakeAllProperties();
else
m_propertyReferences[property] = property;
}
///
/// Append an existing list of property references to myself
///
/// list of property references
internal void Append(PropertyRefList propertyRefs)
{
if (m_allProperties)
return;
foreach (PropertyRef p in propertyRefs.m_propertyReferences.Keys)
{
this.Add(p);
}
}
///
/// Do I contain "all" properties?
///
internal bool AllProperties { get { return m_allProperties; } }
///
/// Create a clone of myself
///
/// a clone of myself
internal PropertyRefList Clone()
{
PropertyRefList newProps = new PropertyRefList(m_allProperties);
foreach (PropertyRef p in this.m_propertyReferences.Keys)
newProps.Add(p);
return newProps;
}
///
/// Do I contain the specifed property?
///
/// The property
/// true, if I do
internal bool Contains(PropertyRef p)
{
return m_allProperties || m_propertyReferences.ContainsKey(p);
}
///
/// Get the list of all properties
///
internal IEnumerable Properties
{
get { return m_propertyReferences.Keys; }
}
///
///
///
///
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- InputMethod.cs
- ValuePatternIdentifiers.cs
- XslTransform.cs
- GridItemPatternIdentifiers.cs
- IgnoreDeviceFilterElement.cs
- ZipIOLocalFileDataDescriptor.cs
- OpCopier.cs
- DependencyObjectType.cs
- RelationshipEndCollection.cs
- EndpointAddressAugust2004.cs
- EventLogPermissionEntryCollection.cs
- ToolBarTray.cs
- NamespaceDecl.cs
- SelectionProviderWrapper.cs
- GeometryModel3D.cs
- DataGridViewHeaderCell.cs
- XmlQualifiedName.cs
- RC2.cs
- OleDbConnectionPoolGroupProviderInfo.cs
- FormattedText.cs
- BufferedReceiveManager.cs
- ListViewCommandEventArgs.cs
- PolyQuadraticBezierSegment.cs
- RuleSet.cs
- TextChange.cs
- TextParagraphCache.cs
- ResourceDisplayNameAttribute.cs
- CryptoConfig.cs
- Statements.cs
- DataGridClipboardCellContent.cs
- BaseTemplateCodeDomTreeGenerator.cs
- Stacktrace.cs
- ConfigurationSettings.cs
- ScrollChangedEventArgs.cs
- DockingAttribute.cs
- DbConnectionStringCommon.cs
- PageBreakRecord.cs
- ButtonRenderer.cs
- ViewService.cs
- CustomAttributeBuilder.cs
- XmlStringTable.cs
- RecordBuilder.cs
- Translator.cs
- WinEventQueueItem.cs
- SendMessageContent.cs
- DotNetATv1WindowsLogEntryDeserializer.cs
- IsolatedStorageException.cs
- XmlQueryRuntime.cs
- HierarchicalDataBoundControlAdapter.cs
- ContextMenuStripGroupCollection.cs
- MetaColumn.cs
- httpapplicationstate.cs
- Timer.cs
- DataColumnCollection.cs
- ConnectionPoolManager.cs
- TableDetailsCollection.cs
- QueryCoreOp.cs
- ReadOnlyCollection.cs
- SqlClientMetaDataCollectionNames.cs
- ClipboardProcessor.cs
- ContextDataSourceContextData.cs
- ColorConverter.cs
- Cursor.cs
- DataTablePropertyDescriptor.cs
- DataSetSchema.cs
- ValidationException.cs
- DBDataPermission.cs
- TreeViewCancelEvent.cs
- XPathScanner.cs
- EntityEntry.cs
- JapaneseCalendar.cs
- PointAnimationUsingPath.cs
- RawAppCommandInputReport.cs
- GlobalizationSection.cs
- IPeerNeighbor.cs
- MsmqIntegrationAppDomainProtocolHandler.cs
- TextTreeUndo.cs
- SkinBuilder.cs
- EmbeddedMailObject.cs
- SelectedDatesCollection.cs
- PageStatePersister.cs
- Asn1Utilities.cs
- SerializableTypeCodeDomSerializer.cs
- CreateRefExpr.cs
- AttributeInfo.cs
- IconEditor.cs
- DataGridViewControlCollection.cs
- Block.cs
- IncrementalReadDecoders.cs
- RegexInterpreter.cs
- Identity.cs
- XPathConvert.cs
- MetadataCache.cs
- Query.cs
- TextBoxBase.cs
- DataControlLinkButton.cs
- DateTimeFormatInfo.cs
- DataGridViewRowPrePaintEventArgs.cs
- BindingNavigator.cs
- WebHttpBinding.cs