public virtual void TestCloneAttributes()
{
AttributeSource src = new AttributeSource();
TermAttribute termAtt = (TermAttribute)src.AddAttribute(typeof(TermAttribute));
TypeAttribute typeAtt = (TypeAttribute)src.AddAttribute(typeof(TypeAttribute));
termAtt.SetTermBuffer("TestTerm");
typeAtt.SetType("TestType");
AttributeSource clone = src.CloneAttributes();
System.Collections.IEnumerator it = clone.GetAttributeClassesIterator().GetEnumerator();
Assert.IsTrue(it.MoveNext());
Assert.AreEqual(typeof(TermAttribute), it.Current, "TermAttribute must be the first attribute");
Assert.IsTrue(it.MoveNext());
Assert.AreEqual(typeof(TypeAttribute), it.Current, "TypeAttribute must be the second attribute");
Assert.IsFalse(it.MoveNext(), "No more attributes");
TermAttribute termAtt2 = (TermAttribute)clone.GetAttribute(typeof(TermAttribute));
TypeAttribute typeAtt2 = (TypeAttribute)clone.GetAttribute(typeof(TypeAttribute));
Assert.IsFalse(ReferenceEquals(termAtt2, termAtt), "TermAttribute of original and clone must be different instances");
Assert.IsFalse(ReferenceEquals(typeAtt2, typeAtt), "TypeAttribute of original and clone must be different instances");
Assert.AreEqual(termAtt2, termAtt, "TermAttribute of original and clone must be equal");
Assert.AreEqual(typeAtt2, typeAtt, "TypeAttribute of original and clone must be equal");
}
public virtual void TestCloneAttributes()
{
AttributeSource src = new AttributeSource();
ITermAttribute termAtt = src.AddAttribute <ITermAttribute>();
ITypeAttribute typeAtt = src.AddAttribute <ITypeAttribute>();
termAtt.SetTermBuffer("TestTerm");
typeAtt.Type = "TestType";
var types = new List <Type>();
AttributeSource clone = src.CloneAttributes();
IEnumerator <Type> it = clone.GetAttributeTypesIterator().GetEnumerator();
Assert.IsTrue(it.MoveNext());
types.Add(it.Current);
Assert.IsTrue(it.MoveNext());
types.Add(it.Current);
Assert.IsFalse(it.MoveNext(), "No more attributes");
Assert.Contains(typeof(ITypeAttribute), types, "TypeAttribute must be present in attributes");
Assert.Contains(typeof(ITermAttribute), types, "TermAttribute must be present in attributes");
ITermAttribute termAtt2 = clone.GetAttribute <ITermAttribute>();
ITypeAttribute typeAtt2 = clone.GetAttribute <ITypeAttribute>();
Assert.IsFalse(ReferenceEquals(termAtt2, termAtt), "TermAttribute of original and clone must be different instances");
Assert.IsFalse(ReferenceEquals(typeAtt2, typeAtt), "TypeAttribute of original and clone must be different instances");
Assert.AreEqual(termAtt2, termAtt, "TermAttribute of original and clone must be equal");
Assert.AreEqual(typeAtt2, typeAtt, "TypeAttribute of original and clone must be equal");
}
public virtual void TestCloneAttributes()
{
AttributeSource src = new AttributeSource();
IFlagsAttribute flagsAtt = src.AddAttribute <IFlagsAttribute>();
ITypeAttribute typeAtt = src.AddAttribute <ITypeAttribute>();
flagsAtt.Flags = 1234;
typeAtt.Type = "TestType";
AttributeSource clone = src.CloneAttributes();
IEnumerator <Type> it = clone.GetAttributeClassesEnumerator();
it.MoveNext();
Assert.AreEqual(typeof(IFlagsAttribute), it.Current, "FlagsAttribute must be the first attribute");
it.MoveNext();
Assert.AreEqual(typeof(ITypeAttribute), it.Current, "TypeAttribute must be the second attribute");
Assert.IsFalse(it.MoveNext(), "No more attributes");
IFlagsAttribute flagsAtt2 = clone.GetAttribute <IFlagsAttribute>();
ITypeAttribute typeAtt2 = clone.GetAttribute <ITypeAttribute>();
Assert.AreNotSame(flagsAtt2, flagsAtt, "FlagsAttribute of original and clone must be different instances");
Assert.AreNotSame(typeAtt2, typeAtt, "TypeAttribute of original and clone must be different instances");
Assert.AreEqual(flagsAtt2, flagsAtt, "FlagsAttribute of original and clone must be equal");
Assert.AreEqual(typeAtt2, typeAtt, "TypeAttribute of original and clone must be equal");
// test copy back
flagsAtt2.Flags = 4711;
typeAtt2.Type = "OtherType";
clone.CopyTo(src);
Assert.AreEqual(4711, flagsAtt.Flags, "FlagsAttribute of original must now contain updated term");
Assert.AreEqual(typeAtt.Type, "OtherType", "TypeAttribute of original must now contain updated type");
// verify again:
Assert.AreNotSame(flagsAtt2, flagsAtt, "FlagsAttribute of original and clone must be different instances");
Assert.AreNotSame(typeAtt2, typeAtt, "TypeAttribute of original and clone must be different instances");
Assert.AreEqual(flagsAtt2, flagsAtt, "FlagsAttribute of original and clone must be equal");
Assert.AreEqual(typeAtt2, typeAtt, "TypeAttribute of original and clone must be equal");
}
public InputWindowToken(ShingleFilter outerInstance, AttributeSource attSource)
{
this.outerInstance = outerInstance;
this.attSource = attSource;
this.termAtt = attSource.GetAttribute<ICharTermAttribute>();
this.offsetAtt = attSource.GetAttribute<IOffsetAttribute>();
}
public override bool IncrementToken()
{
if (hasMoreTokensInClone)
{
int start = breaker.Current();
int end = breaker.Next();
if (end != BreakIterator.DONE)
{
clonedToken.CopyTo(this);
termAtt.CopyBuffer(clonedTermAtt.Buffer(), start, end - start);
if (hasIllegalOffsets)
{
offsetAtt.SetOffset(clonedOffsetAtt.StartOffset(), clonedOffsetAtt.EndOffset());
}
else
{
offsetAtt.SetOffset(clonedOffsetAtt.StartOffset() + start, clonedOffsetAtt.StartOffset() + end);
}
if (handlePosIncr)
{
posAtt.PositionIncrement = 1;
}
return true;
}
hasMoreTokensInClone = false;
}
if (!input.IncrementToken())
{
return false;
}
if (termAtt.Length == 0 || !Regex.IsMatch(termAtt.ToString().Substring(0, 1), @"\p{IsThai}"))
{
return true;
}
hasMoreTokensInClone = true;
// if length by start + end offsets doesn't match the term text then assume
// this is a synonym and don't adjust the offsets.
hasIllegalOffsets = offsetAtt.EndOffset() - offsetAtt.StartOffset() != termAtt.Length;
// we lazy init the cloned token, as in ctor not all attributes may be added
if (clonedToken == null)
{
clonedToken = CloneAttributes();
clonedTermAtt = clonedToken.GetAttribute<ICharTermAttribute>();
clonedOffsetAtt = clonedToken.GetAttribute<IOffsetAttribute>();
}
else
{
this.CopyTo(clonedToken);
}
// reinit CharacterIterator
charIterator.SetText(clonedTermAtt.Buffer(), 0, clonedTermAtt.Length);
breaker.SetText(new string(charIterator.Text, charIterator.Start, charIterator.Length));
int end2 = breaker.Next();
if (end2 != BreakIterator.DONE)
{
termAtt.Length = end2;
if (hasIllegalOffsets)
{
offsetAtt.SetOffset(clonedOffsetAtt.StartOffset(), clonedOffsetAtt.EndOffset());
}
else
{
offsetAtt.SetOffset(clonedOffsetAtt.StartOffset(), clonedOffsetAtt.StartOffset() + end2);
}
// position increment keeps as it is for first token
return true;
}
return false;
}