下面列出了org.apache.commons.lang3.tuple.MutablePair#getRight ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public Map<String, MutablePair<String, CommentsNodeImpl>> copyMap(CommentsNodeImpl parent)
{
Map<String, MutablePair<String, CommentsNodeImpl>> result = new HashMap<>(this.dataMap.size());
for (Entry<String, MutablePair<String, CommentsNodeImpl>> entry : this.dataMap.entrySet())
{
String keyToCpy = entry.getKey();
MutablePair<String, CommentsNodeImpl> valueToCpy = entry.getValue();
CommentsNodeImpl nodeToCpy = valueToCpy.getRight();
CommentsNodeImpl copiedNode;
if (nodeToCpy == null)
{
copiedNode = null;
}
else
{
copiedNode = new CommentsNodeImpl(parent);
copiedNode.dataMap.putAll(nodeToCpy.copyMap(parent));
}
MutablePair<String, CommentsNodeImpl> copied = new MutablePair<>(valueToCpy.getLeft(), copiedNode);
result.put(keyToCpy, copied);
}
return result;
}
@Override
public void trim()
{
for (Iterator<Entry<String, MutablePair<String, CommentsNodeImpl>>> iterator = this.dataMap.entrySet().iterator(); iterator.hasNext(); )
{
Entry<String, MutablePair<String, CommentsNodeImpl>> entry = iterator.next();
MutablePair<String, CommentsNodeImpl> value = entry.getValue();
CommentsNodeImpl right = value.getRight();
if (right != null)
{
right.trim();
}
if (((right == null) || right.dataMap.isEmpty()) && (value.getLeft() == null))
{
iterator.remove();
continue;
}
if (right == null)
{
continue;
}
right.trim();
}
}
@Override
public CommentsNodeImpl getNode(String path)
{
MutablePair<String, CommentsNodeImpl> nodePair = this.dataMap.get(path);
CommentsNodeImpl node = (nodePair == null) ? null : nodePair.getRight();
if (node == null)
{
MutablePair<String, CommentsNodeImpl> anyNodePair = this.dataMap.get(ANY);
node = (anyNodePair == null) ? null : anyNodePair.getRight();
if (node == null)
{
CommentsNodeImpl commentsNode = new CommentsNodeImpl(this);
if (nodePair != null)
{
nodePair.setRight(commentsNode);
}
else
{
this.dataMap.put(path, new MutablePair<>(null, commentsNode));
}
return commentsNode;
}
return node;
}
return node;
}
/**
* keep the one with the most information if both are deletions.
*
* @param d1 the most one
* @param d2 the elder one
* @return the most one
*/
private MutablePair<DeltaType, KubernetesObject> isDeletionDup(
MutablePair<DeltaType, KubernetesObject> d1, MutablePair<DeltaType, KubernetesObject> d2) {
if (!d1.getLeft().equals(DeltaType.Deleted) || !d2.getLeft().equals(DeltaType.Deleted)) {
return null;
}
Object obj = d2.getRight();
if (obj instanceof DeletedFinalStateUnknown) {
return d1;
}
return d2;
}
public Optional<MutablePair<V1Event, V1Patch>> correlate(V1Event event) {
MutablePair<V1Event, String> aggregatedResult = this.aggregator.aggregate(event);
V1Event aggregatedEvent = aggregatedResult.getLeft();
String cacheKey = aggregatedResult.getRight();
MutablePair<V1Event, V1Patch> observeResult = this.logger.observe(aggregatedEvent, cacheKey);
if (!this.filter.test(event)) {
return Optional.empty();
}
return Optional.of(observeResult);
}
public synchronized MutablePair<V1Event, String> aggregate(V1Event event) {
DateTime now = DateTime.now();
MutablePair<String, String> aggregatedKeys = keyFunc.apply(event);
String aggregatedKey = aggregatedKeys.getLeft();
String localKey = aggregatedKeys.getRight();
AggregatedRecord record;
try {
record = this.spammingCache.get(aggregatedKey, AggregatedRecord::new);
} catch (ExecutionException e) {
throw new IllegalStateException(e);
}
record.lastTimestamp = now;
record.localKeys.add(localKey);
if (record.localKeys.size() < this.maxEvents) {
this.spammingCache.put(aggregatedKey, record);
return new MutablePair<>(event, EventUtils.getEventKey(event));
}
record.localKeys.remove(record.localKeys.stream().findAny().get()); // remove any keys
V1Event aggregatedEvent =
new V1EventBuilder(event)
.withMetadata(
new V1ObjectMetaBuilder()
.withName(EventUtils.generateName(event.getInvolvedObject().getName(), now))
.withNamespace(event.getInvolvedObject().getNamespace())
.build())
.withCount(1)
.withFirstTimestamp(now)
.withLastTimestamp(now)
.withMessage(this.messageFunc.apply(event))
.build();
this.spammingCache.put(aggregatedKey, record);
return new MutablePair<>(aggregatedEvent, aggregatedKey);
}
public static VoxelShape getShape(Cuboid6 cuboid) {
VoxelShape shape = cuboidToShapeCache.getIfPresent(cuboid);
if (shape == null) {
shape = VoxelShapes.create(cuboid.min.x, cuboid.min.y, cuboid.min.z, cuboid.max.x, cuboid.max.y, cuboid.max.z);
cuboidToShapeCache.put(cuboid, shape);
MutablePair<AxisAlignedBB, Cuboid6> entry = getReverse(shape);
if (entry.getRight() == null) {
entry.setRight(cuboid);
}
}
return shape;
}
public static Cuboid6 getCuboid(VoxelShape shape) {
MutablePair<AxisAlignedBB, Cuboid6> entry = getReverse(shape);
if (entry.getRight() == null) {
entry.setRight(new Cuboid6(// I hope this is okay, don't want to rely on AABB cache.
shape.getStart(Direction.Axis.X), shape.getStart(Direction.Axis.Y), shape.getStart(Direction.Axis.Z),//
shape.getEnd(Direction.Axis.X), shape.getEnd(Direction.Axis.Y), shape.getEnd(Direction.Axis.Z)//
));
}
return entry.getRight();
}
@SuppressWarnings("unchecked")
Map<String, MutablePair<String, ?>> buildMap()
{
Map<String, MutablePair<String, ?>> resultMap = new LinkedHashMap<>(this.dataMap.size());
for (Entry<String, MutablePair<String, CommentsNodeImpl>> entry : this.dataMap.entrySet())
{
MutablePair<String, CommentsNodeImpl> value = entry.getValue();
CommentsNodeImpl right = value.getRight();
String left = value.getLeft();
if ((right == null) && (left == null))
{
continue;
}
Map<String, MutablePair<String, ?>> rightMap = null;
if (right != null)
{
rightMap = right.buildMap();
if (rightMap.isEmpty())
{
rightMap = null;
if (left == null)
{
continue;
}
}
}
resultMap.put(entry.getKey(), new MutablePair<>(left, rightMap));
}
return resultMap;
}
@Override
public void join(CommentsNode toJoin_)
{
if (toJoin_ instanceof EmptyCommentsNode)
{
return;
}
if (! (toJoin_ instanceof CommentsNodeImpl))
{
throw new IllegalArgumentException("Can't join to unknown node type.");
}
CommentsNodeImpl toJoin = (CommentsNodeImpl) toJoin_;
for (Entry<String, MutablePair<String, CommentsNodeImpl>> entry : toJoin.dataMap.entrySet())
{
String nodeKey = entry.getKey();
MutablePair<String, CommentsNodeImpl> pair = entry.getValue();
String nodeComment = pair.getLeft();
CommentsNodeImpl subNode = pair.getRight();
if (nodeComment != null)
{
this.setComment(nodeKey, nodeComment);
}
if (subNode != null)
{
this.join(nodeKey, subNode);
}
}
}
@SuppressWarnings("unchecked")
private void write(Map<String, MutablePair<String, ?>> map) throws IOException
{
this.updateIndent(true);
int keys = map.entrySet().size();
int k = 0;
for (Entry<String, MutablePair<String, ?>> entry : map.entrySet())
{
k += 1;
MutablePair<String, ?> pair = entry.getValue();
String comment = pair.getLeft();
Map<String, MutablePair<String, ?>> rightMap = (Map<String, MutablePair<String, ?>>) pair.getRight();
int rightKeys = (rightMap == null) ? 0 : rightMap.size();
boolean newLine = keys > 3;
if (comment != null)
{
this.writeComment(comment);
}
String key = entry.getKey();
this.writeKey(key);
if (rightMap != null)
{
this.write(rightMap);
}
if (newLine)
{
this.writeNewLine(false);
}
}
this.writeNewLine(false);
this.updateIndent(false);
}
@Override
public void beginWindow(long windowId)
{
currentWindowId = windowId;
if (currentWindowId <= windowManager.getLargestCompletedWindow()) {
try {
replay(currentWindowId);
return;
} catch (SQLException e) {
throw new RuntimeException("Replay failed", e);
}
}
currentWindowRecoveryState = WindowData.of(currentWindowRecoveryState.key, lastEmittedRow, 0);
if (isPollerPartition) {
MutablePair<Object, Integer> keyOffset = fetchedKeyAndOffset.get();
if (keyOffset != null && keyOffset.getRight() < lastEmittedRow) {
if (!adjustKeyAndOffset.get()) {
// rebase offset
lastEmittedRow -= keyOffset.getRight();
currentWindowRecoveryState.lowerBound = lastEmittedRow;
currentWindowRecoveryState.key = keyOffset.getLeft();
adjustKeyAndOffset.set(true);
}
}
}
}
@Override
public MutablePair<MutableLong, MutableLong> accumulate(MutablePair<MutableLong, MutableLong> accumulatedValue, MutablePair<Double, Double> input)
{
if (input.getLeft() * input.getLeft() + input.getRight() * input.getRight() < 1) {
accumulatedValue.getLeft().increment();
}
accumulatedValue.getRight().increment();
return accumulatedValue;
}
private static void doWriteToStream(RecordReceiver lineReceiver,
BufferedWriter writer, String contex, Configuration config,
TaskPluginCollector taskPluginCollector) throws IOException {
String nullFormat = config.getString(Key.NULL_FORMAT);
// 兼容format & dataFormat
String dateFormat = config.getString(Key.DATE_FORMAT);
// warn: default false
String fileFormat = config.getString(Key.FILE_FORMAT,
Constant.FILE_FORMAT_TEXT);
String delimiterInStr = config.getString(Key.FIELD_DELIMITER);
if (null != delimiterInStr && 1 != delimiterInStr.length()) {
throw DataXException.asDataXException(
UnstructuredStorageWriterErrorCode.ILLEGAL_VALUE,
String.format("仅仅支持单字符切分, 您配置的切分为 : [%]", delimiterInStr));
}
if (null == delimiterInStr) {
LOG.warn(String.format("您没有配置列分隔符, 使用默认值[%s]",
Constant.DEFAULT_FIELD_DELIMITER));
}
// warn: fieldDelimiter could not be '' for no fieldDelimiter
char fieldDelimiter = config.getChar(Key.FIELD_DELIMITER,
Constant.DEFAULT_FIELD_DELIMITER);
List<String> headers = config.getList(Key.HEADER, String.class);
if (null != headers && !headers.isEmpty()) {
writer.write(UnstructuredStorageWriterUtil.doTransportOneRecord(
headers, fieldDelimiter, fileFormat));
}
Record record = null;
while ((record = lineReceiver.getFromReader()) != null) {
MutablePair<String, Boolean> transportResult = UnstructuredStorageWriterUtil
.transportOneRecord(record, nullFormat, dateFormat,
fieldDelimiter, fileFormat, taskPluginCollector);
if (!transportResult.getRight()) {
writer.write(transportResult.getLeft());
}
}
}
@Override
protected String getFileName(AbstractBlockReader.ReaderRecord<Slice> tuple)
{
MutablePair<Integer,String> blockId = blockInfo.get(tuple.getBlockId());
return blockId.getRight() + PARTSUFFIX + blockId.getLeft();
}
@Override
public void finalizeFile(String fileName) throws IOException
{
MutablePair<Integer,String> blockId = blockInfo.get(Long.parseLong(fileName));
super.finalizeFile(blockId.getRight() + PARTSUFFIX + blockId.getLeft());
}