Job {@link Summarizer} class setting.
@param clazz {@link Summarizer} class
@param combine If true is set the combiner in the Summarizer
@return this
191207
public SimpleJob setSummarizer(Class<? extends Reducer<Key, Value, Key, Value>> clazz,
                                   boolean combine) {
        return setSummarizer(clazz, combine, DEFAULT_COMBAIN_CACHE);
    }
267267
@Override
	public void prepare() throws Exception {
		final TaskConfig config = this.taskContext.getTaskConfig();
		this.strategy = config.getDriverStrategy();
		
		if (strategy == DriverStrategy.ALL_GROUP_COMBINE) {
			if (!(this.taskContext.getStub() instanceof GenericCombine)) {
				throw new Exception("Using combiner on a UDF that does not implement the combiner interface " + GenericCombine.class.getName());
			}
		}
		else if (strategy != DriverStrategy.ALL_GROUP_REDUCE) {
			throw new Exception("Unrecognized driver strategy for AllGroupReduce driver: " + config.getDriverStrategy().name());
		}
		this.serializer = this.taskContext.<IT>getInputSerializer(0).getSerializer();
		this.input = this.taskContext.getInput(0);
	}
993765
@Override
	public <E> void serializeCollection(Collection<E> collection, Class<E> objectClazz, File output) {
		if (collection == null)
			return;

		try (SerializerWrapper serializer = createSerializer(output)) {
			mapperFor(objectClazz).serializeCollection(this, serializer, collection);
		} catch (Exception e) {
			e.printStackTrace();
			throw new KriptonRuntimeException(e);
		}
	}
1069507
public SimpleJob setBigJoin(String[] masterLabels, String masterColumn, String dataColumn,
                                String masterPath, String separator) {
        if (natural) {
            throw new RuntimeException("Not supported big join for natural job.");
        }

        bigJoin = true;
        conf.setInt(READER_TYPE, SINGLE_COLUMN_JOIN_READER);
        conf.setStrings(MASTER_LABELS, masterLabels);
        conf.set(JOIN_MASTER_COLUMN, masterColumn);
        conf.set(JOIN_DATA_COLUMN, dataColumn);
        conf.set(MASTER_PATH, masterPath);
        conf.set(MASTER_SEPARATOR, separator);
        return this;
    }
1011189
@Nonnull
  public <T> List<T> toObjects(@Nonnull Class<T> clazz) {
    List<T> results = new ArrayList<>();

    for (DocumentSnapshot documentSnapshot : getDocuments()) {
      results.add(CustomClassMapper.convertToCustomClass(documentSnapshot.getData(), clazz));
    }

    return results;
  }
803031
public CombineOutput combine(final List<ShareInfo> usetheseshares)
    {
        CombineOutput ret = null;

        sanityCheckPublicInfos(publicInfo, usetheseshares);

        if (true)
        {
            println(" SOLVING USING THESE SHARES, mod=" + publicInfo.getPrimeModulus());
            for (ShareInfo si : usetheseshares)
            {
                println("   " + si.share);
            }
            println("end SOLVING USING THESE SHARES");
        }
        if (publicInfo.getK() > usetheseshares.size())
        {
            throw new SecretShareException("Must have " + publicInfo.getK() +
                                           " shares to solve.  Only provided " +
                                           usetheseshares.size());
        }

        checkForDuplicatesOrThrow(usetheseshares);


        final int size = publicInfo.getK();
        BigInteger[] xarray = new BigInteger[size];
        BigInteger[] fofxarray = new BigInteger[size];
        for (int i = 0, n = size; i < n; i++)
        {
            xarray[i] = usetheseshares.get(i).getXasBigInteger();
            fofxarray[i] = usetheseshares.get(i).getShare();
        }
        EasyLinearEquation ele =
            EasyLinearEquation.createForPolynomial(xarray, fofxarray);
        if (publicInfo.getPrimeModulus() != null)
        {
            ele = ele.createWithPrimeModulus(publicInfo.getPrimeModulus());
        }

        BigInteger solveSecret = null;

        if (false)
        {
            EasyLinearEquation.EasySolve solve = ele.solve();

            solveSecret = solve.getAnswer(1);
        }
        else
        {
            BigInteger[][] matrix = ele.getMatrix();
            NumberMatrix.print("SS.java", matrix, out);
            println("CVT matrix.height=" + matrix.length + " width=" + matrix[0].length);
            BigRationalMatrix brm = BigRationalMatrix.create(matrix);
            NumberMatrix.print("SS.java brm", brm.getArray(), out);

            NumberSimplex<BigRational> simplex = new NumberSimplex<BigRational>(brm, 0);
            simplex.initForSolve(out);
            simplex.solve(out);

            BigRational answer = simplex.getAnswer(0);
            if (publicInfo.getPrimeModulus() != null)
            {
                solveSecret = answer.computeBigIntegerMod(publicInfo.getPrimeModulus());
            }
            else
            {
                solveSecret = answer.bigIntegerValue();
            }
        }

        if (publicInfo.getPrimeModulus() != null)
        {
            solveSecret = solveSecret.mod(publicInfo.getPrimeModulus());
        }
        ret = new CombineOutput(solveSecret);


        return ret;
    }
1017896
public static <T> Clazz<T> Clazz( Class<T> clazz )
	{
		return impl.Clazz( clazz );
	}
232412
public static JoinTable getJoinTable(Class<?> clazz) {
		Class<?> curClass = clazz;
		while (curClass != null) {
			JoinTable joinTable = curClass.getAnnotation(JoinTable.class);
			if(joinTable != null) {
				return joinTable;
			}
			curClass = curClass.getSuperclass();
		}
		
		return null;
	}
485892
public SimpleJob setSummarizer(Class<? extends Reducer<Key, Value, Key, Value>> clazz) {
        return setSummarizer(clazz, false, 0);
    }
937205
public @Nonnull Result combine(@Nonnull Result that) {
        if(this.ordinal < that.ordinal)
            return that;
        else
            return this;
    }
465180
@Override
    public JobReport mergerReports(JobReport... jobReports) {

        List<Long> startTimes = new ArrayList<>();
        List<Long> endTimes = new ArrayList<>();
        List<String> jobNames = new ArrayList<>();

        JobParameters parameters = new JobParameters();
        JobMetrics metrics = new JobMetrics();
        JobReport finalJobReport = new JobReport();
        finalJobReport.setParameters(parameters);
        finalJobReport.setMetrics(metrics);
        finalJobReport.setStatus(JobStatus.COMPLETED);

        for (JobReport jobReport : jobReports) {
            startTimes.add(jobReport.getMetrics().getStartTime());
            endTimes.add(jobReport.getMetrics().getEndTime());
            calculateReadRecords(finalJobReport, jobReport);
            calculateWrittenRecords(finalJobReport, jobReport);
            calculateFilteredRecords(finalJobReport, jobReport);
            calculateErrorRecords(finalJobReport, jobReport);
            setStatus(finalJobReport, jobReport);
            jobNames.add(jobReport.getJobName());
            finalJobReport.setSystemProperties(jobReport.getSystemProperties()); // works unless partial jobs are run in different JVMs..
        }

        //merge results
        finalJobReport.getMetrics().setStartTime(Collections.min(startTimes));
        finalJobReport.getMetrics().setEndTime(Collections.max(endTimes));

        // set name
        finalJobReport.setJobName(concatenate(jobNames));

        return finalJobReport;
    }
399740
public <T> void addMapper(Class<T> clazz, StringMapper<T> mapper) {
		addParser(clazz, mapper);
		mappers.put(clazz, mapper);
	}
477172
public void setLabelingJobSummaryList(java.util.Collection<LabelingJobForWorkteamSummary> labelingJobSummaryList) {
        if (labelingJobSummaryList == null) {
            this.labelingJobSummaryList = null;
            return;
        }

        this.labelingJobSummaryList = new java.util.ArrayList<LabelingJobForWorkteamSummary>(labelingJobSummaryList);
    }
243203
public void combine(LongSummaryStatistics other) {
        count += other.count;
        sum += other.sum;
        min = Math.min(min, other.min);
        max = Math.max(max, other.max);
    }
552131
public InjectorBuilder combineWith(Module ... modules) {
        List<Module> m = new ArrayList<>();
        m.add(module);
        m.addAll(Arrays.asList(modules));
        this.module = Modules.combine(m);
        return this;
    }
911017
public Scheduler schedule(Setting cronSetting) {
		if (CollectionUtil.isNotEmpty(cronSetting)) {
			String group;
			for (Entry<String, LinkedHashMap<String, String>> groupedEntry : cronSetting.getGroupedMap().entrySet()) {
				group = groupedEntry.getKey();
				for (Entry<String, String> entry : groupedEntry.getValue().entrySet()) {
					String jobClass = entry.getKey();
					if (StrUtil.isNotBlank(group)) {
						jobClass = group + CharUtil.DOT + jobClass;
					}
					final String pattern = entry.getValue();
					StaticLog.debug("Load job: {} {}", pattern, jobClass);
					try {
						schedule(pattern, new InvokeTask(jobClass));
					} catch (Exception e) {
						throw new CronException(e, "Schedule [{}] [{}] error!", pattern, jobClass);
					}
				}
			}
		}
		return this;
	}
1080970
public static Field getJoinLeftTable(Class<?> clazz) {
		if(clazz == null) {
			throw new NoJoinTableMemberException("clazz is null");
		}
		List<Field> result = _getAnnotationColumns(clazz, JoinLeftTable.class);
		if(result == null || result.isEmpty()) {
			throw new NoJoinTableMemberException("class " + clazz.getName()
			    + " does not have @JoinLeftTable field");
		}
		return result.get(0);
	}