ConstNode.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / Data / System / Data / Filter / ConstNode.cs / 1 / ConstNode.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
// [....]
// [....] 
//----------------------------------------------------------------------------- 

namespace System.Data { 
    using System;
    using System.Diagnostics;
    using System.Collections.Generic;
    using System.ComponentModel; 
    using System.Globalization;
 
    internal sealed class ConstNode : ExpressionNode { 
        internal readonly object val;
 
        internal ConstNode(DataTable table, ValueType type, object constant) : this(table, type, constant, true) {
        }

        internal ConstNode(DataTable table, ValueType type, object constant, bool fParseQuotes) : base(table) { 
            switch (type) {
                case ValueType.Null: 
                    this.val = DBNull.Value; 
                    break;
 
                case ValueType.Numeric:
                    this.val = SmallestNumeric(constant);
                    break;
                case ValueType.Decimal: 
                    this.val = SmallestDecimal(constant);
                    break; 
                case ValueType.Float: 
                    this.val = Convert.ToDouble(constant, NumberFormatInfo.InvariantInfo);
                    break; 

                case ValueType.Bool:
                    this.val = Convert.ToBoolean(constant, CultureInfo.InvariantCulture);
                    break; 

                case ValueType.Str: 
                    if (fParseQuotes) { 
                        // replace '' with one '
                        this.val = ((string)constant).Replace("''", "'"); 
                    }
                    else {
                        this.val = (string)constant;
                    } 
                    break;
 
                case ValueType.Date: 
                    this.val = DateTime.Parse((string)constant, CultureInfo.InvariantCulture);
                    break; 

                case ValueType.Object:
                    this.val = constant;
                    break; 

                default: 
                    Debug.Assert(false, "NYI"); 
                    goto case ValueType.Object;
            } 
        }

        internal override void Bind(DataTable table, List list) {
            BindTable(table); 
        }
 
        internal override object Eval() { 
            return val;
        } 

        internal override object Eval(DataRow row, DataRowVersion version) {
            return Eval();
        } 

        internal override object Eval(int[] recordNos) { 
            return Eval(); 
        }
 
        internal override bool IsConstant() {
            return true;
        }
 
        internal override bool IsTableConstant() {
            return true; 
        } 

        internal override bool HasLocalAggregate() { 
            return false;
        }
        internal override bool HasRemoteAggregate() {
            return false; 
        }
 
        internal override ExpressionNode Optimize() { 
            return this;
        } 

        private object SmallestDecimal(object constant) {
            if (null == constant) {
                return 0d; 
            }
            else { 
                string sval = (constant as string); 
                if (null != sval) {
                    decimal r12; 
                    if (Decimal.TryParse(sval, NumberStyles.Number, NumberFormatInfo.InvariantInfo, out r12)) {
                        return r12;
                    }
 
                    double r8;
                    if (Double.TryParse(sval, NumberStyles.Float| NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo, out r8)) { 
                        return r8; 
                    }
                } 
                else {
                    IConvertible convertible = (constant as IConvertible);
                    if (null != convertible) {
                        try { 
                            return convertible.ToDecimal(NumberFormatInfo.InvariantInfo);
                        } 
                        catch (System.ArgumentException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.FormatException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.InvalidCastException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.OverflowException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        try {
                            return convertible.ToDouble(NumberFormatInfo.InvariantInfo);
                        }
                        catch (System.ArgumentException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.FormatException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.InvalidCastException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.OverflowException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                    } 
                }
            } 
            return constant;
        }

        private object SmallestNumeric(object constant) { 
            if (null == constant) {
                return (int)0; 
            } 
            else {
                string sval = (constant as string); 
                if (null != sval) {
                    int i4;
                    if (Int32.TryParse(sval, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out i4)) {
                        return i4; 
                    }
                    long i8; 
                    if (Int64.TryParse(sval, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out i8)) { 
                        return i8;
                    } 
                    double r8;
                    if (Double.TryParse(sval, NumberStyles.Float| NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo, out r8)) {
                        return r8;
                    } 
                }
                else { 
                    IConvertible convertible = (constant as IConvertible); 
                    if (null != convertible) {
                        try { 
                            return convertible.ToInt32(NumberFormatInfo.InvariantInfo);
                        }
                        catch (System.ArgumentException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                        catch (System.FormatException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                        catch (System.InvalidCastException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.OverflowException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
 
                        try { 
                            return convertible.ToInt64(NumberFormatInfo.InvariantInfo);
                        } 
                        catch (System.ArgumentException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.FormatException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.InvalidCastException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.OverflowException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
 
                        try {
                            return convertible.ToDouble(NumberFormatInfo.InvariantInfo); 
                        } 
                        catch (System.ArgumentException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                        catch (System.FormatException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.InvalidCastException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        } 
                        catch (System.OverflowException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                    }
                }
            } 
            return constant;
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
// [....]
// [....] 
//----------------------------------------------------------------------------- 

namespace System.Data { 
    using System;
    using System.Diagnostics;
    using System.Collections.Generic;
    using System.ComponentModel; 
    using System.Globalization;
 
    internal sealed class ConstNode : ExpressionNode { 
        internal readonly object val;
 
        internal ConstNode(DataTable table, ValueType type, object constant) : this(table, type, constant, true) {
        }

        internal ConstNode(DataTable table, ValueType type, object constant, bool fParseQuotes) : base(table) { 
            switch (type) {
                case ValueType.Null: 
                    this.val = DBNull.Value; 
                    break;
 
                case ValueType.Numeric:
                    this.val = SmallestNumeric(constant);
                    break;
                case ValueType.Decimal: 
                    this.val = SmallestDecimal(constant);
                    break; 
                case ValueType.Float: 
                    this.val = Convert.ToDouble(constant, NumberFormatInfo.InvariantInfo);
                    break; 

                case ValueType.Bool:
                    this.val = Convert.ToBoolean(constant, CultureInfo.InvariantCulture);
                    break; 

                case ValueType.Str: 
                    if (fParseQuotes) { 
                        // replace '' with one '
                        this.val = ((string)constant).Replace("''", "'"); 
                    }
                    else {
                        this.val = (string)constant;
                    } 
                    break;
 
                case ValueType.Date: 
                    this.val = DateTime.Parse((string)constant, CultureInfo.InvariantCulture);
                    break; 

                case ValueType.Object:
                    this.val = constant;
                    break; 

                default: 
                    Debug.Assert(false, "NYI"); 
                    goto case ValueType.Object;
            } 
        }

        internal override void Bind(DataTable table, List list) {
            BindTable(table); 
        }
 
        internal override object Eval() { 
            return val;
        } 

        internal override object Eval(DataRow row, DataRowVersion version) {
            return Eval();
        } 

        internal override object Eval(int[] recordNos) { 
            return Eval(); 
        }
 
        internal override bool IsConstant() {
            return true;
        }
 
        internal override bool IsTableConstant() {
            return true; 
        } 

        internal override bool HasLocalAggregate() { 
            return false;
        }
        internal override bool HasRemoteAggregate() {
            return false; 
        }
 
        internal override ExpressionNode Optimize() { 
            return this;
        } 

        private object SmallestDecimal(object constant) {
            if (null == constant) {
                return 0d; 
            }
            else { 
                string sval = (constant as string); 
                if (null != sval) {
                    decimal r12; 
                    if (Decimal.TryParse(sval, NumberStyles.Number, NumberFormatInfo.InvariantInfo, out r12)) {
                        return r12;
                    }
 
                    double r8;
                    if (Double.TryParse(sval, NumberStyles.Float| NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo, out r8)) { 
                        return r8; 
                    }
                } 
                else {
                    IConvertible convertible = (constant as IConvertible);
                    if (null != convertible) {
                        try { 
                            return convertible.ToDecimal(NumberFormatInfo.InvariantInfo);
                        } 
                        catch (System.ArgumentException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.FormatException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.InvalidCastException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.OverflowException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        try {
                            return convertible.ToDouble(NumberFormatInfo.InvariantInfo);
                        }
                        catch (System.ArgumentException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.FormatException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.InvalidCastException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.OverflowException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                    } 
                }
            } 
            return constant;
        }

        private object SmallestNumeric(object constant) { 
            if (null == constant) {
                return (int)0; 
            } 
            else {
                string sval = (constant as string); 
                if (null != sval) {
                    int i4;
                    if (Int32.TryParse(sval, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out i4)) {
                        return i4; 
                    }
                    long i8; 
                    if (Int64.TryParse(sval, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out i8)) { 
                        return i8;
                    } 
                    double r8;
                    if (Double.TryParse(sval, NumberStyles.Float| NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo, out r8)) {
                        return r8;
                    } 
                }
                else { 
                    IConvertible convertible = (constant as IConvertible); 
                    if (null != convertible) {
                        try { 
                            return convertible.ToInt32(NumberFormatInfo.InvariantInfo);
                        }
                        catch (System.ArgumentException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                        catch (System.FormatException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                        catch (System.InvalidCastException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.OverflowException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
 
                        try { 
                            return convertible.ToInt64(NumberFormatInfo.InvariantInfo);
                        } 
                        catch (System.ArgumentException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
                        catch (System.FormatException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.InvalidCastException e) { 
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.OverflowException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        }
 
                        try {
                            return convertible.ToDouble(NumberFormatInfo.InvariantInfo); 
                        } 
                        catch (System.ArgumentException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                        catch (System.FormatException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e);
                        } 
                        catch (System.InvalidCastException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        } 
                        catch (System.OverflowException e) {
                            ExceptionBuilder.TraceExceptionWithoutRethrow(e); 
                        }
                    }
                }
            } 
            return constant;
        } 
    } 
}

// 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

• CategoriesDocument.cs
• EncryptedReference.cs
• WebPartConnectionCollection.cs
• Formatter.cs
• InkCanvasFeedbackAdorner.cs
• SchemaInfo.cs
• MutexSecurity.cs
• PnrpPeerResolver.cs
• ContentPlaceHolder.cs
• TaiwanCalendar.cs
• FunctionImportElement.cs
• SplashScreenNativeMethods.cs
• ConditionValidator.cs
• XmlNodeChangedEventArgs.cs
• CustomLineCap.cs
• DbgCompiler.cs
• XmlQueryCardinality.cs
• DesignTimeXamlWriter.cs
• XsltCompileContext.cs
• StructuredTypeEmitter.cs
• SafeEventLogWriteHandle.cs
• PolicyStatement.cs
• BigInt.cs
• PeerCollaboration.cs
• ZipIOExtraFieldElement.cs
• KeyValueSerializer.cs
• SqlDataSourceSelectingEventArgs.cs
• TextViewBase.cs
• BamlReader.cs
• ResXResourceReader.cs
• MediaContextNotificationWindow.cs
• QueryReaderSettings.cs
• listitem.cs
• TraceContextRecord.cs
• PixelFormatConverter.cs
• TreeNodeConverter.cs
• ListViewItemMouseHoverEvent.cs
• TreeView.cs
• Base64Decoder.cs
• AnnotationResourceChangedEventArgs.cs
• Parser.cs
• WebConfigurationFileMap.cs
• PriorityBinding.cs
• PerspectiveCamera.cs
• InvokeCompletedEventArgs.cs
• UniqueConstraint.cs
• XmlSchemaAnnotation.cs
• TagPrefixCollection.cs
• RightsManagementEncryptionTransform.cs
• WebChannelFactory.cs
• SpanIndex.cs
• NameSpaceEvent.cs
• InternalsVisibleToAttribute.cs
• UnsafeNativeMethods.cs
• AnnotationStore.cs
• XmlMembersMapping.cs
• MaskedTextBox.cs
• GeometryCollection.cs
• DataGridViewCellStyleChangedEventArgs.cs
• UnionCodeGroup.cs
• ListenerServiceInstallComponent.cs
• WindowsToolbar.cs
• TraceContextEventArgs.cs
• SafeHandle.cs
• ListViewUpdateEventArgs.cs
• ObjectListItem.cs
• PackageRelationshipSelector.cs
• DataGridViewCellLinkedList.cs
• FontDifferentiator.cs
• ProviderConnectionPointCollection.cs
• DateTimeFormatInfo.cs
• StringSource.cs
• indexingfiltermarshaler.cs
• FontWeight.cs
• TypeSystem.cs
• SelectionProviderWrapper.cs
• FontFamily.cs
• BlurEffect.cs
• SelectionRangeConverter.cs
• KeyEvent.cs
• SponsorHelper.cs
• TemplateXamlTreeBuilder.cs
• Point3DIndependentAnimationStorage.cs
• Pair.cs
• SafeNativeMethods.cs
• FileDialogCustomPlacesCollection.cs
• ADMembershipUser.cs
• WebServiceResponseDesigner.cs
• LinkArea.cs
• UnmanagedMemoryStreamWrapper.cs
• xmlglyphRunInfo.cs
• ProtocolsConfiguration.cs
• BStrWrapper.cs
• EntityDataSourceReferenceGroup.cs
• HorizontalAlignConverter.cs
• TextTreeRootNode.cs
• ObjectViewListener.cs
• TextTreeTextNode.cs
• CacheSection.cs
• ComplexLine.cs