/// <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 type info 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); } } }