public static T validate()

in accord-core/src/main/java/accord/local/Command.java [1582:1689]
108 lines of code
42 McCabe index (conditional complexity)

    public static <T extends Command> T validate(T validate)
    {
        Invariants.require(validate.txnId().hasOnlyIdentityFlags());
        Invariants.require(!validate.participants().hasTouched().isEmpty() || validate.saveStatus() == Uninitialised);
        Known known = validate.known();
        switch (known.route())
        {
            default: throw new UnhandledEnum(known.route());
            case MaybeRoute: break;
            case FullRoute: Invariants.require(Route.isFullRoute(validate.route())); break;
            case CoveringRoute: Invariants.require(Route.isRoute(validate.route())); break;
        }
        {
            PartialTxn partialTxn = validate.partialTxn();
            switch (known.definition())
            {
                default: throw new UnhandledEnum(known.definition());
                case DefinitionErased:
                case DefinitionUnknown:
                case NoOp:
                    Invariants.require(partialTxn == null, "partialTxn is defined %s", validate);
                    break;
                case DefinitionKnown:
                    Invariants.require(partialTxn != null || validate.participants().stillOwns().isEmpty(), "partialTxn is null");
                    break;
            }
        }
        {
            Timestamp executeAt = validate.executeAt();
            switch (known.executeAt())
            {
                default: throw new UnhandledEnum(known.executeAt());
                case ExecuteAtErased:
                case ExecuteAtUnknown:
                    Invariants.require(executeAt == null || executeAt.compareTo(validate.txnId()) >= 0);
                    break;
                case ExecuteAtKnown:
                case ApplyAtKnown:
                case ExecuteAtProposed:
                    Invariants.require(executeAt != null);
                    int c =  executeAt.compareTo(validate.txnId());
                    Invariants.require(c > 0 || (c == 0 && executeAt.getClass() != Timestamp.class));
                    break;
                case NoExecuteAt:
                    Invariants.require(executeAt.equals(Timestamp.NONE));
                    break;
            }
        }
        {
            PartialDeps deps = validate.partialDeps();
            switch (known.deps())
            {
                default: throw new UnhandledEnum(known.deps());
                case DepsUnknown:
                case DepsErased:
                case NoDeps:
                    Invariants.require(deps == null);
                    break;
                case DepsFromCoordinator:
                case DepsProposedFixed:
                case DepsProposed:
                case DepsCommitted:
                case DepsKnown:
                    Invariants.require(deps != null);
                    break;
            }
        }
        {
            Writes writes = validate.writes();
            Result result = validate.result();
            switch (known.outcome())
            {
                default: throw new UnhandledEnum(known.outcome());
                case Apply:
                    if (validate.txnId().is(Write)) Invariants.require(writes != null, "Writes is null %s", validate);
                    else Invariants.require(writes == null, "Writes is not-null %s", validate);
                    Invariants.require(result != null, "Result is null %s", validate);
                    break;
                case Abort:
                    Invariants.require(validate.durability().isMaybeInvalidated(), "%s is not invalidated", validate.durability());
                case Unknown:
                    Invariants.require(validate.durability() != Local);
                case Erased:
                case WasApply:
                    Invariants.require(writes == null, "Writes exist for %s", validate);
                    Invariants.require(result == null, "Results exist %s %s", validate, result);
                    break;
            }
        }
        switch (validate.saveStatus().execution)
        {
            case NotReady:
            case CleaningUp:
                break;
            case ReadyToExclude:
                Invariants.require(validate.saveStatus() != SaveStatus.Committed || validate.asCommitted().waitingOn == null);
                break;
            case WaitingToExecute:
            case ReadyToExecute:
            case Applied:
            case Applying:
            case WaitingToApply:
                Invariants.require(validate.participants().executes() != null);
                Invariants.require(validate.asCommitted().waitingOn != null);
                break;
        }
        return validate;
    }