//////////////////////////////////////////////////////////////////////
        /// <summary>Creates a shipping object given a shipping attribute.
        /// </summary>
        /// <exception cref="ArgumentException">If the attribute
        /// type is not 'shipping' or unknown</exception>
        /// <exception cref="FormatException">If the attribute contains
        /// invalid sub-elements or lacks required sub-elements</exception>
        //////////////////////////////////////////////////////////////////////
        public Shipping(GBaseAttribute attribute)
        {
            GBaseAttributeType type = attribute.Type;

            if (type != null && type != GBaseAttributeType.Shipping)
            {
                throw new ArgumentException("Expected an attribute of " +
                                            "type 'shipping', got an attribute of type '" + type + "'");
            }
            this.country = GetRequiredAttribute(attribute, "country");
            this.service = GetRequiredAttribute(attribute, "service");
            string priceString = GetRequiredAttribute(attribute, "price");

            try
            {
                FloatUnit priceUnit = new FloatUnit(priceString);
                this.price    = priceUnit.Value;
                this.currency = priceUnit.Unit;
            }
            catch (FormatException)
            {
                this.price    = NumberFormat.ToFloat(priceString);
                this.currency = null;
            }
        }
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Creates an AttributeHistogram with no example values.
        /// </summary>
        /// <param name="name">attribute name</param>
        /// <param name="type">attribute type</param>
        /// <param name="count">number of times this attribute appeared
        /// in the histogram query results</param>
        ///////////////////////////////////////////////////////////////////////
        public AttributeHistogram(string name,
                                  GBaseAttributeType type,
                                  int count)
                :this(name, type, count, null)
        {

        }
Exemplo n.º 3
0
 private GBaseAttributeType(GBaseAttributeType supertype,
                            StandardGBaseAttributeTypeIds id,
                            string name)
 {
     this.supertype = supertype;
     this.name      = name;
     this.id        = id;
 }
Exemplo n.º 4
0
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Parses an XML node and create the corresponding
        /// GBaseAttribute.</summary>
        ///////////////////////////////////////////////////////////////////////
        public static GBaseAttribute ParseGBaseAttribute(XmlNode node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            GBaseAttribute attribute = new GBaseAttribute();

            attribute.Name = FromXmlTagName(node.LocalName);
            String value = Utilities.GetAttributeValue("type", node);

            if (value != null)
            {
                attribute.Type = GBaseAttributeType.ForName(value);
            }
            value = Utilities.GetAttributeValue("access", node);
            attribute.IsPrivate = "private".Equals(value);

            foreach (XmlNode child in node.ChildNodes)
            {
                if (child.NodeType == XmlNodeType.Element)
                {
                    bool parsed = false;
                    if (child.NamespaceURI == GBaseNameTable.NSGBaseMeta)
                    {
                        object localName = child.LocalName;
                        if (localName.Equals("adjusted_name"))
                        {
                            attribute.AdjustedName = child.InnerText;
                            parsed = true;
                        }
                        else if (localName.Equals("adjusted_value"))
                        {
                            attribute.AdjustedValue = child.InnerText;
                            parsed = true;
                        }
                    }
                    // Keep everything else as XML
                    if (!parsed)
                    {
                        attribute[child.LocalName] = child.InnerXml;
                    }
                }
            }

            // If there are sub-elements, set the Content to null unless
            // there is clearly something in there.
            string content = ExtractDirectTextChildren(node);

            if (!"".Equals(content.Trim(kXmlWhitespaces)))
            {
                attribute.Content = content;
            }
            return(attribute);
        }
Exemplo n.º 5
0
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Creates an AttributeHistogram.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 /// <param name="count">number of times this attribute appeared
 /// in the histogram query results</param>
 /// <param name="values">example values, may be empty or null
 /// in the histogram query results</param>
 ///////////////////////////////////////////////////////////////////////
 public AttributeHistogram(string name,
                           GBaseAttributeType type,
                           int count,
                           List <HistogramValue> values)
 {
     this.name   = name;
     this.type   = type;
     this.count  = count;
     this.values = values == null ? new List <HistogramValue>() : values;
 }
Exemplo n.º 6
0
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Adds an attribute at the end of the list.
        /// The might exist attributes with the same name, type and even
        /// value. This method will not remove them.</summary>
        /// <param name="name">attribute name</param>
        /// <param name="type">attribute type</param>
        /// <param name="content">value, as a string</param>
        ///////////////////////////////////////////////////////////////////////
        public GBaseAttribute Add(String name,
                                  GBaseAttributeType type,
                                  String content)
        {
            GBaseAttribute attribute =
                new GBaseAttribute(name, type, content);

            Add(attribute);
            return(attribute);
        }
Exemplo n.º 7
0
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Gets all attributes with a specific name and a specific
        /// type.</summary>
        /// <param name="name">attribute name</param>
        /// <param name="type">attribute type</param>
        /// <returns>all attributes on the list that have this name and
        /// type (or one of its subtypes), in order</returns>
        ///////////////////////////////////////////////////////////////////////
        public List <GBaseAttribute> GetAttributes(string name, GBaseAttributeType type)
        {
            List <GBaseAttribute> retVal = new List <GBaseAttribute>();

            foreach (GBaseAttribute var in GetAttributeList(name, type))
            {
                retVal.Add(var);
            }
            return(retVal);
        }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Creates an AttributeHistogram.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 /// <param name="count">number of times this attribute appeared
 /// in the histogram query results</param>
 /// <param name="values">example values, may be empty or null
 /// in the histogram query results</param>
 ///////////////////////////////////////////////////////////////////////
 public AttributeHistogram(string name,
                           GBaseAttributeType type,
                           int count,
                           List<HistogramValue> values)
 {
     this.name = name;
     this.type = type;
     this.count = count;
     this.values = values == null ? new List<HistogramValue>() : values;
 }
Exemplo n.º 9
0
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Gets the first attribute with a specific name and type.
 /// </summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 /// <returns>the first attribute found with this name and type (or
 /// one of its subtypes) or null</returns>
 ///////////////////////////////////////////////////////////////////////
 public GBaseAttribute GetAttribute(string name, GBaseAttributeType type)
 {
     foreach (GBaseAttribute attribute in this)
     {
         if (HasNameAndType(attribute, name, type))
         {
             return(attribute);
         }
     }
     return(null);
 }
Exemplo n.º 10
0
        private ExtensionList GetAttributeList(string name, GBaseAttributeType type)
        {
            ExtensionList retval = ExtensionList.NotVersionAware();

            foreach (GBaseAttribute attribute in this)
            {
                if (HasNameAndType(attribute, name, type))
                {
                    retval.Add(attribute);
                }
            }
            return(retval);
        }
Exemplo n.º 11
0
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Checks whether this object is a supertype or the
        /// same as another type.</summary>
        /// <param name="subtype">other attribute type.</param>
        ///////////////////////////////////////////////////////////////////////
        public bool IsSupertypeOf(GBaseAttributeType subtype)
        {
            if (this == subtype)
            {
                return(true);
            }
            GBaseAttributeType otherSupertype = subtype.Supertype;

            if (otherSupertype == null)
            {
                return(false);
            }
            return(IsSupertypeOf(otherSupertype));
        }
        private bool ExtractAttributeAsFloat(string name,
                                             out float value,
                                             GBaseAttributeType type)
        {
            String stringValue = GetAttributeAsString(name, type);

            if (stringValue == null)
            {
                value = 0;
                return(false);
            }
            value = NumberFormat.ToFloat(stringValue);
            return(true);
        }
        private List <DateTime> GetAttributesAsDateTime(string name,
                                                        GBaseAttributeType type)
        {
            List <DateTime> retval = new List <DateTime>();

            foreach (GBaseAttribute attribute in GetAttributes(name, type))
            {
                if (attribute.Content != null)
                {
                    retval.Add(DateTime.Parse(attribute.Content));
                }
            }
            return(retval);
        }
        private List <float> GetAttributesAsFloat(string name, GBaseAttributeType type)
        {
            List <float> retval = new List <float>();

            foreach (GBaseAttribute attribute in GetAttributes(name, type))
            {
                String content = attribute.Content;
                if (content != null)
                {
                    retval.Add(NumberFormat.ToFloat(content));
                }
            }
            return(retval);
        }
Exemplo n.º 15
0
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Get or create an attribute with the given name.
        /// If the name corresponds to a standard attribute, the global
        /// instance will be returned. Otherwise, a new GBaseAttributeType
        /// with Id = otherType will be created.</summary>
        ///////////////////////////////////////////////////////////////////////
        public static GBaseAttributeType ForName(String name)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }
            GBaseAttributeType standard =
                StandardTypesDict[name] as GBaseAttributeType;

            if (standard != null)
            {
                return(standard);
            }

            return(new GBaseAttributeType(StandardGBaseAttributeTypeIds.otherType,
                                          name));
        }
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Parses XML code and generates an ItemTypeAttributes
        /// object.</summary>
        ///////////////////////////////////////////////////////////////////////
        public static ItemTypeAttributes Parse(XmlNode xml)
        {
            List <AttributeId> attributeIds = new List <AttributeId>();

            for (XmlNode child = xml.FirstChild; child != null; child = child.NextSibling)
            {
                if ("attribute" == child.LocalName &&
                    child.Attributes != null &&
                    child.Attributes["type"] != null)
                {
                    GBaseAttributeType type = GBaseAttributeType.ForName(child.Attributes["type"].Value);
                    attributeIds.Add(new AttributeId(child.Attributes["name"].Value, type));
                }
            }

            return(new ItemTypeAttributes(attributeIds));
        }
Exemplo n.º 17
0
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Parses a gm:attribute tag and create the corresponding
        /// AttributeHistogram object.</summary>
        ///////////////////////////////////////////////////////////////////////
        public static AttributeHistogram Parse(XmlNode node)
        {
            if (node.Attributes != null)
            {
                string             name  = null;
                int                count = 0;
                GBaseAttributeType type  = null;

                name = Utilities.GetAttributeValue("name", node);
                String value = Utilities.GetAttributeValue("type", node);
                if (value != null)
                {
                    type = GBaseAttributeType.ForName(value);
                }
                value = Utilities.GetAttributeValue("count", node);
                if (value != null)
                {
                    count = NumberFormat.ToInt(value);
                }

                if (name != null && type != null)
                {
                    //TODO determine if this is correct.
                    List <HistogramValue> values = new List <HistogramValue>();
                    for (XmlNode child = node.FirstChild;
                         child != null;
                         child = child.NextSibling)
                    {
                        if (child.LocalName == "value")
                        {
                            value = Utilities.GetAttributeValue("count", child);

                            if (value != null)
                            {
                                int valueCount = NumberFormat.ToInt(value);
                                values.Add(new HistogramValue(child.InnerText, valueCount));
                            }
                        }
                    }
                    return(new AttributeHistogram(name, type, count, values));
                }
            }
            return(null);
        }
        private bool ExtractAttributeAsDateTime(string name,
                                                GBaseAttributeType type,
                                                out DateTime value)
        {
            String stringValue = GetAttributeAsString(name, type);

            if (stringValue == null)
            {
                value = NoDateTime;
                return(false);
            }
            try
            {
                value = DateTime.Parse(stringValue);
                return(true);
            }
            catch (FormatException e)
            {
                throw new FormatException(e.Message + " (" + stringValue + ")", e);
            }
        }
Exemplo n.º 19
0
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Compares two types by comparing their names.</summary>
        ///////////////////////////////////////////////////////////////////////
        public override bool Equals(object o)
        {
            if (Object.ReferenceEquals(o, this))
            {
                return(true);
            }

            if (!(o is GBaseAttributeType))
            {
                return(false);
            }

            GBaseAttributeType other = o as GBaseAttributeType;

            if (other.id == id)
            {
                if (other.id == StandardGBaseAttributeTypeIds.otherType)
                {
                    return(name.Equals(other.name));
                }
                return(true);
            }
            return(false);
        }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Gets the first attribute with a specific name and type.
 /// </summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 /// <returns>the first attribute found with this name and type (or
 /// one of its subtypes) or null</returns>
 ///////////////////////////////////////////////////////////////////////
 public GBaseAttribute GetAttribute(string name, GBaseAttributeType type)
 {
     foreach (GBaseAttribute attribute in this)
     {
         if (HasNameAndType(attribute, name, type))
         {
             return attribute;
         }
     }
     return null;
 }
 /// <summary>Creates an AttributeId</summary>x
 public AttributeId(string name, GBaseAttributeType type)
 {
     this.name = name;
     this.type = type;
 }
Exemplo n.º 22
0
 private bool HasNameAndType(GBaseAttribute attr,
                             String name,
                             GBaseAttributeType type)
 {
     return(name == attr.Name && (type == null || type.IsSupertypeOf(attr.Type)));
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Gets all attributes with a specific name and a specific
 /// type.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 /// <returns>all attributes on the list that have this name and
 /// type (or one of its subtypes), in order</returns>
 ///////////////////////////////////////////////////////////////////////
 public List<GBaseAttribute> GetAttributes(string name, GBaseAttributeType type)
 {
     List<GBaseAttribute> retVal = new List<GBaseAttribute>();
     foreach (GBaseAttribute var in GetAttributeList(name, type))
     {
         retVal.Add(var);
     }
     return retVal;
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Adds an attribute at the end of the list.
 /// The might exist attributes with the same name, type and even
 /// value. This method will not remove them.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 /// <param name="content">value, as a string</param>
 ///////////////////////////////////////////////////////////////////////
 public GBaseAttribute Add(String name,
                           GBaseAttributeType type,
                           String content)
 {
     GBaseAttribute attribute =
         new GBaseAttribute(name, type, content);
     Add(attribute);
     return attribute;
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Checks whether this object is a supertype or the
 /// same as another type.</summary>
 /// <param name="subtype">other attribute type.</param>
 ///////////////////////////////////////////////////////////////////////
 public bool IsSupertypeOf(GBaseAttributeType subtype)
 {
     if (this == subtype)
     {
         return true;
     }
     GBaseAttributeType otherSupertype = subtype.Supertype;
     if (otherSupertype == null)
     {
         return false;
     }
     return IsSupertypeOf(otherSupertype);
 }
 private GBaseAttributeType(GBaseAttributeType supertype,
                            StandardGBaseAttributeTypeIds id,
                            string name)
 {
     this.supertype = supertype;
     this.name = name;
     this.id = id;
 }
 private void AssertTypesAreSame(GBaseAttributeType typeA,
                                 GBaseAttributeType typeB)
 {
     Assert.IsTrue(typeA.Equals(typeB), "equals");
     Assert.IsFalse(typeA != typeB, "operaton !=");
     Assert.IsTrue(typeA == typeB, "operator ==");
     Assert.AreEqual(typeA.GetHashCode(), typeB.GetHashCode(), "HashCode");
 }
Exemplo n.º 28
0
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Creates an AttributeHistogram with no example values.
 /// </summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 /// <param name="count">number of times this attribute appeared
 /// in the histogram query results</param>
 ///////////////////////////////////////////////////////////////////////
 public AttributeHistogram(string name,
                           GBaseAttributeType type,
                           int count)
     : this(name, type, count, null)
 {
 }
 private bool HasNameAndType(GBaseAttribute attr,
                             String name,
                             GBaseAttributeType type)
 {
     return name == attr.Name && (type == null || type.IsSupertypeOf(attr.Type));
 }
 private ExtensionList GetAttributeList(string name, GBaseAttributeType type)
 {
     ExtensionList retval = ExtensionList.NotVersionAware();
     foreach (GBaseAttribute attribute in this)
     {
         if (HasNameAndType(attribute, name, type))
         {
             retval.Add(attribute);
         }
     }
     return retval;
 }
 private void AssertTypesAreDifferent(GBaseAttributeType typeA,
                                      GBaseAttributeType typeB)
 {
     Assert.IsFalse(typeA.Equals(typeB), "equals");
     Assert.IsTrue(typeA != typeB, "operator !=");
     Assert.IsFalse(typeA == typeB, "operator ==");
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Remove all attributes with a specific name and type or
 /// on of its subtypes.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 ///////////////////////////////////////////////////////////////////////
 public void RemoveAll(String name, GBaseAttributeType type)
 {
     RemoveAll(GetAttributeList(name, type));
 }
 private bool ExtractAttributeAsFloat(string name,
                                      out float value,
                                      GBaseAttributeType type)
 {
     String stringValue = GetAttributeAsString(name, type);
     if (stringValue == null)
     {
         value = 0;
         return false;
     }
     value = NumberFormat.ToFloat(stringValue);
     return true;
 }
Exemplo n.º 34
0
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Creates a GBaseAttribute</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type or null if unknown</param>
 /// <param name="content">value</param>
 ///////////////////////////////////////////////////////////////////////
 public GBaseAttribute(String name, GBaseAttributeType type, String content)
 {
     this.name    = name;
     this.type    = type;
     this.content = content;
 }
 private List<float> GetAttributesAsFloat(string name, GBaseAttributeType type)
 {
     List<float> retval = new List<float>();
     foreach (GBaseAttribute attribute in GetAttributes(name, type))
     {
         String content = attribute.Content;
         if (content != null)
         {
             retval.Add(NumberFormat.ToFloat(content));
         }
     }
     return retval;
 }
Exemplo n.º 36
0
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Creates a GBaseAttribute with a name and a type.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type or null if unknown</param>
 ///////////////////////////////////////////////////////////////////////
 public GBaseAttribute(String name, GBaseAttributeType type)
     : this(name, type, null)
 {
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Gets the content of the first attribute found with
 /// a specific name and type, as a string.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">type of the attribute</param>
 /// <returns>the value of the first attribute, if found, or null
 /// </returns>
 ///////////////////////////////////////////////////////////////////////
 public String GetAttributeAsString(string name, GBaseAttributeType type)
 {
     return ExtractContent(GetAttribute(name, type));
 }
Exemplo n.º 38
0
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Remove all attributes with a specific name and type or
 /// on of its subtypes.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type</param>
 ///////////////////////////////////////////////////////////////////////
 public void RemoveAll(String name, GBaseAttributeType type)
 {
     RemoveAll(GetAttributeList(name, type));
 }
 private bool ExtractAttributeAsDateTime(string name,
                                         GBaseAttributeType type,
                                         out DateTime value)
 {
     String stringValue = GetAttributeAsString(name, type);
     if (stringValue == null)
     {
         value = NoDateTime;
         return false;
     }
     try
     {
         value = DateTime.Parse(stringValue);
         return true;
     }
     catch(FormatException e)
     {
         throw new FormatException(e.Message + " (" + stringValue + ")", e);
     }
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Creates a GBaseAttribute with a name and a type.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type or null if unknown</param>
 ///////////////////////////////////////////////////////////////////////
 public GBaseAttribute(String name, GBaseAttributeType type)
         : this(name, type, null)
 {
 }
 private List<DateTime> GetAttributesAsDateTime(string name,
         GBaseAttributeType type)
 {
     List<DateTime> retval = new List<DateTime>();
     foreach (GBaseAttribute attribute in GetAttributes(name, type))
     {
         if (attribute.Content != null)
         {
             retval.Add(DateTime.Parse(attribute.Content));
         }
     }
     return retval;
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Gets the content of the first attribute found with
 /// a specific name and type, as a string.</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">type of the attribute</param>
 /// <returns>the value of the first attribute, if found, or null
 /// </returns>
 ///////////////////////////////////////////////////////////////////////
 public String GetAttributeAsString(string name, GBaseAttributeType type)
 {
     return(ExtractContent(GetAttribute(name, type)));
 }
 ///////////////////////////////////////////////////////////////////////
 /// <summary>Creates a GBaseAttribute</summary>
 /// <param name="name">attribute name</param>
 /// <param name="type">attribute type or null if unknown</param>
 /// <param name="content">value</param>
 ///////////////////////////////////////////////////////////////////////
 public GBaseAttribute(String name, GBaseAttributeType type, String content)
 {
     this.name = name;
     this.type = type;
     this.content = content;
 }
 /// <summary>Creates an AttributeId</summary>x
 public AttributeId(string name, GBaseAttributeType type)
 {
     this.name = name;
     this.type = type;
 }
        ///////////////////////////////////////////////////////////////////////
        /// <summary>Parses a gm:attribute tag and create the corresponding
        /// AttributeHistogram object.</summary>
        ///////////////////////////////////////////////////////////////////////
        public static AttributeHistogram Parse(XmlNode node)
        {
            if (node.Attributes != null)
            {
                string name = null;
                int count = 0;
                GBaseAttributeType type = null;

                name = Utilities.GetAttributeValue("name", node);
                String value = Utilities.GetAttributeValue("type", node);
                if (value != null)
                {
                    type = GBaseAttributeType.ForName(value);                
                }
                value = Utilities.GetAttributeValue("count", node);
                if (value != null)
                {
                    count =  NumberFormat.ToInt(value);
                }

                if (name != null && type != null)
                {
                    //TODO determine if this is correct.
                    List<HistogramValue> values = new List<HistogramValue>();
                    for (XmlNode child = node.FirstChild;
                            child != null;
                            child = child.NextSibling)
                    {
                        if (child.LocalName == "value")
                        {
                            value = Utilities.GetAttributeValue("count", child);

                            if (value != null)
                            {
                                int valueCount = NumberFormat.ToInt(value);
                                values.Add(new HistogramValue(child.InnerText, valueCount));
                            }
                        }
                    }
                    return new AttributeHistogram(name, type, count, values);
                }
            }
            return null;
        }