Examples with Pair com.ms.silverking.collection.Pair used on opensource projects

Example 6 with Pair

use of com.ms.silverking.collection.Pair in project SilverKing by Morgan-Stanley.

the class DaemonStateZK method getQuorumState.

private Pair<Boolean, Map<IPAndPort, DaemonState>> getQuorumState(Set<IPAndPort> members, DaemonState targetState, int _maxIncompletePerFetch) throws KeeperException {
    Map<IPAndPort, DaemonState> quorumState;
    boolean allRead;
    int incomplete;
    quorumState = new HashMap<>();
    allRead = true;
    incomplete = 0;
    for (IPAndPort member : members) {
        DaemonState state;
        state = getMemberState(member);
        Log.warningf("member %s state %s", member, state);
        quorumState.put(member, state);
        if (state == null || state.ordinal() < targetState.ordinal()) {
            ++incomplete;
            if (incomplete >= _maxIncompletePerFetch && incomplete < members.size()) {
                allRead = false;
                break;
            }
        }
    }
    return new Pair<>(allRead, quorumState);
}

Example 7 with Pair

use of com.ms.silverking.collection.Pair in project SilverKing by Morgan-Stanley.

the class MessageGroupBase method readAliasMapEntry.

private Pair<AddrAndPort, AddrAndPort[]> readAliasMapEntry(String s, int port) {
    String[] toks;
    toks = s.trim().split("\\s+");
    if (toks.length != 2) {
        throw new RuntimeException("Invalid map entry: " + s);
    } else {
        AddrAndPort addr;
        AddrAndPort[] aliases;
        addr = new IPAndPort(toks[0], port);
        aliases = IPAndPort.parseToArray(toks[1], port);
        return new Pair<>(addr, aliases);
    }
}

Example 8 with Pair

use of com.ms.silverking.collection.Pair in project SilverKing by Morgan-Stanley.

the class OpCompletionTracker method waitForCompletion.

public Pair<Set<UUIDBase>, Set<UUIDBase>> waitForCompletion(Set<UUIDBase> uuids, int time, TimeUnit unit) {
    Timer waitTimer;
    Set<UUIDBase> incompleteOps;
    Set<UUIDBase> failedOps;
    incompleteOps = new HashSet<>();
    failedOps = new HashSet<>();
    waitTimer = new SimpleTimer(unit, time);
    for (UUIDBase uuid : uuids) {
        completionState.putIfAbsent(uuid, new OpCompletionState());
    }
    try {
        for (UUIDBase uuid : uuids) {
            OpCompletionState opCompletionState;
            boolean complete;
            opCompletionState = completionState.get(uuid);
            complete = opCompletionState.waitForCompletion(waitTimer.getRemainingMillis(), TimeUnit.MILLISECONDS);
            if (!complete) {
                incompleteOps.add(uuid);
            }
            if (opCompletionState.getResult().hasFailed()) {
                failedOps.add(uuid);
            }
        }
    } finally {
        for (UUIDBase uuid : uuids) {
            completionState.remove(uuid);
        }
    }
    return new Pair<>(incompleteOps, failedOps);
}

Example 9 with Pair

use of com.ms.silverking.collection.Pair in project SilverKing by Morgan-Stanley.

the class DirectoryInMemorySS method readFromDisk.

Pair<SSStorageParameters, byte[]> readFromDisk(long version) throws IOException {
    byte[] b;
    SSStorageParameters sp;
    byte[] serializedDir;
    int spLength;
    b = FileUtil.readFileAsBytes(fileForVersion(version));
    sp = StorageParameterSerializer.deserialize(b);
    spLength = StorageParameterSerializer.getSerializedLength(sp);
    serializedDir = new byte[b.length - spLength];
    System.arraycopy(b, spLength, serializedDir, 0, b.length - spLength);
    return new Pair<>(sp, serializedDir);
}

Example 10 with Pair

use of com.ms.silverking.collection.Pair in project SilverKing by Morgan-Stanley.

the class WrapperGenerator method generate.

/**
 * Loop through all ParseElements in the list.
 * For text, put as is.
 * For other elements, process according to type.
 * @param c
 * @param elements
 * @param outputDir
 * @param loopIndex
 * @param depth TODO
 * @throws IOException
 */
private void generate(Context c, List<ParseElement> elements, File outputDir, int loopIndex, int depth) throws IOException {
    int i;
    if (debugGeneration) {
        Thread.dumpStack();
        System.out.printf("generate elements %d loopIndex %d depth %d\n", elements.size(), loopIndex, depth);
    }
    i = 0;
    while (i < elements.size()) {
        ParseElement e;
        e = elements.get(i);
        c = c.loopIndex(loopIndex);
        if (debugGeneration) {
            System.out.printf("%s%d\t%s\n", StringUtil.replicate(debugTab, depth), i, e);
        }
        if (e instanceof Text) {
            outStreams.print(c, (Text) e);
            i++;
        } else if (e instanceof Expression) {
            Pair<Context, String> result;
            result = ((Expression) e).evaluate(c);
            c = result.getV1();
            if (result.getV2() != null) {
                outStreams.print(c, result.getV2());
            }
            i++;
        } else if (e instanceof LoopElement) {
            LoopElement le;
            le = (LoopElement) e;
            if (!isValidLoopTarget(c.getLoopElement(), le.getTarget())) {
                generateLoopTargetException(le);
            } else {
                List<ParseElement> loopElements;
                Context _c;
                int newLoopIndex;
                newLoopIndex = 0;
                loopElements = getLoopElements(elements, i);
                _c = c.loopElement(le);
                if (debugGeneration) {
                    System.out.printf("G%sLoop %d %d\n", StringUtil.replicate(debugTab, depth), i, i + loopElements.size());
                }
                switch(le.getTarget()) {
                    case Packages:
                        for (GenPackageClasses genPackageClasses : c.getPackages()) {
                            Context packageContext;
                            packageContext = _c.genPackageClasses(genPackageClasses);
                            generate(packageContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case Classes:
                        // _c = c.loopElements(c.getPackageClasses().size());
                        for (Class _class : c.getPackageClasses()) {
                            Context classContext;
                            classContext = _c.class_(_class);
                            generate(classContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case Methods:
                        // _c = c.loopElements(c.getClass_().getDeclaredMethods().length);
                        for (Method m : getMethodsForGeneration(c.getClass_())) {
                            // for (Method m : c.getClass_().getMethods()) {
                            if (!Modifier.isStatic(m.getModifiers()) && Modifier.isPublic(m.getModifiers())) {
                                System.out.printf("Method\t%s\t%s\t%s\n", m.getName(), !JNIUtil.omitted(m), referenceFinder.allReferencesPresent(m));
                            }
                            if (!Modifier.isStatic(m.getModifiers()) && Modifier.isPublic(m.getModifiers()) && !JNIUtil.omitted(m) && referenceFinder.allReferencesPresent(m)) {
                                Context methodContext;
                                methodContext = _c.method(m);
                                generate(methodContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case StaticMethods:
                        // _c = c.loopElements(c.getClass_().getDeclaredMethods().length);
                        for (Method m : getMethodsForGeneration(c.getClass_())) {
                            // for (Method m : c.getClass_().getMethods()) {
                            if (Modifier.isStatic(m.getModifiers()) && Modifier.isPublic(m.getModifiers()) && !JNIUtil.omitted(m) && referenceFinder.allReferencesPresent(m)) {
                                Context methodContext;
                                methodContext = _c.method(m);
                                generate(methodContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case Constructors:
                        for (Constructor constructor : c.getClass_().getConstructors()) {
                            if (Modifier.isPublic(constructor.getModifiers()) && !JNIUtil.omitted(constructor) && referenceFinder.allReferencesPresent(constructor)) {
                                Context constructorContext;
                                constructorContext = _c.constructor(constructor);
                                generate(constructorContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case NonEmptyConstructors:
                        for (Constructor constructor : c.getClass_().getConstructors()) {
                            if (Modifier.isPublic(constructor.getModifiers()) && !JNIUtil.omitted(constructor) && referenceFinder.allReferencesPresent(constructor)) {
                                if (constructor.getParameterCount() > 0) {
                                    Context constructorContext;
                                    constructorContext = _c.constructor(constructor);
                                    generate(constructorContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                                }
                            }
                        }
                        break;
                    case Parameters:
                        _c = c.loopElements(c.getActiveParameters().length);
                        for (Parameter p : c.getActiveParameters()) {
                            Context parameterContext;
                            parameterContext = _c.parameter(p);
                            generate(parameterContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case StaticFields:
                        for (Field f : getStaticFieldsForGeneration(c.getClass_())) {
                            if (referenceFinder.referencePresent(f.getClass())) {
                                Context fieldContext;
                                fieldContext = _c.field(f);
                                generate(fieldContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case Enums:
                        for (Class ec : getEnumsForGeneration(c.getClass_())) {
                            if (referenceFinder.referencePresent(ec)) {
                                Context enumContext;
                                enumContext = _c.enum_(ec);
                                generate(enumContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case EnumValues:
                        for (String v : getEnumValuesForGeneration(c.getEnum())) {
                            Context enumValueContext;
                            enumValueContext = _c.enumValue(v);
                            generate(enumValueContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case Interfaces:
                        for (Class i_ : getInterfacesForGeneration(c.getClass_())) {
                            if (referenceFinder.referencePresent(i_)) {
                                Context iContext;
                                iContext = _c.interface_(i_);
                                generate(iContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                            }
                        }
                        break;
                    case InheritedClasses:
                        Set<Class> inheritedClasses;
                        Set<Class> ic2;
                        inheritedClasses = JNIUtil.getAllInheritedClasses(c.getClass_());
                        ic2 = new HashSet<>();
                        for (Class inheritedClass : inheritedClasses) {
                            if (isBaseClass(inheritedClass) || referenceFinder.referencePresent(inheritedClass)) {
                                ic2.add(inheritedClass);
                            }
                        }
                        _c = c.loopElements(ic2.size());
                        for (Class inheritedClass : ic2) {
                            Context icContext;
                            icContext = _c.inheritedClass(inheritedClass);
                            generate(icContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    case ReferencedClasses:
                        Set<Class> _referencedClasses;
                        Set<Class> referencedClasses;
                        Set<Class> _inheritedClasses;
                        Set<Class> rc2;
                        _inheritedClasses = JNIUtil.getAllInheritedClasses(c.getClass_());
                        // System.out.printf("\ngetReferencedClasses\t%s\n", c.getClass_().getName());
                        _referencedClasses = JNIUtil.getReferencedClasses(c.getClass_());
                        referencedClasses = new HashSet<>();
                        referencedClasses.addAll(_referencedClasses);
                        referencedClasses.addAll(_inheritedClasses);
                        // System.out.printf("\n%s\t%s\n\n", c.getClass_().getName(), CollectionUtil.toString(referencedClasses));
                        rc2 = new HashSet<>();
                        for (Class referencedClass : referencedClasses) {
                            if (referenceFinder.referencePresent(referencedClass)) {
                                rc2.add(referencedClass);
                            } else {
                            // System.out.printf("ReferencedClasses ignoring %s\n", referencedClass.getName());
                            }
                        }
                        _c = c.loopElements(rc2.size());
                        for (Class referencedClass : rc2) {
                            Context rcContext;
                            // System.out.printf("ReferencedClasses adding %s\n", referencedClass.getName());
                            rcContext = _c.referencedClass(referencedClass);
                            generate(rcContext, loopElements, outputDir, ++newLoopIndex, depth + 1);
                        }
                        break;
                    default:
                        throw new RuntimeException("Panic");
                }
                i += loopElements.size() + 2;
            }
        } else if (e instanceof IfElement) {
            Quadruple<IfElement, List<ParseElement>, List<ParseElement>, Integer> ifStatement;
            ifStatement = getIfElements(elements, i);
            generate(c, IfElement.evaluate(c, ifStatement.getTripleAt1()), outputDir, loopIndex, depth + 1);
            i = ifStatement.getV4();
        } else if (e instanceof SwitchElement) {
            Triple<SwitchElement, List<Pair<CaseElement, List<ParseElement>>>, Integer> switchStatement;
            switchStatement = getSwitchElements(elements, i);
            generate(c, SwitchElement.evaluate(c, switchStatement.getPairAt1()), outputDir, loopIndex, depth + 1);
            i = switchStatement.getV3();
        } else {
            throw new RuntimeException("Unhandled element " + e);
        }
    }
}