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

import com.tridium.sys.schema.ComplexSlotMap;
import javax.baja.space.BComponentSpace;
import javax.baja.sys.BComponent;
import javax.baja.sys.BObject;
import javax.baja.sys.CopyHints;
import javax.baja.sys.Sys;
import javax.baja.sys.Type;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public abstract class BValue
extends BObject {
    private static Object copySerialNumLock = new Object();
    private static int copySerialNum = 0;
    public static final Type TYPE;
    static /* synthetic */ Class class$javax$baja$sys$BValue;

    public abstract BValue newCopy();

    public abstract BValue newCopy(boolean var1);

    public abstract BValue newCopy(CopyHints var1);

    public static BValue[] newCopy(BValue[] bValueArray, CopyHints copyHints) {
        BValue[] bValueArray2;
        Object object;
        BComponentSpace bComponentSpace = null;
        int n = 0;
        while (n < bValueArray.length) {
            if (bValueArray[n] instanceof BComponent) {
                object = (BComponent)bValueArray[n];
                BComponentSpace bComponentSpace2 = ((BComponent)object).getComponentSpace();
                if (bComponentSpace != null && bComponentSpace != bComponentSpace2) {
                    throw new IllegalArgumentException("Components must be in same space");
                }
                bComponentSpace = bComponentSpace2;
            }
            ++n;
        }
        if (bComponentSpace != null && (bValueArray2 = bComponentSpace.getLoadCallbacks().newCopy(bValueArray, copyHints)) != null) {
            return bValueArray2;
        }
        int n2 = BValue.copySerialNum();
        object = new BValue[bValueArray.length];
        int n3 = 0;
        while (n3 < bValueArray.length) {
            object[n3] = ComplexSlotMap.newCopy(bValueArray[n3], copyHints, n2);
            ++n3;
        }
        return object;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     */
    static int copySerialNum() {
        Object object = copySerialNumLock;
        synchronized (object) {
            return ++copySerialNum;
        }
    }

    ComplexSlotMap getSlotMap() {
        return null;
    }

    public 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());
        }
    }

    BValue() {
    }

    static {
        Class clazz = class$javax$baja$sys$BValue;
        if (clazz == null) {
            clazz = class$javax$baja$sys$BValue = BValue.class("[Ljavax.baja.sys.BValue;", false);
        }
        TYPE = Sys.loadType(clazz);
    }
}