private static JsonPrimitive ReadPrimitive(string type, XmlDictionaryReader jsonReader)
        {
            JsonValue result = null;

            switch (type)
            {
            case NullAttributeValue:
                jsonReader.Skip();
                result = null;
                break;

            case BooleanAttributeValue:
                result = jsonReader.ReadElementContentAsBoolean();
                break;

            case StringAttributeValue:
                result = jsonReader.ReadElementContentAsString();
                break;

            case NumberAttributeValue:
                string temp = jsonReader.ReadElementContentAsString();
                result = ConvertStringToJsonNumber(temp);
                break;
            }

            SkipWhitespace(jsonReader);
            return((JsonPrimitive)result);
        }
Example #2
0
            public object ReadValue(XmlDictionaryReader reader)
            {
                object value;

                if (_isArray)
                {
                    switch (_typeCode)
                    {
                    case TypeCode.Byte:
                        value = reader.ReadElementContentAsBase64();
                        break;

                    case TypeCode.Boolean:
                        if (!reader.IsEmptyElement)
                        {
                            reader.ReadStartElement();
                            value = reader.ReadBooleanArray(_itemName, _itemNamespace);
                            reader.ReadEndElement();
                        }
                        else
                        {
                            reader.Read();
                            value = Array.Empty <bool>();
                        }
                        break;

                    case TypeCode.DateTime:
                        if (!reader.IsEmptyElement)
                        {
                            reader.ReadStartElement();
                            value = reader.ReadDateTimeArray(_itemName, _itemNamespace);
                            reader.ReadEndElement();
                        }
                        else
                        {
                            reader.Read();
                            value = Array.Empty <DateTime>();
                        }
                        break;

                    case TypeCode.Decimal:
                        if (!reader.IsEmptyElement)
                        {
                            reader.ReadStartElement();
                            value = reader.ReadDecimalArray(_itemName, _itemNamespace);
                            reader.ReadEndElement();
                        }
                        else
                        {
                            reader.Read();
                            value = Array.Empty <Decimal>();
                        }
                        break;

                    case TypeCode.Int32:
                        if (!reader.IsEmptyElement)
                        {
                            reader.ReadStartElement();
                            value = reader.ReadInt32Array(_itemName, _itemNamespace);
                            reader.ReadEndElement();
                        }
                        else
                        {
                            reader.Read();
                            value = Array.Empty <Int32>();
                        }
                        break;

                    case TypeCode.Int64:
                        if (!reader.IsEmptyElement)
                        {
                            reader.ReadStartElement();
                            value = reader.ReadInt64Array(_itemName, _itemNamespace);
                            reader.ReadEndElement();
                        }
                        else
                        {
                            reader.Read();
                            value = Array.Empty <Int64>();
                        }
                        break;

                    case TypeCode.Single:
                        if (!reader.IsEmptyElement)
                        {
                            reader.ReadStartElement();
                            value = reader.ReadSingleArray(_itemName, _itemNamespace);
                            reader.ReadEndElement();
                        }
                        else
                        {
                            reader.Read();
                            value = Array.Empty <Single>();
                        }
                        break;

                    case TypeCode.Double:
                        if (!reader.IsEmptyElement)
                        {
                            reader.ReadStartElement();
                            value = reader.ReadDoubleArray(_itemName, _itemNamespace);
                            reader.ReadEndElement();
                        }
                        else
                        {
                            reader.Read();
                            value = Array.Empty <Double>();
                        }
                        break;

                    default:
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxInvalidUseOfPrimitiveOperationFormatter));
                    }
                }
                else
                {
                    switch (_typeCode)
                    {
                    case TypeCode.Boolean:
                        value = reader.ReadElementContentAsBoolean();
                        break;

                    case TypeCode.DateTime:
                        value = reader.ReadElementContentAsDateTime();
                        break;

                    case TypeCode.Decimal:
                        value = reader.ReadElementContentAsDecimal();
                        break;

                    case TypeCode.Double:
                        value = reader.ReadElementContentAsDouble();
                        break;

                    case TypeCode.Int32:
                        value = reader.ReadElementContentAsInt();
                        break;

                    case TypeCode.Int64:
                        value = reader.ReadElementContentAsLong();
                        break;

                    case TypeCode.Single:
                        value = reader.ReadElementContentAsFloat();
                        break;

                    case TypeCode.String:
                        return(reader.ReadElementContentAsString());

                    default:
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxInvalidUseOfPrimitiveOperationFormatter));
                    }
                }
                return(value);
            }
Example #3
0
        public void Load(XmlReader xmlReader)
        {
            XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(xmlReader);

            string ns = Constants.WsidNamespace;

            reader.MoveToContent();
            reader.ReadStartElement("RoamingStore", ns);
            reader.MoveToContent();
            reader.ReadStartElement("RoamingInformationCard", ns);
            reader.MoveToContent();
            lang = reader.GetAttribute("xml:lang");
            // metadata
            reader.ReadStartElement("InformationCardMetaData", ns);
            reader.MoveToContent();
            reader.ReadStartElement("InformationCardReference", ns);
            reader.MoveToContent();
            id = reader.ReadElementContentAsString("CardId", ns);
            reader.MoveToContent();
            version = reader.ReadElementContentAsString("CardVersion", ns);
            reader.MoveToContent();
            reader.ReadEndElement();
            reader.MoveToContent();
            name = reader.ReadElementContentAsString("CardName", ns);
            reader.MoveToContent();
            image_mime = reader.GetAttribute("MimeType");
            image      = Convert.FromBase64String(
                reader.ReadElementContentAsString("CardImage", ns));
            reader.MoveToContent();
            issuer = new Uri(
                reader.ReadElementContentAsString("Issuer", ns));
            reader.MoveToContent();
            issued = XmlConvert.ToDateTime(
                reader.ReadElementContentAsString("TimeIssued", ns), XmlDateTimeSerializationMode.Utc);
            reader.MoveToContent();
            expires = XmlConvert.ToDateTime(
                reader.ReadElementContentAsString("TimeExpires", ns), XmlDateTimeSerializationMode.Utc);
            reader.MoveToContent();
            if (reader.IsStartElement("TokenServiceList", ns))
            {
                reader.ReadStartElement("TokenServiceList", ns);
                reader.MoveToContent();
                for (reader.MoveToContent();
                     reader.NodeType == XmlNodeType.Element;
                     reader.MoveToContent())
                {
                    reader.ReadStartElement("TokenService", ns);
                    reader.MoveToContent();
                    TokenService ts = new TokenService();
                    ts.ReadXml(reader);
                    token_services.Add(ts);
                    reader.MoveToContent();
                    reader.ReadEndElement();
                }
                reader.ReadEndElement();
            }

            reader.MoveToContent();
            reader.ReadStartElement("SupportedTokenTypeList", ns);
            for (reader.MoveToContent();
                 reader.NodeType == XmlNodeType.Element;
                 reader.MoveToContent())
            {
                supported_token_types.Add(new Uri(
                                              reader.ReadElementContentAsString("TokenType", Constants.WstNamespace)));
            }
            reader.ReadEndElement();

            reader.MoveToContent();
            reader.ReadStartElement("SupportedClaimTypeList", ns);
            for (reader.MoveToContent();
                 reader.NodeType == XmlNodeType.Element;
                 reader.MoveToContent())
            {
                string uri = reader.GetAttribute("Uri");
                reader.ReadStartElement("SupportedClaimType", ns);
                string tag = reader.ReadElementContentAsString("DisplayTag", ns);
                reader.MoveToContent();
                string desc = reader.ReadElementContentAsString("Description", ns);
                reader.MoveToContent();
                reader.ReadEndElement();
                supported_claim_types.Add(new ClaimTypeDefinition(uri, tag, desc));
            }
            reader.ReadEndElement();

            reader.MoveToContent();
            self_issued = reader.ReadElementContentAsBoolean("IsSelfIssued", ns);
            reader.MoveToContent();
            hash_salt = Convert.FromBase64String(
                reader.ReadElementContentAsString("HashSalt", ns));
            reader.MoveToContent();
            last_updated = XmlConvert.ToDateTime(
                reader.ReadElementContentAsString("TimeLastUpdated", ns), XmlDateTimeSerializationMode.Utc);
            reader.MoveToContent();
            issuer_id = reader.ReadElementContentAsString("IssuerId", ns);
            reader.MoveToContent();
            issuer_name = reader.ReadElementContentAsString("IssuerName", ns);
            reader.MoveToContent();
            back_color = reader.ReadElementContentAsInt("BackgroundColor", ns);

            reader.MoveToContent();
            reader.ReadEndElement();              // InformationCardMetaData

            // private data
            reader.MoveToContent();
            reader.ReadStartElement("InformationCardPrivateData", ns);
            reader.MoveToContent();
            master_key = Convert.FromBase64String(
                reader.ReadElementContentAsString("MasterKey", ns));
            reader.MoveToContent();
            if (reader.IsStartElement("ClaimValueList", ns))
            {
                reader.ReadStartElement("ClaimValueList", ns);

                reader.MoveToContent();
                for (reader.MoveToContent();
                     reader.NodeType == XmlNodeType.Element;
                     reader.MoveToContent())
                {
                    string uri = reader.GetAttribute("Uri");
                    reader.ReadStartElement("ClaimValue", ns);
                    reader.MoveToContent();
                    string value = reader.ReadElementContentAsString("Value", ns);
                    reader.MoveToContent();
                    reader.ReadEndElement();
                    claim_values.Add(new ClaimValue(uri, value));
                }
                reader.ReadEndElement();
                reader.MoveToContent();
            }

            reader.ReadEndElement();              // InformationCardPrivateData

            reader.MoveToContent();
            reader.ReadEndElement();
            reader.MoveToContent();
            reader.ReadEndElement();
        }
Example #4
0
            public object ReadValue(XmlDictionaryReader reader)
            {
                object obj2;

                if (!this.isArray)
                {
                    switch (this.typeCode)
                    {
                    case TypeCode.Int32:
                        return(reader.ReadElementContentAsInt());

                    case TypeCode.Int64:
                        return(reader.ReadElementContentAsLong());

                    case TypeCode.Single:
                        return(reader.ReadElementContentAsFloat());

                    case TypeCode.Double:
                        return(reader.ReadElementContentAsDouble());

                    case TypeCode.Decimal:
                        return(reader.ReadElementContentAsDecimal());

                    case TypeCode.DateTime:
                        return(reader.ReadElementContentAsDateTime());

                    case TypeCode.String:
                        return(reader.ReadElementContentAsString());

                    case TypeCode.Boolean:
                        return(reader.ReadElementContentAsBoolean());
                    }
                    throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxInvalidUseOfPrimitiveOperationFormatter")));
                }
                switch (this.typeCode)
                {
                case TypeCode.Boolean:
                    if (reader.IsEmptyElement)
                    {
                        reader.Read();
                        return(new bool[0]);
                    }
                    reader.ReadStartElement();
                    obj2 = reader.ReadBooleanArray(this.itemName, this.itemNamespace);
                    reader.ReadEndElement();
                    return(obj2);

                case TypeCode.Byte:
                    return(reader.ReadElementContentAsBase64());

                case TypeCode.Int32:
                    if (reader.IsEmptyElement)
                    {
                        reader.Read();
                        return(new int[0]);
                    }
                    reader.ReadStartElement();
                    obj2 = reader.ReadInt32Array(this.itemName, this.itemNamespace);
                    reader.ReadEndElement();
                    return(obj2);

                case TypeCode.Int64:
                    if (reader.IsEmptyElement)
                    {
                        reader.Read();
                        return(new long[0]);
                    }
                    reader.ReadStartElement();
                    obj2 = reader.ReadInt64Array(this.itemName, this.itemNamespace);
                    reader.ReadEndElement();
                    return(obj2);

                case TypeCode.Single:
                    if (reader.IsEmptyElement)
                    {
                        reader.Read();
                        return(new float[0]);
                    }
                    reader.ReadStartElement();
                    obj2 = reader.ReadSingleArray(this.itemName, this.itemNamespace);
                    reader.ReadEndElement();
                    return(obj2);

                case TypeCode.Double:
                    if (reader.IsEmptyElement)
                    {
                        reader.Read();
                        return(new double[0]);
                    }
                    reader.ReadStartElement();
                    obj2 = reader.ReadDoubleArray(this.itemName, this.itemNamespace);
                    reader.ReadEndElement();
                    return(obj2);

                case TypeCode.Decimal:
                    if (reader.IsEmptyElement)
                    {
                        reader.Read();
                        return(new decimal[0]);
                    }
                    reader.ReadStartElement();
                    obj2 = reader.ReadDecimalArray(this.itemName, this.itemNamespace);
                    reader.ReadEndElement();
                    return(obj2);

                case TypeCode.DateTime:
                    if (reader.IsEmptyElement)
                    {
                        reader.Read();
                        return(new DateTime[0]);
                    }
                    reader.ReadStartElement();
                    obj2 = reader.ReadDateTimeArray(this.itemName, this.itemNamespace);
                    reader.ReadEndElement();
                    return(obj2);
                }
                throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxInvalidUseOfPrimitiveOperationFormatter")));
            }