/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets the viewer's current binary mask. Calling this method will also set the
/// viewer's current search class type to Binary.
/// </summary>
/// ------------------------------------------------------------------------------------
public void SetBMask(FeatureMask mask, bool allFeaturesMustMatch)
{
_bMask = mask;
_allFeaturesMustMatch = allFeaturesMustMatch;
_srchClassType = SearchClassType.Binary;
RefreshEnabledPhones();
}
public void ContainsOneOrMore_WithDiffSizeBits()
{
var fmask1 = new FeatureMask(100);
var fmask2 = new FeatureMask(200);
Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2));
}
public void OR()
{
var fmask1 = new FeatureMask(100);
var fmask2 = new FeatureMask(100);
fmask1[10] = true;
fmask1[20] = true;
fmask1[30] = true;
var masks = (UInt64[])ReflectionHelper.GetField(fmask1, "m_masks");
Assert.IsTrue(masks[0] > 0);
Assert.IsTrue(masks[1] == 0);
fmask2[70] = true;
fmask2[80] = true;
fmask2[90] = true;
masks = (UInt64[])ReflectionHelper.GetField(fmask2, "m_masks");
Assert.IsTrue(masks[0] == 0);
Assert.IsTrue(masks[1] > 0);
fmask1 |= fmask2;
Assert.IsTrue(fmask1[10]);
Assert.IsTrue(fmask1[20]);
Assert.IsTrue(fmask1[30]);
Assert.IsTrue(fmask1[70]);
Assert.IsTrue(fmask1[80]);
Assert.IsTrue(fmask1[90]);
}
// "Bit count mismatch: both masks must contain same number of bits.")]
public void OR_WithDiffSizeBits()
{
var fmask1 = new FeatureMask(100);
var fmask2 = new FeatureMask(200);
Assert.IsNotNull(fmask1 | fmask2);
}
// "Bit count mismatch: both masks must contain same number of bits.")]
public void ContainsAll_WithDiffSizeBits()
{
var fmask1 = new FeatureMask(100);
var fmask2 = new FeatureMask(200);
Assert.IsNotNull(fmask1.ContainsAll(fmask2));
}
public void Clone()
{
var fmask1 = new FeatureMask(64);
fmask1[10] = true;
fmask1[20] = true;
fmask1[30] = true;
fmask1[40] = true;
var fmask2 = fmask1.Clone();
Assert.AreEqual(64, fmask2.Size);
Assert.AreEqual(1, (int)ReflectionHelper.GetField(fmask2, "m_maskCount"));
Assert.IsTrue(fmask2[10]);
Assert.IsTrue(fmask2[20]);
Assert.IsTrue(fmask2[30]);
Assert.IsTrue(fmask2[40]);
UInt64 mask = 1;
mask <<= 10;
mask |= 1;
mask <<= 10;
mask |= 1;
mask <<= 10;
mask |= 1;
mask <<= 10;
var masks = (UInt64[])ReflectionHelper.GetField(fmask2, "m_masks");
Assert.AreEqual(mask, masks[0]);
}
public void BitSetting_SingleBit()
{
var fmask = new FeatureMask(100);
var masks = (UInt64[])ReflectionHelper.GetField(fmask, "m_masks");
Assert.AreEqual(0, masks[0]);
Assert.AreEqual(0, masks[1]);
fmask[0] = true;
Assert.AreEqual(1, masks[0]);
fmask[0] = false;
Assert.AreEqual(0, masks[0]);
Int64 expected = 1;
expected <<= 9;
fmask[9] = true;
Assert.AreEqual(expected, masks[0]);
expected = 1;
expected <<= (90 - 64);
fmask[90] = true;
Assert.AreEqual(expected, masks[1]);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handle the user choosing a feature.
/// </summary>
/// ------------------------------------------------------------------------------------
void HandleFeatureChanged(object sender, FeatureMask newMask)
{
m_classInfo.Mask = newMask;
_textBoxMembers.Text = m_classInfo.FormattedMembersString;
m_classInfo.IsDirty = true;
UpdateCharacterViewers();
}
/// ------------------------------------------------------------------------------------
public FeatureListViewBase(FeatureMask emptyMask)
{
_emptyMask = emptyMask;
AllowDoubleClickToChangeCheckState = true;
var colHdr = new ColumnHeader();
colHdr.Width = kMaxColWidth;
_tooltip = new ToolTip();
base.Font = FontHelper.UIFont;
_emphasizedFont = FontHelper.MakeFont(FontHelper.UIFont, FontStyle.Bold);
CheckBoxes = true;
Columns.Add(colHdr);
HeaderStyle = ColumnHeaderStyle.None;
base.DoubleBuffered = true;
LabelEdit = false;
MultiSelect = false;
HideSelection = false;
View = View.List;
OwnerDraw = true;
Visible = true;
}
public void ContainsOneOrMore()
{
var fmask1 = new FeatureMask(100);
var fmask2 = new FeatureMask(100);
Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2));
fmask1[45] = true;
fmask2[75] = true;
Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2));
fmask1[75] = true;
fmask2[45] = true;
Assert.IsTrue(fmask1.ContainsOneOrMore(fmask2));
fmask1[45] = false;
Assert.IsTrue(fmask1.ContainsOneOrMore(fmask2));
fmask1.Clear();
fmask2.Clear();
Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2));
// Overlap by one bit.
for (int i = 60; i <= 64; i++)
{
fmask1[i] = true;
}
for (int i = 64; i < 70; i++)
{
fmask2[i] = true;
}
Assert.IsTrue(fmask1.ContainsOneOrMore(fmask2));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets the viewer's current articulatory masks. Calling this method will also set
/// the viewer's current search class type to Articulatory.
/// </summary>
/// ------------------------------------------------------------------------------------
public void SetAMasks(FeatureMask mask, bool allFeaturesMustMatch)
{
_aMask = mask;
_allFeaturesMustMatch = allFeaturesMustMatch;
_srchClassType = SearchClassType.Articulatory;
RefreshEnabledPhones();
}
public void NotEqual_WithDiffSizes()
{
var fmask1 = new FeatureMask(10);
var fmask2 = new FeatureMask(20);
fmask1[5] = true;
fmask2[5] = true;
Assert.IsTrue(fmask1 != fmask2);
}
public void VerifyToString()
{
var fmask = new FeatureMask(128);
fmask[15] = true;
fmask[31] = true;
fmask[47] = true;
fmask[63] = true;
Assert.AreEqual("8000800080008000", fmask.ToString());
}
public void IsEmtpy()
{
var fmask = new FeatureMask(100);
Assert.IsFalse(fmask.IsEmpty);
fmask = new FeatureMask(0);
Assert.IsTrue(fmask.IsEmpty);
fmask = FeatureMask.Empty;
Assert.IsTrue(fmask.IsEmpty);
}
public void NotEqual_WithNull()
{
FeatureMask fmask1 = null;
FeatureMask fmask2 = null;
Assert.IsFalse(fmask1 != fmask2);
fmask1 = new FeatureMask(1);
Assert.IsTrue(fmask1 != fmask2);
fmask1 = null;
fmask2 = new FeatureMask(1);
Assert.IsTrue(fmask1 != fmask2);
}
public void GetFeatureList()
{
var fmask = new FeatureMask(m_cache.Count);
fmask[m_fNames.IndexOf("Onions")] = true;
fmask[m_fNames.IndexOf("Ham")] = true;
fmask[m_fNames.IndexOf("Cheese")] = true;
var list = m_cache.GetFeatureList(fmask).ToArray();
Assert.AreEqual(3, list.Length);
Assert.AreEqual("Cheese", list[0]);
Assert.AreEqual("Ham", list[1]);
Assert.AreEqual("Onions", list[2]);
}
public void AreAnyBitsSet()
{
var fmask = new FeatureMask(100);
Assert.IsFalse(fmask.IsAnyBitSet);
fmask[45] = true;
fmask[75] = true;
Assert.IsTrue(fmask[45]);
Assert.IsTrue(fmask[75]);
Assert.IsTrue(fmask.IsAnyBitSet);
fmask[45] = false;
fmask[75] = false;
Assert.IsFalse(fmask.IsAnyBitSet);
}
public void BitSetting_MultipleBits()
{
var fmask = new FeatureMask(128);
var masks = (UInt64[])ReflectionHelper.GetField(fmask, "m_masks");
fmask[15] = true;
fmask[31] = true;
fmask[47] = true;
fmask[63] = true;
Assert.AreEqual(0x8000800080008000, masks[0]);
fmask[69] = true;
fmask[85] = true;
fmask[101] = true;
fmask[117] = true;
Assert.AreEqual(0x0020002000200020, masks[1]);
}
public void Clear()
{
var fmask = new FeatureMask(256);
Assert.IsFalse(fmask.IsAnyBitSet);
fmask[60] = true;
fmask[120] = true;
fmask[200] = true;
fmask[250] = true;
Assert.IsTrue(fmask.IsAnyBitSet);
Assert.IsFalse(fmask.IsEmpty);
fmask.Clear();
Assert.IsFalse(fmask.IsAnyBitSet);
Assert.IsFalse(fmask.IsEmpty);
}
public void VerifyInternalMaskArraySize()
{
// Make the mask 64 bits long.
var fmask = new FeatureMask(64);
Assert.AreEqual(1, ReflectionHelper.GetField(fmask, "m_maskCount"));
// Make the mask 65 bits long.
fmask = new FeatureMask(65);
Assert.AreEqual(2, ReflectionHelper.GetField(fmask, "m_maskCount"));
// Make the mask 128 bits long.
fmask = new FeatureMask(128);
Assert.AreEqual(2, ReflectionHelper.GetField(fmask, "m_maskCount"));
// Make the mask 129 bits long.
fmask = new FeatureMask(129);
Assert.AreEqual(3, ReflectionHelper.GetField(fmask, "m_maskCount"));
}
/// ------------------------------------------------------------------------------------
public DefineFeatureClassDlgBase(ClassListViewItem classInfo, ClassesDlg classDlg,
FeatureListViewBase lvFeatures, FeatureMask emptyMask)
: base(classInfo ?? new ClassListViewItem {
ClassType = SearchClassType.Articulatory
}, classDlg)
{
_lvFeatures = lvFeatures;
_lvFeatures.Load();
_lvFeatures.Dock = DockStyle.Fill;
_lvFeatures.Visible = true;
_lvFeatures.LabelEdit = false;
_lvFeatures.FeatureChanged += HandleFeatureChanged;
_lvFeatures.TabIndex = _textBoxClassName.TabIndex + 1;
_lvFeatures.CurrentMask = (m_classInfo.Mask ?? emptyMask);
SetupPhoneViewers();
SetupSplitters();
SetupRadioButtons();
UpdateCharacterViewers();
}
/// ---------------------------------------------------------------------------------
private void GetFeatureMasksFromItems(List <string> items)
{
var distinctiveFeatureNames = (from fname in items.Where(i => i.StartsWith("F:"))
where fname.StartsWith("+") || fname.StartsWith("-")
select fname).ToList();
if (distinctiveFeatureNames.Count > 0)
{
_distinctiveFeatureMask = App.BFeatureCache.GetMask(distinctiveFeatureNames);
}
var descriptiveFeatureNames = (from fname in items.Where(i => i.StartsWith("F:"))
where !fname.StartsWith("+") && !fname.StartsWith("-")
select fname).ToList();
if (descriptiveFeatureNames.Count > 0)
{
_descriptiveFeatureMask = App.BFeatureCache.GetMask(descriptiveFeatureNames);
}
items = items.Where(i => !i.StartsWith("F:")).ToList();
}
public void ContainsAll()
{
var fmask1 = new FeatureMask(100);
var fmask2 = new FeatureMask(100);
fmask1[45] = true;
fmask1[50] = true;
fmask1[75] = true;
Assert.IsFalse(fmask1.ContainsAll(fmask2));
fmask2[45] = true;
Assert.IsTrue(fmask1.ContainsAll(fmask2));
fmask2[50] = true;
Assert.IsTrue(fmask1.ContainsAll(fmask2));
fmask2[75] = true;
Assert.IsTrue(fmask1.ContainsAll(fmask2));
fmask2[90] = true;
Assert.IsFalse(fmask1.ContainsAll(fmask2));
}
/// ------------------------------------------------------------------------------------
private static void VerifyGroup_1(PatternGroup group, bool andMembers)
{
Assert.IsNotNull(group);
Assert.AreEqual((andMembers ? GroupType.And : GroupType.Or), group.GroupType);
Assert.AreEqual(2, group.Members.Count);
var groupMember = group.Members[0] as PatternGroupMember;
Assert.IsNotNull(groupMember);
Assert.AreEqual(MemberType.Binary, groupMember.MemberType);
Assert.AreEqual("+high", groupMember.Member);
FeatureMask mask = App.BFeatureCache.GetMask("+high");
Assert.IsTrue(groupMember.BMask.ContainsOneOrMore(mask));
groupMember = group.Members[1] as PatternGroupMember;
Assert.IsNotNull(groupMember);
Assert.AreEqual(MemberType.Articulatory, groupMember.MemberType);
Assert.AreEqual("dental", groupMember.Member);
// Check the ToString just for kicks.
Assert.AreEqual((andMembers ? "[[+high][dental]]" : "{[+high],[dental]}"), group.ToString());
}
/// ------------------------------------------------------------------------------------
protected override void CycleFeatureStateValue(FeatureItemInfo itemInfo, FeatureMask mask)
{
switch (itemInfo.TriStateValue)
{
case BinaryFeatureValue.None:
itemInfo.TriStateValue = BinaryFeatureValue.Plus;
mask[itemInfo.MinusBit] = false;
mask[itemInfo.PlusBit] = true;
break;
case BinaryFeatureValue.Plus:
itemInfo.TriStateValue = BinaryFeatureValue.Minus;
mask[itemInfo.MinusBit] = true;
mask[itemInfo.PlusBit] = false;
break;
default:
itemInfo.TriStateValue = BinaryFeatureValue.None;
mask[itemInfo.MinusBit] = false;
mask[itemInfo.PlusBit] = false;
break;
}
}
public void NotEqual()
{
var fmask1 = new FeatureMask(100);
var fmask2 = new FeatureMask(100);
fmask1[10] = true;
fmask1[20] = true;
fmask1[70] = true;
fmask1[90] = true;
var masks = (UInt64[])ReflectionHelper.GetField(fmask1, "m_masks");
Assert.IsTrue(masks[0] > 0);
Assert.IsTrue(masks[1] > 0);
fmask2[11] = true;
fmask2[21] = true;
fmask2[70] = true;
fmask2[90] = true;
masks = (UInt64[])ReflectionHelper.GetField(fmask2, "m_masks");
Assert.IsTrue(masks[0] > 0);
Assert.IsTrue(masks[1] > 0);
Assert.IsTrue(fmask1 != fmask2);
}
public void BitGetting()
{
var fmask = new FeatureMask(100);
fmask[45] = true;
Assert.IsTrue(fmask[45]);
fmask[45] = false;
Assert.IsFalse(fmask[45]);
fmask[60] = true;
Assert.IsTrue(fmask[60]);
fmask[60] = false;
Assert.IsFalse(fmask[60]);
fmask[80] = true;
Assert.IsTrue(fmask[80]);
fmask[80] = false;
Assert.IsFalse(fmask[80]);
fmask[75] = true;
Assert.IsTrue(fmask[75]);
fmask[75] = false;
Assert.IsFalse(fmask[75]);
}
/// ------------------------------------------------------------------------------------
private void HandleArticulatoryFeatureCheckChanged(object sender, FeatureMask newMask)
{
lblAFeatures.Text = m_lvAFeatures.FormattedFeaturesString;
}
public void PatternGroupTest_Complex()
{
var group = _parser.Parse("[[{a,e}{[+high],[dental]}][-dorsal]]", EnvironmentType.After);
Assert.IsNotNull(group);
Assert.AreEqual(group.GroupType, GroupType.And);
Assert.AreEqual(2, group.Members.Count);
// Verify the second member of the group.
var groupMember = group.Members[1] as PatternGroupMember;
Assert.IsNotNull(groupMember);
Assert.AreEqual(MemberType.Binary, groupMember.MemberType);
Assert.AreEqual("-dorsal", groupMember.Member);
FeatureMask mask = App.BFeatureCache.GetMask("-dorsal");
Assert.IsTrue(groupMember.BMask.ContainsOneOrMore(mask));
// Nested within the first group should be 2 other groups.
PatternGroup nestedGroup = group.Members[0] as PatternGroup;
Assert.IsNotNull(nestedGroup);
Assert.AreEqual(2, nestedGroup.Members.Count);
Assert.AreEqual(GroupType.And, nestedGroup.GroupType);
// Verify the first group nested in the nested group.
var nestedGroup1 = nestedGroup.Members[0] as PatternGroup;
Assert.IsNotNull(nestedGroup1);
Assert.AreEqual(2, nestedGroup1.Members.Count);
Assert.AreEqual(GroupType.Or, nestedGroup1.GroupType);
// Verify the first member of the nested, nested group.
groupMember = nestedGroup1.Members[0] as PatternGroupMember;
Assert.IsNotNull(groupMember);
Assert.AreEqual(MemberType.SinglePhone, groupMember.MemberType);
Assert.AreEqual("a", groupMember.Member);
// Verify the second member of the nested, nested group.
groupMember = nestedGroup1.Members[1] as PatternGroupMember;
Assert.IsNotNull(groupMember);
Assert.AreEqual(MemberType.SinglePhone, groupMember.MemberType);
Assert.AreEqual("e", groupMember.Member);
// Verify the second group nested in the nested group.
var nestedGroup2 = nestedGroup.Members[1] as PatternGroup;
Assert.IsNotNull(nestedGroup2);
Assert.AreEqual(2, nestedGroup2.Members.Count);
Assert.AreEqual(GroupType.Or, nestedGroup2.GroupType);
// Verify the first member of the nested, nested group.
groupMember = nestedGroup2.Members[0] as PatternGroupMember;
Assert.IsNotNull(groupMember);
Assert.AreEqual(MemberType.Binary, groupMember.MemberType);
Assert.AreEqual("+high", groupMember.Member);
mask = App.BFeatureCache.GetMask("+high");
Assert.IsTrue(groupMember.BMask.ContainsOneOrMore(mask));
// Verify the second member of the nested, nested group.
groupMember = nestedGroup2.Members[1] as PatternGroupMember;
Assert.IsNotNull(groupMember);
Assert.AreEqual(MemberType.Articulatory, groupMember.MemberType);
Assert.AreEqual("dental", groupMember.Member);
mask = App.AFeatureCache.GetMask("dental");
Assert.IsTrue(groupMember.AMask.ContainsOneOrMore(mask));
}
/// ------------------------------------------------------------------------------------
protected override void SetFeatureInfoStateFromMask(FeatureItemInfo itemInfo, FeatureMask mask)
{
if (mask[itemInfo.PlusBit])
{
itemInfo.TriStateValue = BinaryFeatureValue.Plus;
}
else if (mask[itemInfo.MinusBit])
{
itemInfo.TriStateValue = BinaryFeatureValue.Minus;
}
else
{
itemInfo.TriStateValue = BinaryFeatureValue.None;
}
}
