import org.javatuples.Tuple; //导入依赖的package包/类
@Test
public void testCreateTupleFromVarArgs() {

    Pair<Integer, String> pair = Tuples.create(10, "foo");
    Assertions.assertThat((Iterable<?>) pair)
            .isEqualTo(new Pair<>(10, "foo"));

    Tuple tuple = Tuples.create(String.class, Long.class);
    Assertions.assertThat((Iterable<?>) tuple)
            .isInstanceOf(Pair.class);
    Assertions.assertThat(tuple.containsAll(String.class, Long.class))
            .isTrue();
    Assertions.assertThat(tuple.getSize())
            .isEqualTo(2);

    tuple = Tuples.create(String.class, Long.class, Float.class);
    Assertions.assertThat((Iterable<?>) tuple)
            .isInstanceOf(Triplet.class);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
public static <T extends Tuple> ILinkParameterValidatorFactory<T> fromConditionFactory(
		final IDetachableFactory<T, ? extends Condition> conditionFactory) {
	Args.notNull(conditionFactory, "conditionFactory");
	return new AbstractLinkParameterValidatorFactory<T>() {
		private static final long serialVersionUID = 1L;
		@Override
		public ILinkParameterValidator create(T parameters) {
			return new ConditionLinkParameterValidator(conditionFactory.create(parameters));
		}
		@Override
		public void detach() {
			super.detach();
			conditionFactory.detach();
		}
	};
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
private <TTarget, TLinkDescriptor> TLinkDescriptor createLinkDescriptor(
		IBuilderLinkDescriptorFactory<TTarget, TLinkDescriptor> linkDescriptorFactory,
		IModel<? extends TTarget> targetModel) {
	return mapperLinkDescriptorFactory(
			linkDescriptorFactory,
			ModelFactories.<IModel<? extends TTarget>, Tuple>constant(targetModel),
			ImmutableList.<Integer>of()
			)
			.create(new Tuple() {
				private static final long serialVersionUID = 1L;
				@Override
				public int getSize() {
					return 0;
				}
			});
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
private String formatTuple(Tuple tuple) {
    StringBuffer buf = new StringBuffer();
    int size = tuple.getSize();
    for (int i = 0; i < size; i ++) {
        if (i != 0) {
            buf.append(';');
        }

        Object obj = tuple.getValue(i);
        if (obj instanceof Tuple) {
            buf.append(formatTuple((Tuple)obj));
        } else {
            buf.append(tuple.getValue(i));
        }
    }
    return buf.toString();
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
/**
 * Execute this marvelous code, going from the Content to Users.
 *
 * Internally uses the RecommendationForNewUser class to build the recommendation as we want, pretty and
 * simple.
 *
 * @param vertex
 * @param messenger
 * @param memory
 */
@Override
public void execute(Vertex vertex, Messenger<Tuple> messenger, Memory memory) {
  try {
    HadoopQueryRunner runner = new HadoopQueryRunner(g, vertex.value(Schema.USER_NAME));
    GraphTraversal<Vertex, Edge> t = g.V(vertex.id()).inE(Schema.FOLLOWS);

    while(t.hasNext()) {
      Edge followsEdge = t.next();

      long commonFollowedUsers = runner.countCommonFollowedUsers(followsEdge.outVertex());
      long postsPerDaySince = runner.countPostsPerDaySince(sevenDaysAgo);
      long weight = (3 * commonFollowedUsers + postsPerDaySince) / 4;
      if(min == -10 || min > weight) {
        min = (int) weight;
      }
      if(max < weight) {
        max = (int) weight;
      }
      count++;

      followsEdge.property(CreateWeightIndex.WEIGHT, weight);
    }
  } catch (Exception e){
    e.printStackTrace();
    LOGGER.error("while processing " + vertex.id() + ": " + e.getClass().toString() + "(" + e.getMessage() + ")");
    return;
  }
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
@SuppressWarnings({"CloneDoesntDeclareCloneNotSupportedException", "CloneDoesntCallSuperClone"})
public VertexProgram<Tuple> clone() {
  LOGGER.info("clone");
  try {
    return (ComputeWeightVertexProgram) super.clone();
  } catch (final CloneNotSupportedException e) {
    throw new IllegalStateException(e.getMessage(), e);
  }
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
public HBaseVertex(HBaseGraph graph, Object id, String label, Long createdAt, Long updatedAt,
                   Map<String, Object> properties, boolean propertiesFullyLoaded) {
    super(graph, id, label, createdAt, updatedAt, properties, propertiesFullyLoaded);

    if (graph != null) {
        this.edgeCache = CacheBuilder.<Tuple, List<Edge>>newBuilder()
                .maximumSize(graph.configuration().getRelationshipCacheMaxSize())
                .expireAfterAccess(graph.configuration().getRelationshipCacheTtlSecs(), TimeUnit.SECONDS)
                .build();
    }
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
@Override
public void execute(final Vertex sourceVertex, final Messenger<Tuple> messenger, final Memory memory) {
    try {
        executeInternal(sourceVertex, messenger, memory);
    } catch (Exception e) {
        if (graph.features().graph().supportsTransactions()) {
            graph.tx().rollback();
        }
        throw e;
    }
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
private <TTarget, TLinkDescriptor> ITwoParameterLinkDescriptorMapper<TLinkDescriptor, TParam1, TParam2>
		createMapper(IBuilderLinkDescriptorFactory<TTarget, TLinkDescriptor> linkDescriptorFactory,
				IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>> pageClassFactory,
				List<Integer> parameterIndices) {
	return new CoreTwoParameterLinkDescriptorMapperImpl<>(
			mapperLinkDescriptorFactory(
					linkDescriptorFactory,
					pageClassFactory, parameterIndices
			)
	);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
private <TTarget, TLinkDescriptor> IFourParameterLinkDescriptorMapper<
		TLinkDescriptor,
		TParam1, TParam2, TParam3, TParam4
		> createMapper(IBuilderLinkDescriptorFactory<TTarget, TLinkDescriptor> linkDescriptorFactory,
				IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>> pageClassFactory,
				List<Integer> parameterIndices) {
	return new CoreFourParameterLinkDescriptorMapperImpl<>(
			mapperLinkDescriptorFactory(
					linkDescriptorFactory,
					pageClassFactory, parameterIndices
			)
	);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
private <TTarget, TLinkDescriptor> IThreeParameterLinkDescriptorMapper<TLinkDescriptor, TParam1, TParam2, TParam3>
		createMapper(IBuilderLinkDescriptorFactory<TTarget, TLinkDescriptor> linkDescriptorFactory,
				IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>> pageClassFactory,
				List<Integer> parameterIndices) {
	return new CoreThreeParameterLinkDescriptorMapperImpl<>(
			mapperLinkDescriptorFactory(
					linkDescriptorFactory,
					pageClassFactory, parameterIndices
			)
	);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
private <TTarget, TLinkDescriptor> IOneParameterLinkDescriptorMapper<TLinkDescriptor, TParam1>
		createMapper(IBuilderLinkDescriptorFactory<TTarget, TLinkDescriptor> linkDescriptorFactory,
				IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>> pageClassFactory,
				List<Integer> parameterIndices) {
	return new CoreOneParameterLinkDescriptorMapperImpl<>(
			mapperLinkDescriptorFactory(
					linkDescriptorFactory, 
					pageClassFactory, parameterIndices 
			)
	);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
protected final <TTarget, TLinkDescriptor> IBuilderMapperLinkDescriptorFactory<TLinkDescriptor>
		mapperLinkDescriptorFactory(
				IBuilderLinkDescriptorFactory<TTarget, TLinkDescriptor> linkDescriptorFactory,
				IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>> targetFactory,
				List<Integer> targetFactoryParameterIndices
		) {
	return linkDescriptorFactory.forMapper(
			Pair.with(targetFactory, targetFactoryParameterIndices),
			mappingEntryBuilders, validatorFactories
	);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
public BuilderMapperLinkDescriptorFactory(
		IBuilderLinkDescriptorFactory<TTarget, TLinkDescriptor> linkDescriptorFactory,
		Pair<
				? extends IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>>,
				? extends List<Integer>
				> targetFactory,
		Map<LinkParameterMappingEntryBuilder<?>, List<Integer>> mappingEntryBuilders,
		Map<ILinkParameterValidatorFactory<?>, List<Integer>> validatorFactories) {
	super();
	this.linkDescriptorFactory = linkDescriptorFactory;
	this.targetFactory = targetFactory;
	this.mappingEntryBuilders = mappingEntryBuilders;
	this.validatorFactories = validatorFactories;
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
private static Tuple extractParameters(Tuple parameters, List<Integer> indices) {
	int size = indices.size();
	switch (size) {
	case 0:
		return null;
	case 1:
		return Unit.with(parameters.getValue(indices.get(0)));
	case 2:
		return Pair.with(
				parameters.getValue(indices.get(0)),
				parameters.getValue(indices.get(1))
		);
	case 3:
		return Triplet.with(
				parameters.getValue(indices.get(0)),
				parameters.getValue(indices.get(1)),
				parameters.getValue(indices.get(2))
		);
	case 4:
		return Quartet.with(
				parameters.getValue(indices.get(0)),
				parameters.getValue(indices.get(1)),
				parameters.getValue(indices.get(2)),
				parameters.getValue(indices.get(3))
		);
	default:
		throw new IllegalStateException("Only Unit, Pair, Triplet and Quartet parameters are supported for ILinkParameterMappingEntryFactory");
	}
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
IBuilderMapperLinkDescriptorFactory<TLinkDescriptor> forMapper(
		Pair<
				? extends IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>>,
				? extends List<Integer>
				> targetFactory,
		Map<LinkParameterMappingEntryBuilder<?>, List<Integer>> mappingEntryBuilders,
		Map<ILinkParameterValidatorFactory<?>, List<Integer>> validatorFactories
);
 

import org.javatuples.Tuple; //导入依赖的package包/类
@Override
public IBuilderMapperLinkDescriptorFactory<TLinkDescriptor> forMapper(
		Pair<
				? extends IDetachableFactory<? extends Tuple, ? extends IModel<? extends TTarget>>,
				? extends List<Integer>
				> targetFactory,
		Map<LinkParameterMappingEntryBuilder<?>, List<Integer>> mappingEntryBuilders,
		Map<ILinkParameterValidatorFactory<?>, List<Integer>> validatorFactories) {
	return new BuilderMapperLinkDescriptorFactory<>(
			this, targetFactory, mappingEntryBuilders, validatorFactories
	);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
protected static <T extends Tuple> T serializeAndDeserialize(T tuple) {
	for (Object value : tuple) {
		if (value instanceof IDetachable) {
			((IDetachable)value).detach();
		}
	}
	return doSerializeAndDeserialize(tuple);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
<T extends Tuple, D> Assembler<T, D> tupleAssemblerOf(Class<? extends AggregateRoot<?>>[] aggregateRootTuple,
        Class<D> dto) {
    if (assemblerQualifierClass != null) {
        return assemblerRegistry.getTupleAssembler(aggregateRootTuple, dto, assemblerQualifierClass);
    } else if (assemblerQualifier != null) {
        return assemblerRegistry.getTupleAssembler(aggregateRootTuple, dto, assemblerQualifier);
    }
    return assemblerRegistry.getTupleAssembler(aggregateRootTuple, dto);
}
 

import org.javatuples.Tuple; //导入依赖的package包/类
/**
 * Builds a tuple from a collection of objects.
 *
 * @param objects the collection of objects (size must be less or equal than 10).
 * @param <T>     the tuple type.
 * @return the constructed tuple.
 */
@SuppressWarnings("unchecked")
public static <T extends Tuple> T create(Collection<?> objects) {
    Class<? extends Tuple> tupleClass = classOfTuple(objects.size());
    try {
        return (T) tupleClass.getMethod("fromCollection", Collection.class)
                .invoke(null, objects);
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
        throw BusinessException.wrap(e, BusinessErrorCode.UNABLE_TO_CREATE_TUPLE);
    }
}