/// <summary> /// Strongly-typed Equals that returns true if this type and "other" type are equivalent. /// </summary> public bool Equals(XmlQueryCardinality other) { return(_value == other._value); }
/// <summary> /// Returns true if this cardinality is guaranteed to be a subset of "other". /// </summary> private bool IsSubset(XmlQueryCardinality other) { return((this.value & ~other.value) == 0); }
/// <summary> /// Returns true if every non-None subset of this cardinality is disjoint with "other" cardinality. /// Here is the behavior for None, which is the inverse of the None behavior for IsSubset: /// None op None = false /// None op ~None = false /// ~None op None = true /// </summary> public bool NeverSubset(XmlQueryCardinality other) { return(_value != 0 && (_value & other._value) == 0); }
/// <summary> /// Private constructor. Create methods should be used to create instances. /// </summary> private SequenceType(XmlQueryType prime, XmlQueryCardinality card) { this.prime = prime; this.card = card; }
/// <summary> /// Deserialize the object from BinaryReader. /// </summary> public static XmlQueryType Create(BinaryReader reader) { if (reader.ReadBoolean()) return TF.NodeSDod; XmlQueryType prime = TF.Deserialize(reader); XmlQueryCardinality card = new XmlQueryCardinality(reader); return Create(prime, card); }
/// <summary> /// Compute a sequence of zero to some max cardinality. /// </summary> /// <param name="t">the type to sequence</param> /// <param name="c">the upper bound</param> /// <returns>the sequence of t from 0 to c</returns> public static XmlQueryType AtMost(XmlQueryType t, XmlQueryCardinality c) { return PrimeProduct(t, c.AtMost()); }
/// <summary> /// Create sequence type from prime and cardinality. /// </summary> public static XmlQueryType Create(XmlQueryType prime, XmlQueryCardinality card) { Debug.Assert(prime != null, "SequenceType can only modify the cardinality of a non-null XmlQueryType."); Debug.Assert(prime.IsSingleton, "Prime type must have cardinality one."); if (prime.TypeCode == XmlTypeCode.None) { // If cardinality includes zero, then return (None, Zero), else return (None, None). return XmlQueryCardinality.Zero <= card ? Zero : None; } // Normalize sequences with these cardinalities: None, Zero, One if (card == XmlQueryCardinality.None) { return None; } else if (card == XmlQueryCardinality.Zero) { return Zero; } else if (card == XmlQueryCardinality.One) { return prime; } return new SequenceType(prime, card); }
/// <summary> /// Compute the product of the prime of "t" with cardinality "c". /// </summary> /// <param name="t">the member type</param> /// <param name="c">the cardinality</param> /// <returns>the prime type with the indicated cardinality applied</returns> public static XmlQueryType PrimeProduct(XmlQueryType t, XmlQueryCardinality c) { // If cardinality stays the same, then this is a no-op if (t.Cardinality == c && !t.IsDod) return t; return SequenceType.Create(t.Prime, c); }
/// <summary> /// Compute a sequence with cardinality *= c. /// </summary> /// <param name="t">the type to sequence</param> /// <param name="c">the cardinality multiplier</param> /// <returns>the sequence of t with cardinality *= c</returns> public static XmlQueryType Product(XmlQueryType t, XmlQueryCardinality c) { return PrimeProduct(t, t.Cardinality * c); }
/// <summary> /// Create an XmlQueryType from an XmlTypeCode and cardinality. /// </summary> /// <param name="code">the type code of the item</param> /// <param name="card">cardinality</param> /// <returns>build-in type type</returns> public XmlQueryType Type(XmlTypeCode code, XmlQueryCardinality card) { return SequenceType.Create(ItemType.Create(code, false), card); }
/// <summary> /// Create an XmlQueryType having an XSD name test, content type, nillable and cardinality. /// </summary> /// <param name="code">unless code is Document, Element, or Attribute, "contentType" is ignored</param> /// <param name="nameTest">name test on the node</param> /// <param name="contentType">content type of the node</param> /// <param name="isNillable">nillable property</param> /// <param name="card">cardinality</param> /// <returns>the item type</returns> public XmlQueryType Type(XmlTypeCode code, XmlQualifiedNameTest nameTest, XmlSchemaType contentType, bool isNillable, XmlQueryCardinality card) { return SequenceType.Create(ItemType.Create(code, nameTest, contentType, isNillable), card); }
/// <summary> /// Strongly-typed Equals that returns true if this type and "other" type are equivalent. /// </summary> public bool Equals(XmlQueryCardinality other) { return this.value == other.value; }
/// <summary> /// Returns true if every non-None subset of this cardinality is disjoint with "other" cardinality. /// Here is the behavior for None, which is the inverse of the None behavior for IsSubset: /// None op None = false /// None op ~None = false /// ~None op None = true /// </summary> public bool NeverSubset(XmlQueryCardinality other) { return this.value != 0 && (this.value & other.value) == 0; }
/// <summary> /// Returns true if this cardinality is guaranteed to be a subset of "other". /// </summary> private bool IsSubset(XmlQueryCardinality other) { return (this.value & ~other.value) == 0; }
private XmlQueryType ParseType(string s) { if (s != null && s.Length > 0) { Match m = s_typeInfoRegex.Match(s); Debug.Assert(m.Success && m.Groups.Count == 4, "Malformed Type info"); XmlQueryCardinality qc = new XmlQueryCardinality(m.Groups[1].Value); bool strict = bool.Parse(m.Groups[3].Value); string[] codes = m.Groups[2].Value.Split('|'); XmlQueryType[] types = new XmlQueryType[codes.Length]; for (int i = 0; i < codes.Length; i++) types[i] = XmlQueryTypeFactory.Type((XmlTypeCode)Enum.Parse(typeof(XmlTypeCode), codes[i]), strict); return XmlQueryTypeFactory.Product(XmlQueryTypeFactory.Choice(types), qc); } return null; }
/// <summary> /// Private constructor. Create methods should be used to create instances. /// </summary> private SequenceType(XmlQueryType prime, XmlQueryCardinality card) { _prime = prime; _card = card; }