/// <summary>Populate Tuple from iterators.</summary>
/// <remarks>
/// Populate Tuple from iterators.
/// It should be the case that, given iterators i_1...i_n over values from
/// sources s_1...s_n sharing key k, repeated calls to next should yield
/// I x I.
/// </remarks>
/// <exception cref="System.IO.IOException"/>
protected internal virtual bool Next(TupleWritable val)
{
// No static typeinfo on Tuples
if (this.first)
{
int i = -1;
for (this.pos = 0; this.pos < this.iters.Length; ++this.pos)
{
if (this.iters[this.pos].HasNext() && this.iters[this.pos].Next((X)val.Get(this.pos
)))
{
i = this.pos;
val.SetWritten(i);
}
}
this.pos = i;
this.first = false;
if (this.pos < 0)
{
this.Clear();
return(false);
}
return(true);
}
while (0 <= this.pos && !(this.iters[this.pos].HasNext() && this.iters[this.pos].
Next((X)val.Get(this.pos))))
{
--this.pos;
}
if (this.pos < 0)
{
this.Clear();
return(false);
}
val.SetWritten(this.pos);
for (int i_1 = 0; i_1 < this.pos; ++i_1)
{
if (this.iters[i_1].Replay((X)val.Get(i_1)))
{
val.SetWritten(i_1);
}
}
while (this.pos + 1 < this.iters.Length)
{
++this.pos;
this.iters[this.pos].Reset();
if (this.iters[this.pos].HasNext() && this.iters[this.pos].Next((X)val.Get(this.pos
)))
{
val.SetWritten(this.pos);
}
}
return(true);
}
/// <exception cref="System.Exception"/>
public virtual void TestIterable()
{
Random r = new Random();
Writable[] writs = new Writable[] { new BooleanWritable(r.NextBoolean()), new FloatWritable
(r.NextFloat()), new FloatWritable(r.NextFloat()), new IntWritable(r.Next()), new
LongWritable(r.NextLong()), new BytesWritable(Sharpen.Runtime.GetBytesForString(
"dingo")), new LongWritable(r.NextLong()), new IntWritable(r.Next()), new BytesWritable
(Sharpen.Runtime.GetBytesForString("yak")), new IntWritable(r.Next()) };
TupleWritable t = new TupleWritable(writs);
for (int i = 0; i < 6; ++i)
{
t.SetWritten(i);
}
VerifIter(writs, t, 0);
}
/// <summary>Replay the last Tuple emitted.</summary>
/// <exception cref="System.IO.IOException"/>
public virtual bool Replay(TupleWritable val)
{
// No static typeinfo on Tuples
// The last emitted tuple might have drawn on an empty source;
// it can't be cleared prematurely, b/c there may be more duplicate
// keys in iterator positions < pos
System.Diagnostics.Debug.Assert(!this.first);
bool ret = false;
for (int i = 0; i < this.iters.Length; ++i)
{
if (this.iters[i].Replay((X)val.Get(i)))
{
val.SetWritten(i);
ret = true;
}
}
return(ret);
}
/// <exception cref="System.Exception"/>
public virtual void TestWideWritable2()
{
Writable[] manyWrits = MakeRandomWritables(71);
TupleWritable sTuple = new TupleWritable(manyWrits);
for (int i = 0; i < manyWrits.Length; i++)
{
sTuple.SetWritten(i);
}
ByteArrayOutputStream @out = new ByteArrayOutputStream();
sTuple.Write(new DataOutputStream(@out));
ByteArrayInputStream @in = new ByteArrayInputStream(@out.ToByteArray());
TupleWritable dTuple = new TupleWritable();
dTuple.ReadFields(new DataInputStream(@in));
NUnit.Framework.Assert.IsTrue("Failed to write/read tuple", sTuple.Equals(dTuple)
);
NUnit.Framework.Assert.AreEqual("All tuple data has not been read from the stream"
, -1, @in.Read());
}
private TupleWritable MakeTuple(Writable[] writs)
{
Writable[] sub1 = new Writable[] { writs[1], writs[2] };
Writable[] sub3 = new Writable[] { writs[4], writs[5] };
Writable[] sub2 = new Writable[] { writs[3], new TupleWritable(sub3), writs[6] };
Writable[] vals = new Writable[] { writs[0], new TupleWritable(sub1), new TupleWritable
(sub2), writs[7], writs[8], writs[9] };
// [v0, [v1, v2], [v3, [v4, v5], v6], v7, v8, v9]
TupleWritable ret = new TupleWritable(vals);
for (int i = 0; i < 6; ++i)
{
ret.SetWritten(i);
}
((TupleWritable)sub2[1]).SetWritten(0);
((TupleWritable)sub2[1]).SetWritten(1);
((TupleWritable)vals[1]).SetWritten(0);
((TupleWritable)vals[1]).SetWritten(1);
for (int i_1 = 0; i_1 < 3; ++i_1)
{
((TupleWritable)vals[2]).SetWritten(i_1);
}
return(ret);
}
/// <summary>Tests that we can write more than 64 values.</summary>
/// <exception cref="System.Exception"/>
public virtual void TestWideTupleBoundary()
{
Text emptyText = new Text("Should not be set written");
Writable[] values = new Writable[65];
Arrays.Fill(values, emptyText);
values[64] = new Text("Should be the only value set written");
TupleWritable tuple = new TupleWritable(values);
tuple.SetWritten(64);
for (int pos = 0; pos < tuple.Size(); pos++)
{
bool has = tuple.Has(pos);
if (pos == 64)
{
NUnit.Framework.Assert.IsTrue(has);
}
else
{
NUnit.Framework.Assert.IsFalse("Tuple position is incorrectly labelled as set: "
+ pos, has);
}
}
}
/// <exception cref="System.Exception"/>
public virtual void TestWideTuple2()
{
Text emptyText = new Text("Should be empty");
Writable[] values = new Writable[64];
Arrays.Fill(values, emptyText);
values[9] = new Text("Number 9");
TupleWritable tuple = new TupleWritable(values);
tuple.SetWritten(9);
for (int pos = 0; pos < tuple.Size(); pos++)
{
bool has = tuple.Has(pos);
if (pos == 9)
{
NUnit.Framework.Assert.IsTrue(has);
}
else
{
NUnit.Framework.Assert.IsFalse("Tuple position is incorrectly labelled as set: "
+ pos, has);
}
}
}
