public Context(WrappedReducer <Keyin, Valuein, Keyout, Valueout> _enclosing, ReduceContext
<KEYIN, VALUEIN, KEYOUT, VALUEOUT> reduceContext)
: base(_enclosing)
{
this._enclosing = _enclosing;
this.reduceContext = reduceContext;
}
public void EmptyKeyValues()
{
ReduceContext<string, int> context = new ReduceContext<string, int>();
Assert.IsNotNull(context.Pairs);
Assert.AreEqual(0, context.Pairs.Count());
}
public ChainReduceContextImpl(ReduceContext <KEYIN, VALUEIN, KEYOUT, VALUEOUT> @base
, RecordWriter <KEYOUT, VALUEOUT> output, Configuration conf)
{
this.@base = @base;
this.rw = output;
this.conf = conf;
}
public void Reduce(ReduceContext context)
{
long sum = 0;
while (context.NextValue())
{
sum += Convert.ToInt64(encoding.GetString(context.InputValue));
}
context.Emit(context.InputKey, encoding.GetBytes(sum.ToString()));
}
public void EmitKeyValue()
{
ReduceContext<string, int> context = new ReduceContext<string, int>();
context.Emit("word", 1);
Assert.IsNotNull(context.Pairs);
Assert.AreEqual(1, context.Pairs.Count());
var pair = context.Pairs.First();
Assert.IsNotNull(pair);
Assert.AreEqual("word", pair.Key);
Assert.AreEqual(1, pair.Value);
}
public ReduceContext reduce()
{
ReduceContext _localctx = new ReduceContext(Context, State);
EnterRule(_localctx, 10, RULE_reduce);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 71; property();
State = 76;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la == COMMA)
{
{
{
State = 72; Match(COMMA);
State = 73; property();
}
}
State = 78;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public void EmitSaveKeyValues()
{
ReduceContext<string, int> context = new ReduceContext<string, int>();
context.Emit("a", 2);
context.Emit("word", 2);
context.Emit("is", 1);
Assert.IsNotNull(context.Pairs);
Assert.AreEqual(3, context.Pairs.Count());
var pair1 = context.Pairs.FirstOrDefault(p => p.Key == "word");
Assert.IsNotNull(pair1);
Assert.AreEqual(2, pair1.Value);
var pair2 = context.Pairs.FirstOrDefault(p => p.Key == "a");
Assert.IsNotNull(pair2);
Assert.AreEqual(2, pair2.Value);
var pair3 = context.Pairs.FirstOrDefault(p => p.Key == "is");
Assert.IsNotNull(pair3);
Assert.AreEqual(1, pair3.Value);
}
/// <summary>
/// Transforms the record.
/// </summary>
/// <param name="key">Record Number.</param>
/// <param name="values">The record (should only be one in the list).</param>
/// <param name="context">An instance of <see cref="Research.MapReduce.Core.
/// ReduceContext{K, V}"/>.</param>
/// <returns>The transformed record identified by the record number.</returns>
public IEnumerable <KeyValuePair <int, string> > Reduce(int key, IEnumerable <string> values, ReduceContext <int, string> context)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(values.First());
var record = ParseXml(xmlDoc);
RunRules(ref record);
string value = string.Format("<record><title>{0}</title><date>{1}</date><text>{2}</text></record>",
record.Title, record.DateAdded, record.Body);
yield return(new KeyValuePair <int, string>(key, value));
}
public override IReduceExpr Reduce(ReduceContext context) => new ReduceCastedArgExpr(position, Cast.TypeName);
IReduceExpr IReducer.Reduce(ReduceContext context) => new ReduceArgExpr(position);
public override IReduceExpr Reduce(ReduceContext context)
{
return(context.TryFindProductionType(position, out var type) ?
new ReduceCastedArgExpr(position, type !) :
new ReduceArgExpr(position));
}
public abstract IReduceExpr Reduce(ReduceContext context);
public abstract Reducer CreateReducer(ReduceContext context);
public virtual RecordWriter CreateRecordWriter(ReduceContext context)
{
return null;
}
/// <summary>
/// Create a reduce context that is based on ChainMapContext and the given
/// record writer
/// </summary>
private Reducer.Context CreateReduceContext <Keyin, Valuein, Keyout, Valueout>(RecordWriter
<KEYOUT, VALUEOUT> rw, ReduceContext <KEYIN, VALUEIN, KEYOUT, VALUEOUT> context,
Configuration conf)
{
ReduceContext <KEYIN, VALUEIN, KEYOUT, VALUEOUT> reduceContext = new ChainReduceContextImpl
<KEYIN, VALUEIN, KEYOUT, VALUEOUT>(context, rw, conf);
Reducer.Context reducerContext = new WrappedReducer <KEYIN, VALUEIN, KEYOUT, VALUEOUT
>().GetReducerContext(reduceContext);
return(reducerContext);
}
public override IReduceExpr Reduce(ReduceContext context) => context.TerminalsReduce();
/// <summary>
/// Empty method implementation since there is nothing to configure.
/// </summary>
/// <param name="context">An instance of <see cref="Research.MapReduce.Core.
/// ReduceContext{K, V}"/>.</param>
public void Configure(ReduceContext <int, string> context)
{
}
public IReduceExpr Reduce(ReduceContext context) =>
new ReduceMethodExpr("Tuple.Create", context.CreateArgs());
public IReduceExpr Reduce(ReduceContext context) => new ReduceArgExpr(0);
/// <summary>
/// A a wrapped
/// <see cref="Org.Apache.Hadoop.Mapreduce.Reducer.Context"/>
/// for custom implementations.
/// </summary>
/// <param name="reduceContext"><code>ReduceContext</code> to be wrapped</param>
/// <returns>a wrapped <code>Reducer.Context</code> for custom implementations</returns>
public virtual Reducer.Context GetReducerContext(ReduceContext <KEYIN, VALUEIN, KEYOUT
, VALUEOUT> reduceContext)
{
return(new WrappedReducer.Context(this, reduceContext));
}
public override Reducer CreateReducer(ReduceContext context)
{
return new WordCountReducer();
}
public IReduction Reduction(ReduceContext context) => new PushReduce(context.Id, context.ActionReduce());
private static void Reduce(string key, IList<int> values, ReduceContext<string, int> context)
{
int total = values.Sum();
context.Emit(key, total);
}
public IReduceExpr Reduce(ReduceContext context) => new ReduceNullExpr();
