/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  javax.baja.nre.util.Array
 */
package javax.baja.space;

import com.tridium.dataRecovery.BDataRecoveryComponentRecorder;
import com.tridium.sys.Nre;
import com.tridium.sys.schema.ComponentSlotMap;
import com.tridium.sys.station.Station;
import com.tridium.sys.transfer.DeleteOp;
import com.tridium.sys.transfer.IntraCompSpaceMove;
import com.tridium.util.ArrayUtil;
import com.tridium.util.ObjectUtil;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import javax.baja.category.BCategoryMask;
import javax.baja.category.BICategorizable;
import javax.baja.collection.BICollection;
import javax.baja.collection.BITable;
import javax.baja.collection.Column;
import javax.baja.collection.TableCursor;
import javax.baja.dataRecovery.BIDataRecoverySource;
import javax.baja.dataRecovery.IDataRecoveryRecord;
import javax.baja.log.Log;
import javax.baja.naming.BOrd;
import javax.baja.naming.BatchResolve;
import javax.baja.naming.OrdTarget;
import javax.baja.naming.SlotPath;
import javax.baja.naming.UnresolvedException;
import javax.baja.nav.BINavNode;
import javax.baja.nre.util.Array;
import javax.baja.registry.Registry;
import javax.baja.registry.TypeInfo;
import javax.baja.security.BIProtected;
import javax.baja.security.BPermissions;
import javax.baja.space.BSpace;
import javax.baja.space.LoadCallbacks;
import javax.baja.space.Mark;
import javax.baja.space.SubscribeCallbacks;
import javax.baja.space.TrapCallbacks;
import javax.baja.spy.SpyWriter;
import javax.baja.sync.Transaction;
import javax.baja.sys.BBoolean;
import javax.baja.sys.BComplex;
import javax.baja.sys.BComponent;
import javax.baja.sys.BComponentEvent;
import javax.baja.sys.BDouble;
import javax.baja.sys.BFloat;
import javax.baja.sys.BIMixIn;
import javax.baja.sys.BIPropertyContainer;
import javax.baja.sys.BIPropertySpace;
import javax.baja.sys.BIcon;
import javax.baja.sys.BInteger;
import javax.baja.sys.BLong;
import javax.baja.sys.BObject;
import javax.baja.sys.BString;
import javax.baja.sys.BValue;
import javax.baja.sys.BajaRuntimeException;
import javax.baja.sys.Clock;
import javax.baja.sys.Context;
import javax.baja.sys.Cursor;
import javax.baja.sys.Property;
import javax.baja.sys.Slot;
import javax.baja.sys.SlotCursor;
import javax.baja.sys.Sys;
import javax.baja.sys.Type;
import javax.baja.sys.TypeSubscriber;
import javax.baja.util.LexiconText;

/*
 * Illegal identifiers - consider using --renameillegalidents true
 */
public class BComponentSpace
extends BSpace
implements BICategorizable,
BIProtected,
BIPropertySpace,
BIDataRecoverySource {
    public static final Type TYPE;
    static Log mixInLog;
    static TypeInfo nullProxyExt;
    HashMap map;
    long nextHandle;
    LoadCallbacks loadCallbacks;
    TrapCallbacks trapCallbacks;
    SubscribeCallbacks subscribeCallbacks;
    BComponent root;
    BOrd ordInSession;
    Type[] mixIns;
    boolean holdMixInUpdates;
    private BDataRecoveryComponentRecorder dataRecoveryRestorer;
    long nextHandleOnCriticalStart;
    Array reassignedHandles;
    HashMap typeSubscriptionMap;
    static /* synthetic */ Class class$javax$baja$space$BComponentSpace;
    static /* synthetic */ Class class$javax$baja$sys$TypeSubscriber;
    static /* synthetic */ Class class$javax$baja$naming$BOrd;
    static /* synthetic */ Class class$java$lang$Object;
    static /* synthetic */ Class class$javax$baja$sys$Context;
    static /* synthetic */ Class class$java$lang$String;
    static /* synthetic */ Class class$java$lang$Integer;
    static /* synthetic */ Class class$java$lang$Long;
    static /* synthetic */ Class class$java$lang$Float;
    static /* synthetic */ Class class$java$lang$Double;
    static /* synthetic */ Class class$java$lang$Boolean;

    public Type getType() {
        return TYPE;
    }

    public BComponent getRootComponent() {
        return this.root;
    }

    public synchronized void setRootComponent(BComponent bComponent) {
        this.root = bComponent;
        this.map.clear();
        if (bComponent != null && bComponent.getComponentSpace() == null) {
            ((ComponentSlotMap)bComponent.fw(1)).mount(this, null, null);
        }
    }

    public boolean isSpaceReadonly() {
        return false;
    }

    public int getComponentCount() {
        return this.map.size();
    }

    public BComponent[] getAllComponents() {
        return this.map.values().toArray(new BComponent[this.map.size()]);
    }

    public long getDefaultLeaseTime() {
        return 60000L;
    }

    /*
     * Exception decompiling
     */
    public void subscribe(Type[] var1_1, TypeSubscriber var2_2) {
        /*
         * This method has failed to decompile.  When submitting a bug report, please provide this stack trace, and (if you hold appropriate legal rights) the relevant class file.
         * 
         * org.benf.cfr.reader.util.ConfusedCFRException: Back jump on a try block [egrp 0[TRYBLOCK] [1 : 20->79)] java.lang.Throwable
         *     at org.benf.cfr.reader.bytecode.analysis.opgraph.Op02WithProcessedDataAndRefs.insertExceptionBlocks(Op02WithProcessedDataAndRefs.java:2283)
         *     at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisInner(CodeAnalyser.java:415)
         *     at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisOrWrapFail(CodeAnalyser.java:278)
         *     at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysis(CodeAnalyser.java:201)
         *     at org.benf.cfr.reader.entities.attributes.AttributeCode.analyse(AttributeCode.java:94)
         *     at org.benf.cfr.reader.entities.Method.analyse(Method.java:531)
         *     at org.benf.cfr.reader.entities.ClassFile.analyseMid(ClassFile.java:1055)
         *     at org.benf.cfr.reader.entities.ClassFile.analyseTop(ClassFile.java:942)
         *     at org.benf.cfr.reader.Driver.doJarVersionTypes(Driver.java:257)
         *     at org.benf.cfr.reader.Driver.doJar(Driver.java:139)
         *     at org.benf.cfr.reader.CfrDriverImpl.analyse(CfrDriverImpl.java:76)
         *     at org.benf.cfr.reader.Main.main(Main.java:54)
         */
        throw new IllegalStateException("Decompilation failed");
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     * Converted monitor instructions to comments
     * Lifted jumps to return sites
     */
    public void unsubscribe(Type[] typeArray, TypeSubscriber typeSubscriber) {
        int n = 0;
        while (n < typeArray.length) {
            Array[] arrayArray = (Array[])this.typeSubscriptionMap.get(typeArray[n]);
            if (arrayArray != null) {
                Array[] arrayArray2 = arrayArray;
                // MONITORENTER : arrayArray
                int n2 = 0;
                while (true) {
                    if (n2 >= arrayArray.length) {
                        // MONITOREXIT : arrayArray2
                        break;
                    }
                    if (arrayArray[n2] != null) {
                        arrayArray[n2].remove((Object)typeSubscriber);
                        if (arrayArray[n2].isEmpty()) {
                            arrayArray[n2] = null;
                        }
                    }
                    ++n2;
                }
            }
            ++n;
        }
    }

    /*
     * Exception decompiling
     */
    public void updateSubscription(Type[] var1_1, TypeSubscriber var2_2) {
        /*
         * This method has failed to decompile.  When submitting a bug report, please provide this stack trace, and (if you hold appropriate legal rights) the relevant class file.
         * 
         * org.benf.cfr.reader.util.ConfusedCFRException: Back jump on a try block [egrp 0[TRYBLOCK] [1 : 20->79)] java.lang.Throwable
         *     at org.benf.cfr.reader.bytecode.analysis.opgraph.Op02WithProcessedDataAndRefs.insertExceptionBlocks(Op02WithProcessedDataAndRefs.java:2283)
         *     at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisInner(CodeAnalyser.java:415)
         *     at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysisOrWrapFail(CodeAnalyser.java:278)
         *     at org.benf.cfr.reader.bytecode.CodeAnalyser.getAnalysis(CodeAnalyser.java:201)
         *     at org.benf.cfr.reader.entities.attributes.AttributeCode.analyse(AttributeCode.java:94)
         *     at org.benf.cfr.reader.entities.Method.analyse(Method.java:531)
         *     at org.benf.cfr.reader.entities.ClassFile.analyseMid(ClassFile.java:1055)
         *     at org.benf.cfr.reader.entities.ClassFile.analyseTop(ClassFile.java:942)
         *     at org.benf.cfr.reader.Driver.doJarVersionTypes(Driver.java:257)
         *     at org.benf.cfr.reader.Driver.doJar(Driver.java:139)
         *     at org.benf.cfr.reader.CfrDriverImpl.analyse(CfrDriverImpl.java:76)
         *     at org.benf.cfr.reader.Main.main(Main.java:54)
         */
        throw new IllegalStateException("Decompilation failed");
    }

    public boolean isSubscribed(Type type) {
        if (type == null) {
            return false;
        }
        if (this.typeSubscriptionMap.containsKey(type)) {
            Array[] arrayArray = (Array[])this.typeSubscriptionMap.get(type);
            int n = 0;
            while (n < arrayArray.length) {
                if (arrayArray[n] != null && arrayArray[n].size() > 0) {
                    return true;
                }
                ++n;
            }
        }
        return this.isSubscribed(type.getSuperType());
    }

    public boolean isSubscribed(Type type, int n) {
        if (type == null) {
            return false;
        }
        if (n == -1) {
            return false;
        }
        if (!this.typeSubscriptionMap.containsKey(type)) {
            return this.isSubscribed(type.getSuperType(), n);
        }
        Array[] arrayArray = (Array[])this.typeSubscriptionMap.get(type);
        if (arrayArray[n] == null || arrayArray[n].size() == 0) {
            return this.isSubscribed(type.getSuperType(), n);
        }
        return true;
    }

    public void event(BComponentEvent bComponentEvent) {
        this.event(bComponentEvent, bComponentEvent.getSourceComponent().getType());
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     * Converted monitor instructions to comments
     * Lifted jumps to return sites
     */
    private final void event(BComponentEvent bComponentEvent, Type type) {
        if (type == null) return;
        if (type.getModule().getModuleName().equals("event")) {
            return;
        }
        Array[] arrayArray = (Array[])this.typeSubscriptionMap.get(type);
        if (arrayArray != null) {
            block6: {
                Array[] arrayArray2 = arrayArray;
                // MONITORENTER : arrayArray
                if (arrayArray[bComponentEvent.getId()] == null || arrayArray[bComponentEvent.getId()].size() <= 0) break block6;
                int n = 0;
                while (n < arrayArray[bComponentEvent.getId()].size()) {
                    ((TypeSubscriber)arrayArray[bComponentEvent.getId()].get(n)).event(bComponentEvent);
                    ++n;
                }
            }
            // MONITOREXIT : arrayArray2
        }
        this.event(bComponentEvent, type.getSuperType());
    }

    public BOrd getOrdInSession() {
        return this.ordInSession;
    }

    public LoadCallbacks getLoadCallbacks() {
        return this.loadCallbacks;
    }

    public void setLoadCallbacks(LoadCallbacks loadCallbacks) {
        this.loadCallbacks = loadCallbacks;
    }

    public TrapCallbacks getTrapCallbacks() {
        return this.trapCallbacks;
    }

    public void setTrapCallbacks(TrapCallbacks trapCallbacks) {
        this.trapCallbacks = trapCallbacks;
    }

    public SubscribeCallbacks getSubscribeCallbacks() {
        return this.subscribeCallbacks;
    }

    public void setSubscribeCallbacks(SubscribeCallbacks subscribeCallbacks) {
        this.subscribeCallbacks = subscribeCallbacks;
    }

    public final void update(BComponent bComponent, int n) {
        this.getSubscribeCallbacks().update(bComponent, n);
    }

    public final Transaction newTransaction() {
        return this.newTransaction(null);
    }

    public Transaction newTransaction(Context context) {
        return new Transaction(this, context){};
    }

    public void modified(BComponent bComponent, Context context) {
    }

    public void childParented(BComponent bComponent, Property property, BValue bValue, Context context) {
    }

    public void childUnparented(BComponent bComponent, Property property, BValue bValue, Context context) {
    }

    public boolean fireDirectCallbacks() {
        return true;
    }

    public boolean isProxyComponentSpace() {
        return false;
    }

    public void sync() throws Exception {
    }

    public final BComponent findByHandle(Object object) {
        return this.findByHandle(object, true);
    }

    public BComponent findByHandle(Object object, boolean bl) {
        return this.doFindByHandle(object, bl);
    }

    protected BComponent doFindByHandle(Object object, boolean bl) {
        return (BComponent)this.map.get(object);
    }

    public final BComponent resolveByHandle(Object object) {
        BComponent bComponent = this.findByHandle(object);
        if (bComponent != null) {
            return bComponent;
        }
        throw new UnresolvedException(String.valueOf(object));
    }

    public SlotPath handleToSlotPath(Object object) {
        BComponent bComponent = (BComponent)this.map.get(object);
        if (bComponent == null) {
            return null;
        }
        return bComponent.getSlotPath();
    }

    public SlotPath[] handlesToSlotPaths(Object[] objectArray) {
        SlotPath[] slotPathArray = new SlotPath[objectArray.length];
        int n = 0;
        while (n < objectArray.length) {
            slotPathArray[n] = this.handleToSlotPath(objectArray[n]);
            ++n;
        }
        return slotPathArray;
    }

    public Type[] getEnabledMixIns() {
        return (Type[])this.mixIns.clone();
    }

    public synchronized void enableMixIn(Type type) {
        if (this.isProxyComponentSpace()) {
            throw new IllegalStateException("Cannot call on proxy space");
        }
        if (!type.is(BIMixIn.TYPE)) {
            throw new IllegalArgumentException(type.toString() + " does not implement baja:IMixIn");
        }
        int n = 0;
        while (n < this.mixIns.length) {
            if (this.mixIns[n] == type) {
                return;
            }
            ++n;
        }
        this.mixIns = (Type[])ArrayUtil.addOne(this.mixIns, type);
        this.updateMixIns();
        if (Sys.getStation() == this.root) {
            Station.broadcastStationMixIns();
        }
    }

    public synchronized void disableMixIn(Type type) {
        if (this.isProxyComponentSpace()) {
            throw new IllegalStateException("Cannot call on proxy space");
        }
        int n = -1;
        int n2 = 0;
        while (n2 < this.mixIns.length) {
            if (this.mixIns[n2] == type) {
                n = n2;
                break;
            }
            ++n2;
        }
        if (n < 0) {
            return;
        }
        this.mixIns = (Type[])ArrayUtil.removeOne((Object[])this.mixIns, n);
        if (Sys.getStation() == this.root) {
            Station.broadcastStationMixIns();
        }
    }

    private final synchronized void updateMixIns() {
        if (this.holdMixInUpdates) {
            return;
        }
        long l = Clock.ticks();
        if (this.isProxyComponentSpace()) {
            throw new IllegalStateException("Cannot call on proxy space");
        }
        BComponent[] bComponentArray = new BComponent[this.map.size()];
        this.map.values().toArray(bComponentArray);
        int n = 0;
        while (n < bComponentArray.length) {
            this.updateMixIns(bComponentArray[n]);
            ++n;
        }
        long l2 = Clock.ticks();
        mixInLog.message("Updated [" + (l2 - l) + "ms]");
    }

    private final synchronized void updateMixIns(BComponent bComponent) {
        if (this.holdMixInUpdates) {
            return;
        }
        TypeInfo typeInfo = bComponent.getType().getTypeInfo();
        Registry registry = Sys.getRegistry();
        int n = this.mixIns.length;
        int n2 = 0;
        while (n2 < n) {
            if (registry.isAgent(this.mixIns[n2].getTypeInfo(), typeInfo)) {
                this.addMixInIfNeeded(bComponent, this.mixIns[n2]);
            }
            ++n2;
        }
    }

    private final void addMixInIfNeeded(BComponent bComponent, Type type) {
        try {
            if (bComponent.getMixIn(type) != null) {
                return;
            }
            if (mixInLog.isTraceOn()) {
                mixInLog.trace("Add " + type + " to " + bComponent.toPathString());
            }
            BValue bValue = (BValue)type.getInstance();
            bComponent.add(type.toString().replace(':', '_'), bValue);
        }
        catch (Exception exception) {
            mixInLog.error("Cannot add mix in " + type + " to " + bComponent.toPathString(), exception);
        }
    }

    private final synchronized void setHoldMixInUpdates(boolean bl) {
        this.holdMixInUpdates = bl;
        if (!bl && this.mixIns.length > 0) {
            this.updateMixIns();
        }
    }

    public BCategoryMask getCategoryMask() {
        BCategoryMask bCategoryMask = this.root.getCategoryMask();
        if (bCategoryMask == null || bCategoryMask.isNull()) {
            return BCategoryMask.make("1");
        }
        return bCategoryMask;
    }

    public BCategoryMask getAppliedCategoryMask() {
        return this.getCategoryMask();
    }

    public BPermissions getPermissions(Context context) {
        if (context != null && context.getUser() != null) {
            return context.getUser().getPermissionsFor(this);
        }
        return BPermissions.all;
    }

    public boolean canRead(OrdTarget ordTarget) {
        return ordTarget.getPermissionsForTarget().hasOperatorRead();
    }

    public boolean canWrite(OrdTarget ordTarget) {
        return ordTarget.getPermissionsForTarget().hasOperatorWrite();
    }

    public boolean canInvoke(OrdTarget ordTarget) {
        return ordTarget.getPermissionsForTarget().hasOperatorInvoke();
    }

    public Cursor findObjects(Type type, BOrd bOrd, String string, Context context) {
        return this.findObjects(type, bOrd, string, (Type)null, context);
    }

    public Cursor findObjects(Type type, BOrd bOrd, String string, Type type2, Context context) {
        return new ContainerCursor(this.findContainers(type, bOrd, context), string, type2, context);
    }

    public Cursor findObjects(Type type, BOrd bOrd, String string, BValue bValue, Context context) {
        return new ContainerCursor(this.findContainers(type, bOrd, context), string, bValue, context);
    }

    public Cursor findDistinctValues(Type type, BOrd bOrd, String string, Context context) {
        return this.findDistinctValues(type, bOrd, string, null, context);
    }

    public Cursor findDistinctValues(Type type, BOrd bOrd, String string, Type type2, Context context) {
        return new DistinctPropertyCursor(this.findContainers(type, bOrd, context), string, type2, context);
    }

    public boolean addIndex(String string, Context context) {
        throw new UnsupportedOperationException();
    }

    public void removeIndex(String string, Context context) {
        throw new UnsupportedOperationException();
    }

    private final Cursor findContainers(Type type, BOrd bOrd, Context context) {
        Type type2 = type != null ? type : BComponent.TYPE;
        boolean bl = false;
        if (this.isProxyComponentSpace() && type2.is(BComponent.TYPE)) {
            bl = true;
        }
        boolean bl2 = bl;
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("bql:select ");
        if (bl2) {
            stringBuffer.append("navOrd");
        } else {
            stringBuffer.append("*");
        }
        stringBuffer.append(" from ").append(type2.toString());
        BOrd bOrd2 = null;
        bOrd2 = bOrd == null || bOrd.isNull() ? BOrd.make(this.getNavOrd(), stringBuffer.toString()) : BOrd.make(bOrd, stringBuffer.toString());
        BITable bITable = ((BICollection)((Object)bOrd2.resolve(this).get())).toTable();
        Column column = bITable.getColumns().get(0);
        TableCursor tableCursor = (TableCursor)bITable.cursor();
        if (!bl2) {
            return tableCursor;
        }
        Class clazz = class$javax$baja$naming$BOrd;
        if (clazz == null) {
            clazz = class$javax$baja$naming$BOrd = BComponentSpace.class("[Ljavax.baja.naming.BOrd;", false);
        }
        Array array = new Array(clazz);
        while (tableCursor.next()) {
            array.add((Object)BOrd.make(tableCursor.get(column).toString(null)).relativizeToSession());
        }
        BOrd[] bOrdArray = (BOrd[])array.trim();
        BatchResolve batchResolve = new BatchResolve(bOrdArray).resolve(this);
        BObject[] bObjectArray = batchResolve.getTargetComponents();
        BComponent.lease((BComponent[])bObjectArray, 0);
        return new ArrayCursor(bObjectArray, context);
    }

    public Object fw(int n, Object object, Object object2, Object object3, Object object4) {
        switch (n) {
            case 101: {
                this.mount(object);
                return null;
            }
            case 102: {
                this.unmount(object);
                return null;
            }
            case 103: {
                return this.generateHandles((Integer)object);
            }
            case 111: {
                return this.generateUniqueName((String)object, (ObjectUtil.NameContainer)object2);
            }
            case 104: {
                return null;
            }
            case 105: {
                this.setHoldMixInUpdates((Boolean)object);
                return null;
            }
            case 112: {
                return DeleteOp.make((Mark)object, (Context)object2);
            }
            case 106: {
                return ((DeleteOp)object).doDelete();
            }
            case 107: {
                return ((DeleteOp)object).doUndelete();
            }
            case 109: {
                return this.rpc((BComponent)object, (String)object2, object3, (Context)object4);
            }
            case 113: {
                return new IntraCompSpaceMove();
            }
            case 1002: {
                this.dataRecoveryRestorer = (BDataRecoveryComponentRecorder)object;
                if (this.dataRecoveryRestorer != null) {
                    this.nextHandleOnCriticalStart = this.nextHandle;
                    this.reassignedHandles = new Array();
                } else {
                    this.reassignedHandles = null;
                }
                return null;
            }
            case 116: {
                return this.map.get(object);
            }
        }
        return super.fw(n, object, object2, object3, object4);
    }

    /*
     * Enabled aggressive block sorting
     * Enabled unnecessary exception pruning
     * Enabled aggressive exception aggregation
     */
    protected synchronized void mount(Object object) {
        ComponentSlotMap componentSlotMap = (ComponentSlotMap)object;
        BComponent bComponent = (BComponent)componentSlotMap.getInstance();
        this.nextHandle = BComponentSpace.solveForNextHandle(bComponent, this.nextHandle);
        if (componentSlotMap.getSpace() != null) {
            throw new IllegalStateException("Component already mounted: " + componentSlotMap.getInstance());
        }
        Object object2 = componentSlotMap.getHandle();
        if (object2 == null || object2.toString().startsWith("copy-")) {
            object2 = this.generateHandle();
        }
        componentSlotMap.setHandle(object2);
        BComponent bComponent2 = (BComponent)this.map.get(object2);
        if (bComponent2 != null) {
            boolean bl;
            block15: {
                bl = false;
                try {
                    Object object3;
                    Object object4;
                    long l;
                    if (this.dataRecoveryRestorer == null || (l = Long.parseLong((String)object2, 16)) >= this.nextHandleOnCriticalStart && !this.reassignedHandles.contains(object2)) break block15;
                    boolean bl2 = false;
                    if (bComponent2.getType().getTypeInfo() == nullProxyExt) {
                        bl2 = true;
                    }
                    if (!(bl = bl2)) {
                        object4 = bComponent2.getParent();
                        object3 = bComponent2.getPropertyInParent();
                        Property property = componentSlotMap.getPropertyInParent();
                        if (object4 == componentSlotMap.getParent() && object3 != null && property != null && object3.equals(property)) {
                            bl = true;
                        } else {
                            while (object4 != null && object3 != null) {
                                int n = ((BComplex)object4).getFlags((Slot)object3);
                                boolean bl3 = false;
                                if ((n & 2) != 0) {
                                    bl3 = true;
                                }
                                if (bl = bl3) break;
                                object3 = ((BComplex)object4).getPropertyInParent();
                                object4 = ((BComplex)object4).getParent();
                            }
                        }
                    }
                    if (!bl) break block15;
                    object4 = this.generateHandle();
                    ((ComponentSlotMap)bComponent2.fw(1)).setHandle(object4);
                    this.map.put(object4, bComponent2);
                    this.reassignedHandles.remove(object2);
                    this.reassignedHandles.add(object4);
                    try {
                        if (BDataRecoveryComponentRecorder.LOG.isTraceOn()) {
                            object3 = new StringBuffer();
                            ((StringBuffer)object3).append("Reassigned handle for ").append(bComponent2.toPathString());
                            ((StringBuffer)object3).append(", old=").append(object2);
                            ((StringBuffer)object3).append(", new=").append(object4);
                            ((StringBuffer)object3).append(" due to conflict with data recovery restore for component ").append(bComponent.toPathString());
                            BDataRecoveryComponentRecorder.LOG.trace(((StringBuffer)object3).toString());
                        }
                    }
                    catch (Throwable throwable) {}
                }
                catch (Throwable throwable) {
                    throwable.printStackTrace();
                    throw new IllegalStateException("Duplicate handle: " + object2 + ' ' + bComponent2.toDebugString() + " ; " + bComponent.toDebugString());
                }
            }
            if (!bl) {
                throw new IllegalStateException("Duplicate handle: " + object2 + ' ' + bComponent2.toDebugString() + " ; " + bComponent.toDebugString());
            }
        }
        this.map.put(object2, bComponent);
        this.updateMixIns(bComponent);
    }

    protected synchronized void unmount(Object object) {
        ComponentSlotMap componentSlotMap = (ComponentSlotMap)object;
        if (componentSlotMap.getSpace() != this) {
            throw new IllegalStateException("Component not mounted: " + componentSlotMap);
        }
        this.map.remove(componentSlotMap.getHandle());
    }

    synchronized Object[] generateHandles(int n) {
        Object[] objectArray = new Object[n];
        int n2 = 0;
        while (n2 < n) {
            objectArray[n2] = this.generateHandle();
            ++n2;
        }
        return objectArray;
    }

    synchronized Object generateHandle() {
        if (this.isProxyComponentSpace()) {
            throw new IllegalStateException("generateHandle in proxy space");
        }
        return Long.toHexString(this.nextHandle++);
    }

    String generateUniqueName(String string, ObjectUtil.NameContainer nameContainer) {
        return ObjectUtil.generateUniqueSlotName(string, nameContainer);
    }

    BValue rpc(BComponent bComponent, String string, Object object, Context context) {
        int n = string.indexOf(58);
        String string2 = string.substring(0, n);
        String string3 = string.substring(n + 1);
        if (string2.equals("reflect")) {
            return this.rpcReflect(bComponent, string3, object, context);
        }
        if (string2.equals("reflectProperty")) {
            return this.rpcReflectProperty(bComponent, string3, object, context);
        }
        return null;
    }

    BValue rpcReflect(BComponent bComponent, String string, Object object, Context context) {
        return BComponentSpace.wrapRpcResult(BComponentSpace.invokeRpc(bComponent, string, object, context));
    }

    BValue rpcReflectProperty(BComponent bComponent, String string, Object object, Context context) {
        int n = string.indexOf(58);
        String string2 = string.substring(0, n);
        String string3 = string.substring(n + 1);
        BValue bValue = bComponent.get(string2);
        return BComponentSpace.wrapRpcResult(BComponentSpace.invokeRpc(bValue, string3, object, context));
    }

    private static final Object invokeRpc(Object object, String string, Object object2, Context context) {
        try {
            Class clazz;
            Class<?> clazz2 = object.getClass();
            Class[] classArray = new Class[2];
            Class clazz3 = class$java$lang$Object;
            if (clazz3 == null) {
                clazz3 = classArray[0] = (class$java$lang$Object = BComponentSpace.class("[Ljava.lang.Object;", false));
            }
            if ((clazz = class$javax$baja$sys$Context) == null) {
                clazz = class$javax$baja$sys$Context = BComponentSpace.class("[Ljavax.baja.sys.Context;", false);
            }
            classArray[1] = clazz;
            Method method = clazz2.getMethod(string, classArray);
            return method.invoke(object, object2, context);
        }
        catch (Exception exception) {
            exception.printStackTrace();
            return null;
        }
    }

    private static final BValue wrapRpcResult(Object object) {
        if (object == null) {
            return null;
        }
        if (object instanceof BValue) {
            return (BValue)object;
        }
        Class<?> clazz = object.getClass();
        Class clazz2 = class$java$lang$String;
        if (clazz2 == null) {
            clazz2 = class$java$lang$String = BComponentSpace.class("[Ljava.lang.String;", false);
        }
        if (clazz2.isAssignableFrom(clazz)) {
            return BString.make((String)object);
        }
        Class clazz3 = class$java$lang$Integer;
        if (clazz3 == null) {
            clazz3 = class$java$lang$Integer = BComponentSpace.class("[Ljava.lang.Integer;", false);
        }
        if (clazz3.isAssignableFrom(clazz)) {
            return BInteger.make((Integer)object);
        }
        Class clazz4 = class$java$lang$Long;
        if (clazz4 == null) {
            clazz4 = class$java$lang$Long = BComponentSpace.class("[Ljava.lang.Long;", false);
        }
        if (clazz4.isAssignableFrom(clazz)) {
            return BLong.make((Long)object);
        }
        Class clazz5 = class$java$lang$Float;
        if (clazz5 == null) {
            clazz5 = class$java$lang$Float = BComponentSpace.class("[Ljava.lang.Float;", false);
        }
        if (clazz5.isAssignableFrom(clazz)) {
            return BFloat.make(((Float)object).floatValue());
        }
        Class clazz6 = class$java$lang$Double;
        if (clazz6 == null) {
            clazz6 = class$java$lang$Double = BComponentSpace.class("[Ljava.lang.Double;", false);
        }
        if (clazz6.isAssignableFrom(clazz)) {
            return BDouble.make((Double)object);
        }
        Class clazz7 = class$java$lang$Boolean;
        if (clazz7 == null) {
            clazz7 = class$java$lang$Boolean = BComponentSpace.class("[Ljava.lang.Boolean;", false);
        }
        if (clazz7.isAssignableFrom(clazz)) {
            return BBoolean.make((Boolean)object);
        }
        throw new BajaRuntimeException("Cannot return result of type " + object.getClass());
    }

    public boolean hasNavChildren() {
        boolean bl = false;
        if (this.root != null) {
            bl = true;
        }
        return bl;
    }

    public BINavNode getNavChild(String string) {
        if (this.root == null) {
            return null;
        }
        return this.root.getNavChild(string);
    }

    public BINavNode[] getNavChildren() {
        if (this.root == null) {
            return new BINavNode[0];
        }
        return this.root.getNavChildren();
    }

    public BIcon getNavIcon() {
        if (this.root == null) {
            return this.getIcon();
        }
        return this.root.getNavIcon();
    }

    public BOrd getNavOrd() {
        if (this.root == null) {
            return super.getNavOrd();
        }
        return this.root.getNavOrd();
    }

    private static final long solveForNextHandle(BComponent bComponent, long l) {
        Object object = bComponent.getHandle();
        if (object != null && !object.toString().startsWith("copy-")) {
            try {
                long l2 = Long.parseLong(object.toString(), 16);
                if (l2 >= l) {
                    l = l2 + 1L;
                }
            }
            catch (Exception exception) {}
        }
        SlotCursor slotCursor = bComponent.getProperties();
        while (slotCursor.nextComponent()) {
            l = Math.max(l, BComponentSpace.solveForNextHandle(slotCursor.get().asComponent(), l));
        }
        return l;
    }

    public void spy(SpyWriter spyWriter) throws Exception {
        spyWriter.startProps();
        spyWriter.trTitle("ComponentSpace", 2);
        spyWriter.prop((Object)"map.size", this.map.size());
        spyWriter.prop((Object)"nextHandle", Long.toHexString(this.nextHandle));
        spyWriter.prop((Object)"categoryMask", this.getCategoryMask());
        spyWriter.prop((Object)"defaultLeaseTime", this.getDefaultLeaseTime());
        spyWriter.trTitle("Enabled MixIns [" + this.mixIns.length + ']', 2);
        spyWriter.w("<tr>").th("MixIn").th("On").w("</tr>\n");
        int n = 0;
        while (n < this.mixIns.length) {
            spyWriter.tr(this.mixIns[n], this.mixInOn(this.mixIns[n]));
            ++n;
        }
        spyWriter.endProps();
        super.spy(spyWriter);
    }

    String mixInOn(Type type) {
        try {
            StringBuffer stringBuffer = new StringBuffer("{");
            TypeInfo[] typeInfoArray = type.getTypeInfo().getAgentInfo().getAgentOn();
            int n = 0;
            while (n < typeInfoArray.length) {
                if (n > 0) {
                    stringBuffer.append(", ");
                }
                stringBuffer.append(typeInfoArray[n]);
                ++n;
            }
            stringBuffer.append("}");
            return stringBuffer.toString();
        }
        catch (Exception exception) {
            return exception.toString();
        }
    }

    void dumpMap() {
        System.out.println("ComponentSpace.map");
        Iterator iterator = this.map.keySet().iterator();
        while (iterator.hasNext()) {
            Object k = iterator.next();
            Object v = this.map.get(k);
            System.out.println("  " + k + " = " + v);
        }
    }

    public boolean dataRecoveryRestore(IDataRecoveryRecord iDataRecoveryRecord) throws Exception {
        if (this.dataRecoveryRestorer != null) {
            return this.dataRecoveryRestorer.restore(this, iDataRecoveryRecord);
        }
        return false;
    }

    public void dataRecoveryRestoreComplete() {
    }

    public void dataRecoverySpy(SpyWriter spyWriter, Iterator iterator) throws Exception {
        BDataRecoveryComponentRecorder bDataRecoveryComponentRecorder = Nre.serviceManager.getDataRecoveryComponentRecorder(this);
        if (bDataRecoveryComponentRecorder != null) {
            bDataRecoveryComponentRecorder.dataRecoverySpy(this, spyWriter, iterator);
        }
    }

    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 final /* synthetic */ void this() {
        this.map = new HashMap();
        this.nextHandle = 1L;
        this.loadCallbacks = new LoadCallbacks();
        this.trapCallbacks = new TrapCallbacks();
        this.subscribeCallbacks = new SubscribeCallbacks();
        this.mixIns = new Type[0];
        this.dataRecoveryRestorer = null;
        this.nextHandleOnCriticalStart = 1L;
        this.reassignedHandles = null;
        this.typeSubscriptionMap = new HashMap();
    }

    public BComponentSpace(String string, LexiconText lexiconText, BOrd bOrd) {
        super(string, lexiconText);
        this.this();
        this.ordInSession = bOrd;
    }

    static {
        Class clazz = class$javax$baja$space$BComponentSpace;
        if (clazz == null) {
            clazz = class$javax$baja$space$BComponentSpace = BComponentSpace.class("[Ljavax.baja.space.BComponentSpace;", false);
        }
        TYPE = Sys.loadType(clazz);
        mixInLog = Log.getLog("sys.mixin");
        nullProxyExt = null;
        try {
            nullProxyExt = Sys.getRegistry().getType("control:NullProxyExt");
        }
        catch (Exception exception) {}
    }

    /*
     * Illegal identifiers - consider using --renameillegalidents true
     */
    static class ContainerCursor
    implements Cursor {
        Cursor iterator;
        String propertyName;
        Type propertyType;
        BValue propertyValue;
        Context cx;
        BObject current;
        static /* synthetic */ Class class$javax$baja$sys$BComponent;

        public Context getContext() {
            return this.cx;
        }

        public boolean next() {
            return this.next(null);
        }

        public boolean nextComponent() {
            Class clazz = class$javax$baja$sys$BComponent;
            if (clazz == null) {
                clazz = class$javax$baja$sys$BComponent = ContainerCursor.class("[Ljavax.baja.sys.BComponent;", false);
            }
            return this.next(clazz);
        }

        public boolean next(Class clazz) {
            while (this.iterator.next()) {
                BValue bValue;
                BObject bObject = this.iterator.get();
                if (!(bObject instanceof BIPropertyContainer) || clazz != null && !clazz.isInstance(bObject) || (bValue = ((BIPropertyContainer)((Object)bObject)).get(this.propertyName)) == null || this.propertyType != null && !bValue.getType().is(this.propertyType) || this.propertyValue != null && !bValue.equals(this.propertyValue)) continue;
                this.current = bObject;
                return true;
            }
            return false;
        }

        public BObject get() {
            return this.current;
        }

        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 final /* synthetic */ void this() {
            this.propertyType = null;
            this.propertyValue = null;
            this.current = null;
        }

        ContainerCursor(Cursor cursor, String string, Type type, Context context) {
            this.this();
            this.iterator = cursor;
            this.propertyName = string;
            this.propertyType = type;
            this.cx = context;
        }

        ContainerCursor(Cursor cursor, String string, BValue bValue, Context context) {
            this(cursor, string, bValue.getType(), context);
            this.propertyValue = bValue;
        }
    }

    /*
     * Illegal identifiers - consider using --renameillegalidents true
     */
    static class DistinctPropertyCursor
    implements Cursor {
        Cursor iterator;
        String propertyName;
        Type propertyType;
        Array propertyValues;
        Context cx;
        BObject current;
        static /* synthetic */ Class class$javax$baja$sys$BValue;
        static /* synthetic */ Class class$javax$baja$sys$BComponent;

        public Context getContext() {
            return this.cx;
        }

        public boolean next() {
            return this.next(null);
        }

        public boolean nextComponent() {
            Class clazz = class$javax$baja$sys$BComponent;
            if (clazz == null) {
                clazz = class$javax$baja$sys$BComponent = DistinctPropertyCursor.class("[Ljavax.baja.sys.BComponent;", false);
            }
            return this.next(clazz);
        }

        public boolean next(Class clazz) {
            while (this.iterator.next()) {
                BValue bValue;
                BObject bObject = this.iterator.get();
                if (!(bObject instanceof BIPropertyContainer) || (bValue = ((BIPropertyContainer)((Object)bObject)).get(this.propertyName)) == null || clazz != null && !clazz.isInstance(bValue) || this.propertyType != null && !bValue.getType().is(this.propertyType) || this.propertyValues.contains((Object)bValue)) continue;
                this.propertyValues.add((Object)bValue);
                this.current = bValue;
                return true;
            }
            return false;
        }

        public BObject get() {
            return this.current;
        }

        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 final /* synthetic */ void this() {
            this.propertyType = null;
            Class clazz = class$javax$baja$sys$BValue;
            if (clazz == null) {
                clazz = class$javax$baja$sys$BValue = DistinctPropertyCursor.class("[Ljavax.baja.sys.BValue;", false);
            }
            this.propertyValues = new Array(clazz);
            this.current = null;
        }

        DistinctPropertyCursor(Cursor cursor, String string, Type type, Context context) {
            this.this();
            this.iterator = cursor;
            this.propertyName = string;
            this.propertyType = type;
            this.cx = context;
        }
    }

    static class ArrayCursor
    implements Cursor {
        private BObject[] a;
        private Context cx;
        private int current;

        public BObject get() {
            return this.a[this.current];
        }

        public Context getContext() {
            return this.cx;
        }

        public boolean next() {
            if (this.current < this.a.length) {
                ++this.current;
            }
            boolean bl = false;
            if (this.current != this.a.length) {
                bl = true;
            }
            return bl;
        }

        public boolean next(Class clazz) {
            while (this.next()) {
                BObject bObject = this.get();
                if (!clazz.isInstance(bObject)) continue;
                return true;
            }
            return false;
        }

        public boolean nextComponent() {
            while (this.next()) {
                if (!(this.get() instanceof BComponent)) continue;
                return true;
            }
            return false;
        }

        ArrayCursor(BObject[] bObjectArray, Context context) {
            this.a = bObjectArray;
            this.cx = context;
            this.current = -1;
        }
    }
}