internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
        {
            XmlSchemaSimpleType st = null;

            typedValue = null;
            Exception exception = DatatypeImplementation.unionFacetsChecker.CheckLexicalFacets(ref s, this);

            if (exception == null)
            {
                for (int i = 0; i < this.types.Length; i++)
                {
                    if (this.types[i].Datatype.TryParseValue(s, nameTable, nsmgr, out typedValue) == null)
                    {
                        st = this.types[i];
                        break;
                    }
                }
                if (st == null)
                {
                    return(new XmlSchemaException("Sch_UnionFailedEx", s));
                }
                typedValue = new XsdSimpleValue(st, typedValue);
                exception  = DatatypeImplementation.unionFacetsChecker.CheckValueFacets(typedValue, this);
                if (exception == null)
                {
                    return(null);
                }
            }
            return(exception);
        }
Example #2
0
        public override object ChangeType(object value, Type destinationType, IXmlNamespaceResolver nsResolver)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }
            if (destinationType == null)
            {
                throw new ArgumentNullException("destinationType");
            }
            Type sourceType = value.GetType();

            if ((sourceType == XmlBaseConverter.XmlAtomicValueType) && this.hasAtomicMember)
            {
                return(((XmlAtomicValue)value).ValueAs(destinationType, nsResolver));
            }
            if ((sourceType == XmlBaseConverter.XmlAtomicValueArrayType) && this.hasListMember)
            {
                return(XmlAnyListConverter.ItemList.ChangeType(value, destinationType, nsResolver));
            }
            if (!(sourceType == XmlBaseConverter.StringType))
            {
                throw base.CreateInvalidClrMappingException(sourceType, destinationType);
            }
            if (destinationType == XmlBaseConverter.StringType)
            {
                return(value);
            }
            XsdSimpleValue value2 = (XsdSimpleValue)base.SchemaType.Datatype.ParseValue((string)value, new NameTable(), nsResolver, true);

            return(value2.XmlType.ValueConverter.ChangeType((string)value, destinationType, nsResolver));
        }
        private object UnWrapUnion(object typedValue)
        {
            XsdSimpleValue simpleValue = typedValue as XsdSimpleValue;

            if (simpleValue != null)
            {
                typedValue = simpleValue.TypedValue;
            }
            return(typedValue);
        }
Example #4
0
        private object UnWrapUnion(object typedValue)
        {
            XsdSimpleValue value2 = typedValue as XsdSimpleValue;

            if (value2 != null)
            {
                typedValue = value2.TypedValue;
            }
            return(typedValue);
        }
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
        {
            typedValue = null;
            Exception exception = DatatypeImplementation.listFacetsChecker.CheckLexicalFacets(ref s, this);

            if (exception == null)
            {
                object    obj2;
                ArrayList list = new ArrayList();
                if (this.itemType.Variety == XmlSchemaDatatypeVariety.Union)
                {
                    string[] strArray = XmlConvert.SplitString(s);
                    for (int i = 0; i < strArray.Length; i++)
                    {
                        object obj3;
                        exception = this.itemType.TryParseValue(strArray[i], nameTable, nsmgr, out obj3);
                        if (exception != null)
                        {
                            return(exception);
                        }
                        XsdSimpleValue value2 = (XsdSimpleValue)obj3;
                        list.Add(new XmlAtomicValue(value2.XmlType, value2.TypedValue, nsmgr));
                    }
                    obj2 = list.ToArray(typeof(XmlAtomicValue));
                }
                else
                {
                    string[] strArray2 = XmlConvert.SplitString(s);
                    for (int j = 0; j < strArray2.Length; j++)
                    {
                        exception = this.itemType.TryParseValue(strArray2[j], nameTable, nsmgr, out typedValue);
                        if (exception != null)
                        {
                            return(exception);
                        }
                        list.Add(typedValue);
                    }
                    obj2 = list.ToArray(this.itemType.ValueType);
                }
                if (list.Count < this.minListSize)
                {
                    return(new XmlSchemaException("Sch_EmptyAttributeValue", string.Empty));
                }
                exception = DatatypeImplementation.listFacetsChecker.CheckValueFacets(obj2, this);
                if (exception == null)
                {
                    typedValue = obj2;
                    return(null);
                }
            }
            return(exception);
        }
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
        {
            object    obj2;
            Exception innerException = this.TryParseValue(s, nameTable, nsmgr, out obj2);

            if (innerException != null)
            {
                throw new XmlSchemaException("Sch_InvalidValueDetailed", new string[] { s, this.GetTypeName(), innerException.Message }, innerException, null, 0, 0, null);
            }
            if (this.Variety == XmlSchemaDatatypeVariety.Union)
            {
                XsdSimpleValue value2 = obj2 as XsdSimpleValue;
                return(value2.TypedValue);
            }
            return(obj2);
        }
        internal override int Compare(object value1, object value2)
        {
            XsdSimpleValue value3 = value1 as XsdSimpleValue;
            XsdSimpleValue value4 = value2 as XsdSimpleValue;

            if ((value3 != null) && (value4 != null))
            {
                XmlSchemaType xmlType = value3.XmlType;
                XmlSchemaType type2   = value4.XmlType;
                if (xmlType == type2)
                {
                    return(xmlType.Datatype.Compare(value3.TypedValue, value4.TypedValue));
                }
            }
            return(-1);
        }
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;
            if (value == null) {
                throw new ArgumentNullException("value");
            }
            typedValue = null;
            string s = value as string;
            if (s != null) {
                return TryParseValue(s, nameTable, nsmgr, out typedValue);
            }

            object valueToCheck = null;
            XmlSchemaSimpleType memberType = null;
            for (int i = 0; i < types.Length; ++i) {
                if (types[i].Datatype.TryParseValue(value, nameTable, nsmgr, out valueToCheck) == null) { //no error
                    memberType = types[i];
                    break;
                }
            }
            if (valueToCheck == null) {
                exception = new XmlSchemaException(Res.Sch_UnionFailedEx, value.ToString());
                goto Error;
            }
            try {
                if (this.HasLexicalFacets) {
                    string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(System.String), nsmgr); //Using value here to avoid info loss
                    exception = unionFacetsChecker.CheckLexicalFacets(ref s1, this);
                    if (exception != null) goto Error;
                }
                typedValue = new XsdSimpleValue(memberType, valueToCheck);
                if (this.HasValueFacets) {
                    exception = unionFacetsChecker.CheckValueFacets(typedValue, this);
                    if (exception != null) goto Error;
                }
                return null;
            }
            catch (FormatException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }
            catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }
            catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }
            catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }

        Error:
            return exception;
        }
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;
            XmlSchemaSimpleType memberType = null;

            typedValue = null;

            exception = unionFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;

            //Parse string to CLR value
            for (int i = 0; i < types.Length; ++i) {
                exception = types[i].Datatype.TryParseValue(s, nameTable, nsmgr, out typedValue);
                if (exception == null) {
                    memberType = types[i];
                    break;
                }
            }
            if (memberType == null) {
                exception = new XmlSchemaException(Res.Sch_UnionFailedEx, s);
                goto Error;
            }

            typedValue = new XsdSimpleValue(memberType, typedValue);
            exception = unionFacetsChecker.CheckValueFacets(typedValue, this);
            if (exception != null) goto Error;

            return null;

        Error:
            return exception;
        }
 internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
 {
     Exception exception;
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     typedValue = null;
     string s = value as string;
     if (s != null)
     {
         return this.TryParseValue(s, nameTable, nsmgr, out typedValue);
     }
     object obj2 = null;
     XmlSchemaSimpleType st = null;
     for (int i = 0; i < this.types.Length; i++)
     {
         if (this.types[i].Datatype.TryParseValue(value, nameTable, nsmgr, out obj2) == null)
         {
             st = this.types[i];
             break;
         }
     }
     if (obj2 == null)
     {
         return new XmlSchemaException("Sch_UnionFailedEx", value.ToString());
     }
     try
     {
         if (this.HasLexicalFacets)
         {
             string parseString = (string) this.ValueConverter.ChangeType(obj2, typeof(string), nsmgr);
             exception = DatatypeImplementation.unionFacetsChecker.CheckLexicalFacets(ref parseString, this);
             if (exception != null)
             {
                 return exception;
             }
         }
         typedValue = new XsdSimpleValue(st, obj2);
         if (this.HasValueFacets)
         {
             exception = DatatypeImplementation.unionFacetsChecker.CheckValueFacets(typedValue, this);
             if (exception != null)
             {
                 return exception;
             }
         }
         return null;
     }
     catch (FormatException exception2)
     {
         exception = exception2;
     }
     catch (InvalidCastException exception3)
     {
         exception = exception3;
     }
     catch (OverflowException exception4)
     {
         exception = exception4;
     }
     catch (ArgumentException exception5)
     {
         exception = exception5;
     }
     return exception;
 }
 internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
 {
     XmlSchemaSimpleType st = null;
     typedValue = null;
     Exception exception = DatatypeImplementation.unionFacetsChecker.CheckLexicalFacets(ref s, this);
     if (exception == null)
     {
         for (int i = 0; i < this.types.Length; i++)
         {
             if (this.types[i].Datatype.TryParseValue(s, nameTable, nsmgr, out typedValue) == null)
             {
                 st = this.types[i];
                 break;
             }
         }
         if (st == null)
         {
             return new XmlSchemaException("Sch_UnionFailedEx", s);
         }
         typedValue = new XsdSimpleValue(st, typedValue);
         exception = DatatypeImplementation.unionFacetsChecker.CheckValueFacets(typedValue, this);
         if (exception == null)
         {
             return null;
         }
     }
     return exception;
 }
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
        {
            Exception exception;

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }
            typedValue = null;
            string s = value as string;

            if (s != null)
            {
                return(this.TryParseValue(s, nameTable, nsmgr, out typedValue));
            }
            object obj2            = null;
            XmlSchemaSimpleType st = null;

            for (int i = 0; i < this.types.Length; i++)
            {
                if (this.types[i].Datatype.TryParseValue(value, nameTable, nsmgr, out obj2) == null)
                {
                    st = this.types[i];
                    break;
                }
            }
            if (obj2 == null)
            {
                return(new XmlSchemaException("Sch_UnionFailedEx", value.ToString()));
            }
            try
            {
                if (this.HasLexicalFacets)
                {
                    string parseString = (string)this.ValueConverter.ChangeType(obj2, typeof(string), nsmgr);
                    exception = DatatypeImplementation.unionFacetsChecker.CheckLexicalFacets(ref parseString, this);
                    if (exception != null)
                    {
                        return(exception);
                    }
                }
                typedValue = new XsdSimpleValue(st, obj2);
                if (this.HasValueFacets)
                {
                    exception = DatatypeImplementation.unionFacetsChecker.CheckValueFacets(typedValue, this);
                    if (exception != null)
                    {
                        return(exception);
                    }
                }
                return(null);
            }
            catch (FormatException exception2)
            {
                exception = exception2;
            }
            catch (InvalidCastException exception3)
            {
                exception = exception3;
            }
            catch (OverflowException exception4)
            {
                exception = exception4;
            }
            catch (ArgumentException exception5)
            {
                exception = exception5;
            }
            return(exception);
        }