add ConnectivityDirectionEnum

Dennis Kao

2014-01-06 a924ec71875291809d7f2e13c87dc1a231e87526

add ConnectivityDirectionEnum

 xdgnjobs/ximple-spatialjob/src/main/java/com/ximple/eofms/util/ConnectivityDirectionEnum.java

New file
@@ -0,0 +1,275 @@
package com.ximple.eofms.util;

/**
 *
 * TODO Purpose of
 * <p>
 *
 * </p>
 * @author Ulysses
 * @since 1.1.0
 */
public enum ConnectivityDirectionEnum {
    Noneflow((short) 0),

    ForwardflowON((short) 0x01),

    BackflowON((short) 0x02),

    ForwardflowOFF((short) 0x03),

    BackflowOFF((short) 0x04),

    ForwardFixflowON((short) 0x05),

    ForwardFixflowOFF((short) 0x06),

    BackFixflowON((short) 0x07),

    BackFixflowOFF((short) 0x08),

    Breakflow((short) 0x62),

    Nondeterminate((short) 0x63),

    PhaseAON((short) 0x64), // 100

    PhaseBON((short) 0xC8), // 200

    PhaseCON((short) 0x190); // 400

    private final short value;

    ConnectivityDirectionEnum(short value) {
        this.value = value;
    }

    public short getValue() {
        return this.value;
    }

    public static ConnectivityDirectionEnum convertShort(short val) {
        if (val == 0)
            return Noneflow;
        if (val == 0x1)
            return ForwardflowON;
        if (val == 0x2)
            return BackflowON;
        if (val == 0x3)
            return ForwardflowOFF;
        if (val == 0x4)
            return BackflowOFF;
        if (val == 0x5)
            return ForwardFixflowON;
        if (val == 0x6)
            return ForwardFixflowOFF;
        if (val == 0x7)
            return BackFixflowON;
        if (val == 0x8)
            return BackFixflowOFF;
        if (val == 0x62)
            return Breakflow;
        return Nondeterminate;
    }

    public static boolean isOn(short val) {
        short dir = (short) (val & 0x00ff);
        switch (dir) {
        case 0x0:
        case 0x1:
        case 0x2:
        case 0x5:
        case 0x7:
            return true;
        }

        return false;
    }

    public static boolean isOff(short val) {
        return (!isOn(val));
    }

    public static boolean isForward(short val) {
        short dir = (short) (val & 0x00ff);
        switch (dir) {
        case 0x1:
        case 0x3:
        case 0x5:
        case 0x6:
            return true;
        }

        return false;
    }

    public static boolean isBackward(short val) {
        short dir = (short) (val & 0x00ff);
        switch (dir) {
        case 0x2:
        case 0x4:
        case 0x7:
        case 0x8:
            return true;
        }

        return false;
    }

    public static boolean isFixDirection(short val) {
        short dir = (short) (val & 0x00ff);
        switch (dir) {
        case 0x5:
        case 0x6:
        case 0x7:
        case 0x8:
            return true;
        }

        return false;
    }

    public static boolean isNondeterminate(short val) {
        short dir = (short) (val & 0x00ff);
        return (dir == 0x63);
    }

    public static short getWeight(short val) {
        short weight = (short) (val & 0xff00);
        return (short) (weight >>> 8);
    }

    @Override
    public String toString() {
        boolean isA = (this.value & PhaseAON.getValue()) != 0;
        boolean isB = (this.value & PhaseBON.getValue()) != 0;
        boolean isC = (this.value & PhaseCON.getValue()) != 0;
        String phase = "" + (isA ? "A" : "") + (isB ? "B" : "") //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
                + (isC ? "C" : ""); //$NON-NLS-1$ //$NON-NLS-2$
        if (phase.length() != 0)
            phase = "[" + phase + "]"; //$NON-NLS-1$ //$NON-NLS-2$

        if (value == 0)
            return "Noneflow" + phase; //$NON-NLS-1$
        if (value == 0x1)
            return "ForwardflowON" + phase; //$NON-NLS-1$
        if (value == 0x2)
            return "BackflowON" + phase; //$NON-NLS-1$
        if (value == 0x3)
            return "ForwardflowOFF" + phase; //$NON-NLS-1$
        if (value == 0x4)
            return "BackflowOFF" + phase; //$NON-NLS-1$
        if (value == 0x5)
            return "ForwardFixflowON" + phase; //$NON-NLS-1$
        if (value == 0x6)
            return "ForwardFixflowOFF" + phase; //$NON-NLS-1$
        if (value == 0x7)
            return "BackFixflowON" + phase; //$NON-NLS-1$
        if (value == 0x8)
            return "BackFixflowOFF" + phase; //$NON-NLS-1$
        if (value == 0x62)
            return "Breakflow" + phase; //$NON-NLS-1$
        return "Nondeterminate"; //$NON-NLS-1$
    }

    /*
     *
     * enum DirectionType { Noneflow = 0, ForwardflowON = 0x01, BackflowON =
     * 0x02, ForwardflowOFF = 0x03, BackflowOFF = 0x04, ForwardFixflowON = 0x05,
     * ForwardFixflowOFF = 0x06, BackFixflowON = 0x07, BackFixflowOFF = 0x08,
     * Breakflow = 0x62, Nondeterminate = 0x63, PhaseAON = 0x64, // 100 PhaseBON
     * = 0xC8, // 200 PhaseCON = 0x190 // 400 };
     *
     * enum OperationType { OFF = 0, ON = 0x01, NSTATUS = 0x10 };
     *
     *
     * enum tagNetworkEdgeFlowType { FLOWUNKNOWN = 0x0000, // "???w" FLOWFORWARD
     * = 0x0001, // "???V" FLOWBACKWARD = 0x0002, // "�Xf?V" FLOWTWOWAY =
     * 0x0003, // "???V" FLOWBREAK = 0x00F0, // "???_" FLOWUNDELEGATED = 0x00FF,
     * // "?L�PN?q"
     *
     * FLOWWT_1 = 0x0100, // A FLOWWT_2 = 0x0200, // B FLOWWT_3 = 0x0400, // C
     * FLOWWT_4 = 0x0800, // ?-Unused
     *
     * FLOWON = 0x1000, // "On" FLOWOFF = 0x0000, // "Off"
     *
     * FLOWFIX = 0x2000, // Fix Dir
     *
     * FLOWONMASK = 0xF000, FLOWWTMASK = 0x0F00, FLOWWAYMASK = 0x00FF };
     *
     * enum tagNetworkEdgeOStatusType { OPSTATUS_OFF = 0x0000, OPSTATUS_ON =
     * 0x0001, BOUNDSTATUS = 0x0010, OPSTATUSMASK = 0x000F };
     *
     * enum tagPhaseMask { PhaseUnknown = 0x0, PhaseA = 0x1, PhaseB = 0x2,
     * PhaseC = 0x4, PhaseN = 0x8 };
     *
     * BYTE CNetworkSnapshot::marshalDIRFromDirection(short wFlag) { // BYTE
     * bRet = 0xFF; bool bON; bool bFix; if ((wFlag & CNetworkEdge::FLOWONMASK)
     * == CNetworkEdge::FLOWON) bON = true; else bON = false; if ((wFlag &
     * CNetworkEdge::FLOWONMASK) == CNetworkEdge::FLOWFIX) bFix = true; else
     * bFix = false;
     *
     * switch (wFlag & CNetworkEdge::FLOWWAYMASK) { case
     * CNetworkEdge::FLOWFORWARD: if (bFix) if (bON) return
     * CFacility::ForwardFixflowON ; else return CFacility::ForwardFixflowOFF;
     * else if (bON) return CFacility::ForwardflowON; else return
     * CFacility::ForwardflowOFF;
     *
     * case CNetworkEdge::FLOWBACKWARD: if (bFix) if (bON) return
     * CFacility::BackFixflowON; else return CFacility::BackFixflowOFF; else if
     * (bON) return CFacility::BackflowON; else return CFacility::BackflowOFF;
     *
     * case CNetworkEdge::FLOWUNKNOWN: case CNetworkEdge::FLOWTWOWAY: return
     * CFacility::Noneflow;
     *
     * case CNetworkEdge::FLOWBREAK: return CFacility::Breakflow;
     *
     * case CNetworkEdge::FLOWUNDELEGATED: return CFacility::Nondeterminate;
     *
     * default: break; }
     *
     * return 0xFF; }
     *
     * short CNetworkSnapshot::marshalDirectionFromDIR(WORD bFlag) { short wRet
     * = CNetworkEdge::FLOWUNDELEGATED; switch (bFlag) { case
     * CFacility::Noneflow: wRet = CNetworkEdge::FLOWUNKNOWN; break; case
     * CFacility::ForwardflowON: wRet = CNetworkEdge::FLOWFORWARD |
     * CNetworkEdge::FLOWON; break; case CFacility::BackflowON: wRet =
     * CNetworkEdge::FLOWBACKWARD | CNetworkEdge::FLOWON; break; case
     * CFacility::ForwardflowOFF: wRet = CNetworkEdge::FLOWFORWARD; break; case
     * CFacility::BackflowOFF: wRet = CNetworkEdge::FLOWBACKWARD; break; case
     * CFacility::ForwardFixflowON: wRet = CNetworkEdge::FLOWFORWARD |
     * CNetworkEdge::FLOWON | CNetworkEdge::FLOWFIX; break; case
     * CFacility::ForwardFixflowOFF: wRet = CNetworkEdge::FLOWFORWARD |
     * CNetworkEdge::FLOWFIX; break; case CFacility::BackFixflowON: wRet =
     * CNetworkEdge::FLOWBACKWARD | CNetworkEdge::FLOWON |
     * CNetworkEdge::FLOWFIX; break; case CFacility::BackFixflowOFF: wRet =
     * CNetworkEdge::FLOWBACKWARD | CNetworkEdge::FLOWFIX; break; case
     * CFacility::Breakflow: wRet = CNetworkEdge::FLOWBREAK; break; case
     * CFacility::Nondeterminate: wRet = CNetworkEdge::FLOWUNDELEGATED; break;
     * default: break; } return wRet; }
     *
     * short CNetworkSnapshot::marshalPhaseToMask(short wPhase) { short
     * wMaskValue = 0;
     *
     * if (wPhase == 1) { wMaskValue |= CNetworkEdge::PhaseA |
     * CNetworkEdge::PhaseB | CNetworkEdge::PhaseC; return wMaskValue; }
     *
     * if (wPhase > 16) { wMaskValue = CNetworkEdge::PhaseN; wPhase -= 16; }
     *
     * if (wPhase > 10) { wMaskValue |= CNetworkEdge::PhaseA |
     * CNetworkEdge::PhaseB | CNetworkEdge::PhaseC; return wMaskValue; }
     *
     * switch (wPhase) { case 5: // AB case 6: // BA wMaskValue |=
     * CNetworkEdge::PhaseA | CNetworkEdge::PhaseB; break; case 7: // BC case 8:
     * // CB wMaskValue |= CNetworkEdge::PhaseB | CNetworkEdge::PhaseC; break;
     * case 9: // CA case 10: // AC wMaskValue |= CNetworkEdge::PhaseA |
     * CNetworkEdge::PhaseC; break; case 2: // A wMaskValue |=
     * CNetworkEdge::PhaseA; break; case 3: // B wMaskValue |=
     * CNetworkEdge::PhaseB; break; case 4: // C wMaskValue |=
     * CNetworkEdge::PhaseC; break; default: wMaskValue |=
     * CNetworkEdge::PhaseUnknown; break; }
     *
     * return wMaskValue; }
     */
}