MetadataItem.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / ndp / fx / src / DataEntity / System / Data / Metadata / Edm / MetadataItem.cs / 1 / MetadataItem.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....], [....]
//--------------------------------------------------------------------- 
using System; 
using System.Collections.Generic;
using System.Collections.ObjectModel; 
using System.Diagnostics;
using System.Text;
using System.Xml.Serialization;
using System.Xml.Schema; 
using System.Xml;
using System.Globalization; 
 
namespace System.Data.Metadata.Edm
{ 
    /// 
    /// Represents the base item class for all the metadata
    /// 
    public abstract partial class MetadataItem 
    {
        #region Constructors 
        ///  
        /// Implementing this internal constructor so that this class can't be derived
        /// outside this assembly 
        /// 
        internal MetadataItem()
        {
        } 
        internal MetadataItem(MetadataFlags flags)
        { 
            _flags = flags; 
        }
        #endregion 

        #region Fields
        [Flags]
        internal enum MetadataFlags { 
            // GlobalItem
            None = 0,  // DataSpace flags are off by one so that zero can be the uninitialized state 
            CSpace = 1,   // (1 << 0) 
            OSpace = 2,   // (1 << 1)
            OCSpace = 3,  // CSpace | OSpace 
            SSpace = 4,   // (1 << 2)
            CSSpace = 5,  // CSpace | SSpace

            DataSpace = OSpace | CSpace | SSpace | OCSpace | CSSpace, 

            // MetadataItem 
            Readonly = (1 << 3), 

            // EdmType 
            IsAbstract = (1 << 4),

            // FunctionParameter
            In = (1 << 9), 
            Out = (1 << 10),
            InOut = In | Out, 
            ReturnValue = (1 << 11), 

            ParameterMode = (In | Out | InOut | ReturnValue), 
        }
        private MetadataFlags _flags;
        private object _flagsLock = new object();
        private MetadataCollection _itemAttributes; 
        private Documentation _documentation;
        #endregion 
 
        #region Properties
 
        /// 
        /// Returns the kind of the type
        /// 
        public abstract BuiltInTypeKind BuiltInTypeKind 
        {
            get; 
        } 

        ///  
        /// List of item attributes on this type
        /// 
        [MetadataProperty(BuiltInTypeKind.MetadataProperty, true)]
        public ReadOnlyMetadataCollection MetadataProperties 
        {
            get 
            { 
                if (null == _itemAttributes)
                { 
                    MetadataPropertyCollection itemAttributes = new MetadataPropertyCollection(this);
                    if (IsReadOnly)
                    {
                        itemAttributes.SetReadOnly(); 
                    }
                    System.Threading.Interlocked.CompareExchange>( 
                        ref _itemAttributes, itemAttributes, null); 
                }
                return _itemAttributes.AsReadOnlyMetadataCollection(); 
            }
        }

        ///  
        /// List of item attributes on this type
        ///  
        internal MetadataCollection RawMetadataProperties 
        {
            get 
            {
                return _itemAttributes;
            }
        } 

        ///  
        /// List of item attributes on this type 
        /// 
        public Documentation Documentation 
        {
            get
            {
                return _documentation; 
            }
            set 
            { 
                _documentation = value;
            } 
        }

        /// 
        /// Identity of the item 
        /// 
        internal abstract String Identity { get; } 
 
        /// 
        /// Just checks for identities to be equal 
        /// 
        /// 
        /// 
        internal virtual bool EdmEquals(MetadataItem item) 
        {
            return ((null != item) && 
                    ((this == item) || // same reference 
                     (this.BuiltInTypeKind == item.BuiltInTypeKind &&
                      this.Identity == item.Identity))); 
        }

        /// 
        /// Returns true if this item is not-changeable. Otherwise returns false. 
        /// 
        internal bool IsReadOnly 
        { 
            get
            { 
                return GetFlag(MetadataFlags.Readonly);
            }
        }
        #endregion 

        #region Methods 
        ///  
        /// Validates the types and sets the readOnly property to true. Once the type is set to readOnly,
        /// it can never be changed. 
        /// 
        internal virtual void SetReadOnly()
        {
            if (!IsReadOnly) 
            {
                if (null != _itemAttributes) 
                { 
                    _itemAttributes.SetReadOnly();
                } 
                SetFlag(MetadataFlags.Readonly, true);
            }
        }
 
        /// 
        /// Builds identity string for this item. By default, the method calls the identity property. 
        ///  
        /// 
        internal virtual void BuildIdentity(StringBuilder builder) 
        {
            builder.Append(this.Identity);
        }
 
        /// 
        /// Adds the given metadata property to the metadata property collection 
        ///  
        /// 
        internal void AddMetadataProperties(List metadataProperties) 
        {
            this.MetadataProperties.Source.AtomicAddRange(metadataProperties);
        }
        #endregion 

        #region MetadataFlags 
        internal DataSpace GetDataSpace() 
        {
            switch (_flags & MetadataFlags.DataSpace) 
            {
                default: return (DataSpace)(-1);
                case MetadataFlags.CSpace: return DataSpace.CSpace;
                case MetadataFlags.OSpace: return DataSpace.OSpace; 
                case MetadataFlags.SSpace: return DataSpace.SSpace;
                case MetadataFlags.OCSpace: return DataSpace.OCSpace; 
                case MetadataFlags.CSSpace: return DataSpace.CSSpace; 
            }
        } 
        internal void SetDataSpace(DataSpace space)
        {
            _flags = (_flags & ~MetadataFlags.DataSpace) | (MetadataFlags.DataSpace & Convert(space));
        } 
        private static MetadataFlags Convert(DataSpace space) {
            switch (space) 
            { 
                default: return MetadataFlags.None; // invalid
                case DataSpace.CSpace: return MetadataFlags.CSpace; 
                case DataSpace.OSpace: return MetadataFlags.OSpace;
                case DataSpace.SSpace: return MetadataFlags.SSpace;
                case DataSpace.OCSpace: return MetadataFlags.OCSpace;
                case DataSpace.CSSpace: return MetadataFlags.CSSpace; 
            }
        } 
 
        internal ParameterMode GetParameterMode()
        { 
            switch (_flags & MetadataFlags.ParameterMode)
            {
                default: return (ParameterMode)(-1); // invalid
                case MetadataFlags.In: return ParameterMode.In; 
                case MetadataFlags.Out: return ParameterMode.Out;
                case MetadataFlags.InOut: return ParameterMode.InOut; 
                case MetadataFlags.ReturnValue: return ParameterMode.ReturnValue; 
            }
        } 
        internal void SetParameterMode(ParameterMode mode)
        {
            _flags = (_flags & ~MetadataFlags.ParameterMode) | (MetadataFlags.ParameterMode & Convert(mode));
        } 
        private static MetadataFlags Convert(ParameterMode mode)
        { 
            switch (mode) 
            {
                default: return MetadataFlags.ParameterMode; // invalid 
                case ParameterMode.In: return MetadataFlags.In;
                case ParameterMode.Out: return MetadataFlags.Out;
                case ParameterMode.InOut: return MetadataFlags.InOut;
                case ParameterMode.ReturnValue: return MetadataFlags.ReturnValue; 
            }
        } 
 
        internal bool GetFlag(MetadataFlags flag)
        { 
            return (flag == (_flags & flag));
        }
        internal void SetFlag(MetadataFlags flag, bool value)
        { 
            if ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly)
            { 
                Debug.Assert(System.Convert.ToInt32(flag & ~MetadataFlags.Readonly,CultureInfo.InvariantCulture) == 0, 
                            "SetFlag() invoked with Readonly and additional flags.");
            } 

            lock (_flagsLock)
            {
                // an attempt to set the ReadOnly flag on a MetadataItem that is already read-only 
                // is a no-op
                // 
                if (IsReadOnly && ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly)) 
                {
                    return; 
                }

                Util.ThrowIfReadOnly(this);
                if (value) 
                {
                    _flags |= flag; 
                } 
                else
                { 
                    _flags &= ~flag;
                }
            }
        } 
        #endregion
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....], [....]
//--------------------------------------------------------------------- 
using System; 
using System.Collections.Generic;
using System.Collections.ObjectModel; 
using System.Diagnostics;
using System.Text;
using System.Xml.Serialization;
using System.Xml.Schema; 
using System.Xml;
using System.Globalization; 
 
namespace System.Data.Metadata.Edm
{ 
    /// 
    /// Represents the base item class for all the metadata
    /// 
    public abstract partial class MetadataItem 
    {
        #region Constructors 
        ///  
        /// Implementing this internal constructor so that this class can't be derived
        /// outside this assembly 
        /// 
        internal MetadataItem()
        {
        } 
        internal MetadataItem(MetadataFlags flags)
        { 
            _flags = flags; 
        }
        #endregion 

        #region Fields
        [Flags]
        internal enum MetadataFlags { 
            // GlobalItem
            None = 0,  // DataSpace flags are off by one so that zero can be the uninitialized state 
            CSpace = 1,   // (1 << 0) 
            OSpace = 2,   // (1 << 1)
            OCSpace = 3,  // CSpace | OSpace 
            SSpace = 4,   // (1 << 2)
            CSSpace = 5,  // CSpace | SSpace

            DataSpace = OSpace | CSpace | SSpace | OCSpace | CSSpace, 

            // MetadataItem 
            Readonly = (1 << 3), 

            // EdmType 
            IsAbstract = (1 << 4),

            // FunctionParameter
            In = (1 << 9), 
            Out = (1 << 10),
            InOut = In | Out, 
            ReturnValue = (1 << 11), 

            ParameterMode = (In | Out | InOut | ReturnValue), 
        }
        private MetadataFlags _flags;
        private object _flagsLock = new object();
        private MetadataCollection _itemAttributes; 
        private Documentation _documentation;
        #endregion 
 
        #region Properties
 
        /// 
        /// Returns the kind of the type
        /// 
        public abstract BuiltInTypeKind BuiltInTypeKind 
        {
            get; 
        } 

        ///  
        /// List of item attributes on this type
        /// 
        [MetadataProperty(BuiltInTypeKind.MetadataProperty, true)]
        public ReadOnlyMetadataCollection MetadataProperties 
        {
            get 
            { 
                if (null == _itemAttributes)
                { 
                    MetadataPropertyCollection itemAttributes = new MetadataPropertyCollection(this);
                    if (IsReadOnly)
                    {
                        itemAttributes.SetReadOnly(); 
                    }
                    System.Threading.Interlocked.CompareExchange>( 
                        ref _itemAttributes, itemAttributes, null); 
                }
                return _itemAttributes.AsReadOnlyMetadataCollection(); 
            }
        }

        ///  
        /// List of item attributes on this type
        ///  
        internal MetadataCollection RawMetadataProperties 
        {
            get 
            {
                return _itemAttributes;
            }
        } 

        ///  
        /// List of item attributes on this type 
        /// 
        public Documentation Documentation 
        {
            get
            {
                return _documentation; 
            }
            set 
            { 
                _documentation = value;
            } 
        }

        /// 
        /// Identity of the item 
        /// 
        internal abstract String Identity { get; } 
 
        /// 
        /// Just checks for identities to be equal 
        /// 
        /// 
        /// 
        internal virtual bool EdmEquals(MetadataItem item) 
        {
            return ((null != item) && 
                    ((this == item) || // same reference 
                     (this.BuiltInTypeKind == item.BuiltInTypeKind &&
                      this.Identity == item.Identity))); 
        }

        /// 
        /// Returns true if this item is not-changeable. Otherwise returns false. 
        /// 
        internal bool IsReadOnly 
        { 
            get
            { 
                return GetFlag(MetadataFlags.Readonly);
            }
        }
        #endregion 

        #region Methods 
        ///  
        /// Validates the types and sets the readOnly property to true. Once the type is set to readOnly,
        /// it can never be changed. 
        /// 
        internal virtual void SetReadOnly()
        {
            if (!IsReadOnly) 
            {
                if (null != _itemAttributes) 
                { 
                    _itemAttributes.SetReadOnly();
                } 
                SetFlag(MetadataFlags.Readonly, true);
            }
        }
 
        /// 
        /// Builds identity string for this item. By default, the method calls the identity property. 
        ///  
        /// 
        internal virtual void BuildIdentity(StringBuilder builder) 
        {
            builder.Append(this.Identity);
        }
 
        /// 
        /// Adds the given metadata property to the metadata property collection 
        ///  
        /// 
        internal void AddMetadataProperties(List metadataProperties) 
        {
            this.MetadataProperties.Source.AtomicAddRange(metadataProperties);
        }
        #endregion 

        #region MetadataFlags 
        internal DataSpace GetDataSpace() 
        {
            switch (_flags & MetadataFlags.DataSpace) 
            {
                default: return (DataSpace)(-1);
                case MetadataFlags.CSpace: return DataSpace.CSpace;
                case MetadataFlags.OSpace: return DataSpace.OSpace; 
                case MetadataFlags.SSpace: return DataSpace.SSpace;
                case MetadataFlags.OCSpace: return DataSpace.OCSpace; 
                case MetadataFlags.CSSpace: return DataSpace.CSSpace; 
            }
        } 
        internal void SetDataSpace(DataSpace space)
        {
            _flags = (_flags & ~MetadataFlags.DataSpace) | (MetadataFlags.DataSpace & Convert(space));
        } 
        private static MetadataFlags Convert(DataSpace space) {
            switch (space) 
            { 
                default: return MetadataFlags.None; // invalid
                case DataSpace.CSpace: return MetadataFlags.CSpace; 
                case DataSpace.OSpace: return MetadataFlags.OSpace;
                case DataSpace.SSpace: return MetadataFlags.SSpace;
                case DataSpace.OCSpace: return MetadataFlags.OCSpace;
                case DataSpace.CSSpace: return MetadataFlags.CSSpace; 
            }
        } 
 
        internal ParameterMode GetParameterMode()
        { 
            switch (_flags & MetadataFlags.ParameterMode)
            {
                default: return (ParameterMode)(-1); // invalid
                case MetadataFlags.In: return ParameterMode.In; 
                case MetadataFlags.Out: return ParameterMode.Out;
                case MetadataFlags.InOut: return ParameterMode.InOut; 
                case MetadataFlags.ReturnValue: return ParameterMode.ReturnValue; 
            }
        } 
        internal void SetParameterMode(ParameterMode mode)
        {
            _flags = (_flags & ~MetadataFlags.ParameterMode) | (MetadataFlags.ParameterMode & Convert(mode));
        } 
        private static MetadataFlags Convert(ParameterMode mode)
        { 
            switch (mode) 
            {
                default: return MetadataFlags.ParameterMode; // invalid 
                case ParameterMode.In: return MetadataFlags.In;
                case ParameterMode.Out: return MetadataFlags.Out;
                case ParameterMode.InOut: return MetadataFlags.InOut;
                case ParameterMode.ReturnValue: return MetadataFlags.ReturnValue; 
            }
        } 
 
        internal bool GetFlag(MetadataFlags flag)
        { 
            return (flag == (_flags & flag));
        }
        internal void SetFlag(MetadataFlags flag, bool value)
        { 
            if ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly)
            { 
                Debug.Assert(System.Convert.ToInt32(flag & ~MetadataFlags.Readonly,CultureInfo.InvariantCulture) == 0, 
                            "SetFlag() invoked with Readonly and additional flags.");
            } 

            lock (_flagsLock)
            {
                // an attempt to set the ReadOnly flag on a MetadataItem that is already read-only 
                // is a no-op
                // 
                if (IsReadOnly && ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly)) 
                {
                    return; 
                }

                Util.ThrowIfReadOnly(this);
                if (value) 
                {
                    _flags |= flag; 
                } 
                else
                { 
                    _flags &= ~flag;
                }
            }
        } 
        #endregion
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK