private static bool Equivalent(AttributePropertyDescriptor x, AttributePropertyDescriptor y)
{
if (!x.AttributeInfo.Equivalent(y.AttributeInfo))
{
return(false);
}
var descX = x as ChildAttributePropertyDescriptor;
var descY = y as ChildAttributePropertyDescriptor;
if (descX == null || descY == null)
{
return(false);
}
var xPath = descX.Path.ToArray();
var yPath = descY.Path.ToArray();
if (xPath.Length != yPath.Length)
{
return(false);
}
for (int i = 0; i < xPath.Length; i++)
{
if (!yPath[i].IsEquivalent(xPath[i]))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Adds OSC addresses (one for the x-coordinate and one for the y-coordinate) for a list
/// of DOM children that have attributes that are arrays of floats. Each array of floats
/// represents a 2D point where the first float is the x coordinate and the second float
/// is the y coordinate.</summary>
/// <param name="childInfo">The child info which defines the list of children of a selected DomNode</param>
/// <param name="childAttributeDesc">The attribute on each child that defines the array of floats</param>
/// <param name="oscAddress">The base OSC address to use. "/x" and "/y" will be appended for
/// the x-coordinate array and the y-coordinate array, which is how Lemur sends and receives
/// 2-D point arrays.</param>
/// <returns>The base OSC address, with possible changes to make it legal.</returns>
public string Add2DPointProperty(ChildInfo childInfo, AttributePropertyDescriptor childAttributeDesc, string oscAddress)
{
oscAddress = OscServices.FixPropertyAddress(oscAddress);
var xCoordDesc = new ChildListFloatingPointArrayDesc(childInfo, childAttributeDesc, 0);
AddPropertyAddress(xCoordDesc, oscAddress + "/x");
var yCoordDesc = new ChildListFloatingPointArrayDesc(childInfo, childAttributeDesc, 1);
AddPropertyAddress(yCoordDesc, oscAddress + "/y");
return oscAddress;
}
public void TestEquality()
{
var attrType1 = new AttributeType("xkcd", typeof(string));
var attrInfo1 = new AttributeInfo("xkcd", attrType1);
attrInfo1.DefaultValue = "Firefly";
var desc1 = new AttributePropertyDescriptor(
"xkcd", attrInfo1, "Category 1", "A commonly used word or phrase in the xkcd comic", true);
int originalHashCode = desc1.GetHashCode();
// test if two identically created property descriptors compare as being equal
var desc2 = new AttributePropertyDescriptor(
"xkcd", attrInfo1, "Category 1", "A commonly used word or phrase in the xkcd comic", true);
Assert.AreEqual(desc1, desc2);
Assert.AreEqual(desc1.GetHashCode(), desc2.GetHashCode());
// test category being different; oddly, although I think they should not be considered equal,
// the .Net PropertyDescriptor ignores the difference in category name. So, I'm guessing that
// the AttributePropertyDescriptor should behave the same as PropertyDescriptor.
var desc3 = new AttributePropertyDescriptor(
"xkcd", attrInfo1, "Category 2", "A commonly used word or phrase in the xkcd comic", true);
Assert.AreEqual(desc1, desc3);
Assert.AreEqual(desc1.GetHashCode(), desc3.GetHashCode());
// test description being different; similarly here, the .Net PropertyDescriptor doesn't care.
var desc4 = new AttributePropertyDescriptor(
"xkcd", attrInfo1, "Category 1", "slightly different description", true);
Assert.AreEqual(desc1, desc4);
Assert.AreEqual(desc1.GetHashCode(), desc4.GetHashCode());
// test readOnly being different; ditto for read-only flag!
var desc5 = new AttributePropertyDescriptor(
"xkcd", attrInfo1, "Category 1", "A commonly used word or phrase in the xkcd comic", false);
Assert.AreEqual(desc1, desc5);
Assert.AreEqual(desc1.GetHashCode(), desc5.GetHashCode());
// test that the hash code hasn't changed after using the AttributeInfo
var domNodeType = new DomNodeType("WebComic", DomNodeType.BaseOfAllTypes);
var attrInfo2 = new AttributeInfo("xkcd", attrType1);
domNodeType.Define(attrInfo2);
Assert.AreEqual(desc1.GetHashCode(), originalHashCode);
// test that the hash code hasn't changed after creating a derived DomNodeType
var derivedDomNodeType = new DomNodeType("ScientificWebComic", domNodeType);
var derivedAttrInfo = new AttributeInfo("xkcd", attrType1);
derivedDomNodeType.Define(derivedAttrInfo);
Assert.AreEqual(desc1.GetHashCode(), originalHashCode);
// test that an AttributeInfo used in a derived DomNodeType doesn't change equality or hash code
var desc6 = new AttributePropertyDescriptor(
"xkcd", derivedAttrInfo, "Category 1", "A commonly used word or phrase in the xkcd comic", true);
Assert.AreEqual(desc1, desc6);
Assert.AreEqual(desc1.GetHashCode(), desc6.GetHashCode());
}
private static bool Equivalent(AttributePropertyDescriptor x, AttributePropertyDescriptor y)
{
if (!x.AttributeInfo.Equivalent(y.AttributeInfo))
return false;
var descX = x as ChildAttributePropertyDescriptor;
var descY = y as ChildAttributePropertyDescriptor;
if (descX == null || descY == null)
return false;
var xPath = descX.Path.ToArray();
var yPath = descY.Path.ToArray();
if (xPath.Length != yPath.Length)
return false;
for (int i = 0; i < xPath.Length; i++)
{
if (!yPath[i].IsEquivalent(xPath[i]))
return false;
}
return true;
}
// 'byteIndex' is 0 for the lowest byte (green), 1 for next lowest byte (blue),
// and 2 for the third byte (red).
public ByteAttributePropertyDescriptor(AttributePropertyDescriptor original, byte byteIndex)
: base(original.Name, original.AttributeInfo, original.Category, original.Description, original.IsReadOnly)
{
m_bitShift = byteIndex * 8;
}
public ChildListFloatingPointArrayDesc(ChildInfo childInfo, AttributePropertyDescriptor childAttributeDesc, int coordinateIndex)
: base(
childAttributeDesc.Name,
childAttributeDesc.AttributeInfo,
childInfo,
childAttributeDesc.Category,
childAttributeDesc.Description,
childAttributeDesc.IsReadOnly,
null, //editor
childAttributeDesc.Converter)
{
m_childInfo = childInfo;
m_childAttributeDesc = childAttributeDesc;
m_coordinateIndex = coordinateIndex;
}
private static PropertyDescriptor GetDescriptor(
DomNodeType type,
XmlNode annotation,
string name,
string[] segments)
{
PropertyDescriptor desc = null;
// Get mandatory display name
XmlAttribute displayNameAttr = annotation.Attributes["displayName"];
if (displayNameAttr != null)
{
if (string.IsNullOrEmpty(name))
{
throw new AnnotationException(string.Format(
"Required name attribute is null or empty.\r\nType: {0}\r\nElement: {1}",
type.Name, annotation.Name));
}
string displayName = displayNameAttr.Value;
if (string.IsNullOrEmpty(displayName))
{
displayName = name;
}
// Get optional annotations
string category = GetAnnotation(annotation, "category");
string description = GetAnnotation(annotation, "description");
bool readOnly = GetAnnotation(annotation, "readOnly") == "true";
object editor = CreateObject <object>(type, annotation, "editor");
TypeConverter typeConverter = CreateObject <TypeConverter>(type, annotation, "converter");
if (annotation.Name == "scea.dom.editors.attribute")
{
// Attribute annotation
if (segments == null)
{
throw new AnnotationException("Unnamed attribute");
}
if (segments.Length == 1) // local attribute
{
AttributeInfo metaAttr = type.GetAttributeInfo(name);
if (metaAttr == null)
{
throw new AnnotationException("Type doesn't have this attribute");
}
desc = new AttributePropertyDescriptor(
displayName, metaAttr,
category, description, readOnly, editor, typeConverter);
}
else // descendant attribute
{
ChildInfo[] metaElements = GetPath(type, segments, segments.Length - 1);
DomNodeType childType = metaElements[segments.Length - 2].Type;
AttributeInfo metaAttr = childType.GetAttributeInfo(segments[segments.Length - 1]);
if (metaAttr == null)
{
throw new AnnotationException("Descendant type doesn't have this attribute");
}
desc = new ChildAttributePropertyDescriptor(
displayName, metaAttr, metaElements,
category, description, readOnly, editor, typeConverter);
}
}
else if (annotation.Name == "scea.dom.editors.child")
{
// Child value annotation
ChildInfo element = type.GetChildInfo(name);
if (element == null)
{
throw new AnnotationException("Type doesn't have this element");
}
desc = new ChildPropertyDescriptor(
displayName, element,
category, description, readOnly, editor, typeConverter);
}
}
return(desc);
}
public void TestGetPropertyDescriptorKey()
{
// First use AttributePropertyDescriptor and MultiPropertyDescriptor
{
// Make sure that different property descriptor objects with the same Name, Category and Type
// have the same hash code, using PropertyUtils.GetPropertyDescriptorHash().
var attrPropertyDescriptor = new AttributePropertyDescriptor(
"TestName", new AttributeInfo("TestAttrName", new AttributeType("TestAttrName", typeof(string))),
"TestCategory", "Test description", false);
var multiPropertyDescriptor = new MultiPropertyDescriptor(attrPropertyDescriptor);
Assert.IsTrue(IsSameHashKey(attrPropertyDescriptor, multiPropertyDescriptor));
// Make sure that null Category names work, too.
attrPropertyDescriptor = new AttributePropertyDescriptor(
"TestName", new AttributeInfo("TestAttrName", new AttributeType("TestAttrName", typeof(string))),
null, "Test description", false);
multiPropertyDescriptor = new MultiPropertyDescriptor(attrPropertyDescriptor);
Assert.IsTrue(IsSameHashKey(attrPropertyDescriptor, multiPropertyDescriptor));
// Make sure that if the Name and Category and identical, that it works with other property
// descriptors who also have identical Name and Category strings. This makes sure that we
// are not using 'xor' between the Name and Category.
attrPropertyDescriptor = new AttributePropertyDescriptor(
"SameName", new AttributeInfo("TestAttrName", new AttributeType("TestAttrName", typeof(string))),
"SameName", "Name and Category are the same!", false);
multiPropertyDescriptor = new MultiPropertyDescriptor(attrPropertyDescriptor);
Assert.IsTrue(IsSameHashKey(attrPropertyDescriptor, multiPropertyDescriptor));
var d2 = new AttributePropertyDescriptor(
"AnotherSameName", new AttributeInfo("TestAttrName", new AttributeType("TestAttrName", typeof(string))),
"AnotherSameName", "Name and Category are the same!", false);
var m2 = new MultiPropertyDescriptor(d2);
Assert.IsTrue(IsSameHashKey(d2, m2));
Assert.IsTrue(!IsSameHashKey(attrPropertyDescriptor, d2));
// Make sure that if the Name and Category are swapped, that they yield different codes.
attrPropertyDescriptor = new AttributePropertyDescriptor(
"Name1", new AttributeInfo("TestAttrName", new AttributeType("TestAttrName", typeof(string))),
"Name2", "Test description", false);
d2 = new AttributePropertyDescriptor(
"Name2", new AttributeInfo("TestAttrName", new AttributeType("TestAttrName", typeof(string))),
"Name1", "Test description", false);
Assert.IsTrue(!IsSameHashKey(attrPropertyDescriptor, d2));
}
// Now use a stub property descriptor and MultiPropertyDescriptor
{
// Make sure that different property descriptor objects with the same Name, Category and Type
// have the same hash code, using PropertyUtils.GetPropertyDescriptorHash().
var stubPropertyDescriptor = new MyPropertyDescriptor("TestName", "TestCategory", typeof(string));
var multiPropertyDescriptor = new MultiPropertyDescriptor(stubPropertyDescriptor);
Assert.IsTrue(IsSameHashKey(stubPropertyDescriptor, multiPropertyDescriptor));
// Make sure that null Category names work, too.
stubPropertyDescriptor = new MyPropertyDescriptor("TestName", null, typeof(string));
multiPropertyDescriptor = new MultiPropertyDescriptor(stubPropertyDescriptor);
Assert.IsTrue(IsSameHashKey(stubPropertyDescriptor, multiPropertyDescriptor));
// Make sure that if the Name and Category and identical, that it works with other property
// descriptors who also have identical Name and Category strings. This makes sure that we
// are not using 'xor' between the Name and Category.
stubPropertyDescriptor = new MyPropertyDescriptor("SameName", "SameName", typeof(string));
multiPropertyDescriptor = new MultiPropertyDescriptor(stubPropertyDescriptor);
Assert.IsTrue(IsSameHashKey(stubPropertyDescriptor, multiPropertyDescriptor));
var d2 = new MyPropertyDescriptor("AnotherSameName", "AnotherSameName", typeof(string));
var m2 = new MultiPropertyDescriptor(d2);
Assert.IsTrue(IsSameHashKey(d2, m2));
Assert.IsTrue(!IsSameHashKey(stubPropertyDescriptor, d2));
// Make sure that if the Name and Category are swapped, that they yield different codes.
stubPropertyDescriptor = new MyPropertyDescriptor("Name1", "Name2", typeof(string));
d2 = new MyPropertyDescriptor("Name2", "Name1", typeof(string));
Assert.IsTrue(!IsSameHashKey(stubPropertyDescriptor, d2));
}
}