/*
 * Decompiled with CFR 0.152.
 */
package javax.baja.sys;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.lang.reflect.Field;
import javax.baja.sys.BBitString;
import javax.baja.sys.BObject;
import javax.baja.sys.Context;
import javax.baja.sys.Sys;
import javax.baja.sys.Type;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public final class BComponentEventMask
extends BBitString {
    public static final BComponentEventMask PROPERTY_EVENTS = new BComponentEventMask(2047);
    public static final BComponentEventMask SELF_EVENTS = new BComponentEventMask(1701888);
    public static final BComponentEventMask EMPTY = new BComponentEventMask(0);
    public static final BComponentEventMask ALL = new BComponentEventMask(-1);
    public static final BComponentEventMask DEFAULT = EMPTY;
    public static final Type TYPE;
    private static BBitString.Support support;
    private int bits;
    static /* synthetic */ Class class$javax$baja$sys$BComponentEventMask;
    static /* synthetic */ Class class$javax$baja$sys$BComponentEvent;

    public static final BComponentEventMask make() {
        return EMPTY;
    }

    public static final BComponentEventMask make(int n) {
        return new BComponentEventMask(n);
    }

    public static final BComponentEventMask make(int[] nArray) {
        int n = 0;
        int n2 = 0;
        while (n2 < nArray.length) {
            n |= 1 << nArray[n2];
            ++n2;
        }
        if (n == BComponentEventMask.EMPTY.bits) {
            return EMPTY;
        }
        return new BComponentEventMask(n);
    }

    public static final BComponentEventMask make(BComponentEventMask bComponentEventMask, BComponentEventMask bComponentEventMask2, boolean bl) {
        if (bl) {
            return new BComponentEventMask(bComponentEventMask.bits | bComponentEventMask2.bits);
        }
        return new BComponentEventMask(bComponentEventMask.bits & ~bComponentEventMask2.bits);
    }

    public final boolean includes(int n) {
        boolean bl = false;
        if ((1 << n & this.bits) != 0) {
            bl = true;
        }
        return bl;
    }

    public final int getBits() {
        return this.bits;
    }

    public final boolean getBit(int n) {
        boolean bl = false;
        if ((this.bits & n) != 0) {
            bl = true;
        }
        return bl;
    }

    public final boolean getBit(String string) {
        return this.getBit(this.tagToOrdinal(string));
    }

    public final int[] getOrdinals() {
        return support.getOrdinals();
    }

    public final boolean isOrdinal(int n) {
        return support.isOrdinal(n);
    }

    public final String getTag(int n) {
        return support.getTag(n);
    }

    public final String getDisplayTag(int n, Context context) {
        return support.getDisplayTag(n, context);
    }

    public final BBitString getInstance(int[] nArray) {
        int n = 0;
        int n2 = 0;
        while (n2 < nArray.length) {
            n |= nArray[n2];
            ++n2;
        }
        return BComponentEventMask.make(n);
    }

    public final boolean isTag(String string) {
        return support.isTag(string);
    }

    public final int tagToOrdinal(String string) {
        return support.tagToOrdinal(string);
    }

    public final boolean isEmpty() {
        boolean bl = false;
        if (this.bits == 0) {
            bl = true;
        }
        return bl;
    }

    public final String getEmptyTag() {
        return "none";
    }

    public final boolean isNull() {
        boolean bl = false;
        if (this.bits == 0) {
            bl = true;
        }
        return bl;
    }

    public final int hashCode() {
        return this.bits;
    }

    public final boolean equals(Object object) {
        if (object instanceof BComponentEventMask) {
            boolean bl = false;
            if (((BComponentEventMask)object).bits == this.bits) {
                bl = true;
            }
            return bl;
        }
        return false;
    }

    public final void encode(DataOutput dataOutput) throws IOException {
        dataOutput.writeInt(this.bits);
    }

    public final BObject decode(DataInput dataInput) throws IOException {
        return BComponentEventMask.make(dataInput.readInt());
    }

    public final String encodeToString() {
        return Integer.toHexString(this.bits);
    }

    public final BObject decodeFromString(String string) throws IOException {
        try {
            return BComponentEventMask.make(Integer.parseInt(string, 16));
        }
        catch (Exception exception) {
            throw new IOException("Invalid bits: " + string);
        }
    }

    public final Type getType() {
        return TYPE;
    }

    static /* synthetic */ Class class(String string, boolean bl) {
        try {
            Class<?> clazz = Class.forName(string);
            if (!bl) {
                clazz = clazz.getComponentType();
            }
            return clazz;
        }
        catch (ClassNotFoundException classNotFoundException) {
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }

    private BComponentEventMask(int n) {
        this.bits = n;
    }

    static {
        Class clazz = class$javax$baja$sys$BComponentEventMask;
        if (clazz == null) {
            clazz = class$javax$baja$sys$BComponentEventMask = BComponentEventMask.class("[Ljavax.baja.sys.BComponentEventMask;", false);
        }
        TYPE = Sys.loadType(clazz);
        support = new BBitString.Support(DEFAULT);
        try {
            Class clazz2 = class$javax$baja$sys$BComponentEvent;
            if (clazz2 == null) {
                clazz2 = class$javax$baja$sys$BComponentEvent = BComponentEventMask.class("[Ljavax.baja.sys.BComponentEvent;", false);
            }
            Class clazz3 = clazz2;
            Field field = clazz3.getDeclaredField("ID_STRINGS");
            field.setAccessible(true);
            String[] stringArray = (String[])field.get(null);
            int n = 0;
            while (n < stringArray.length) {
                support.add(n, stringArray[n]);
                ++n;
            }
        }
        catch (Exception exception) {
            exception.printStackTrace();
        }
    }
}