BooleanExpression

library BooleanExpression /*


    */requires /*

    */Table        /*
    */Alloc        /*
    */LinkedList   /*
    */Initializer  /*


    *///! novjass

    |=====|
    | API |
    |=====|

        struct BoolExpr/*

          */readonly boolexpr boolexpr/*  The boolexpr of a BoolExpr

          */static method operator [] takes code c returns thistype/*
            - Returns a corresponding BoolExpr for the code argument
            - Creates a new BoolExpr is there is no BoolExpr created for the
              code yet

          */static method create takes code c returns BoolExpr/*
            - Creates a new BoolExpr using code

          */static method createEx takes boolexpr expr returns thistype/*
            - Creates a new BoolExpr using a boolexpr

          */method destroy takes nothing returns nothing/*
            - Destroys a BoolExpr and destroys its boolexpr if the BoolExpr
              is created using boolexprOr()/boolexprAnd()/boolexprNot()

          */method boolexprOr takes BoolExpr expr returns BoolExpr/*
            - Creates a new BoolExpr with a boolexpr created using Or()

          */method boolexprAnd takes BoolExpr expr returns BoolExpr/*
            - Creates a new BoolExpr with a boolexpr created using And()

          */method boolexprNot takes BoolExpr expr returns BoolExpr/*
            - Creates a new BoolExpr with a boolexpr created using Not()


      */struct BooleanExpression/*

          */readonly BoolExpr expression/*  The BoolExpr of the BooleanExpression

          */static method create takes nothing returns BooleanExpression/*
            - Creates a new BooleanExpression

          */method destroy takes nothing returns nothing/*
            - Destroys the BooleanExpression

          */method clear takes nothing returns BooleanExpression/*
            - Clears all BoolExprs registered to the BooleanExpression

          */method register takes BoolExpr expr returns BooleanExpression/*
            - Registers a BoolExpr to the BoolExpr of the BooleanExpression by
              joining them with boolexprOr()

          */method unregister takes BoolExpr expr returns BooleanExpression/*
            - Unregisters a BoolExpr from the BoolExpression

          */method duplicate takes nothing returns BooleanExpression/*
            - Creates a duplicate of the BooleanExpression containing the same
              BoolExpr nodes

    *///! endnovjass


    struct BoolExpr extends array

        private static Table expr
        private static Table canDestroy

        implement AllocT

        static method createEx takes boolexpr filter returns thistype
            local thistype this = allocate()
            local integer id = GetHandleId(filter)
            set expr.boolexpr[this] = filter
            if not expr.has(id) then
                set expr[id] = this
            endif
            return this
        endmethod

        static method create takes code c returns thistype
            return createEx(Filter(c))
        endmethod

        static method operator [] takes code c returns thistype
            local integer id = GetHandleId(Filter(c))
            if expr.has(id) then
                return expr[id]
            endif
            return create(c)
        endmethod

        method destroy takes nothing returns nothing
            call .deallocate()
            if canDestroy.boolean[this] then
                call DestroyBoolExpr(expr.boolexpr[this])
            endif
            call expr.boolexpr.remove(this)
            call canDestroy.boolean.remove(this)
        endmethod

        method boolexprOr takes thistype other returns thistype
            local thistype new = allocate()
            set canDestroy.boolean[new] = true
            set expr.boolexpr[new] = Or(expr.boolexpr[this], expr.boolexpr[other])
            return new
        endmethod

        method boolexprAnd takes thistype other returns thistype
            local thistype new = allocate()
            set canDestroy.boolean[new] = true
            set expr.boolexpr[new] = And(expr.boolexpr[this], expr.boolexpr[other])
            return new
        endmethod

        method boolexprNot takes nothing returns thistype
            local thistype new = allocate()
            set canDestroy.boolean[new] = true
            set expr.boolexpr[new] = Not(expr.boolexpr[this])
            return new
        endmethod

        method operator boolexpr takes nothing returns boolexpr
            return expr.boolexpr[this]
        endmethod

        private static method init takes nothing returns nothing
            set expr = Table.create()
            set canDestroy = Table.create()
        endmethod

        implement Initializer

    endstruct

    struct BooleanExpression extends array

        private static Table listHead
        private static Table parentTree
        private static Table childTree
        private static Table childNode
        private static HashTable instance

        implement AllocT

        static method create takes nothing returns thistype
            local thistype this = allocate()
            set listHead[this] = MasterList.create()
            return this
        endmethod

        method register takes BoolExpr expr returns thistype
            local BoolExpr new
            local MasterList newNode
            debug if instance[this].has(expr) then
                debug call debug("|CFFFF0000ERROR: Attempt to double-register BoolExpr[" + I2S(expr) + "] to BooleanExpression[" + I2S(this) + "]|R")
                debug return 0
            debug endif
            set newNode = MasterList.allocate()
            if not parentTree.has(this) then
                set new = BoolExpr.createEx(expr.boolexpr)
            else
                set new = BoolExpr(parentTree[this]).boolexprOr(expr)
            endif
            call MasterList(listHead[this]).insertNode(newNode)
            set instance[this][expr] = newNode
            set childNode[newNode] = expr
            set childTree[newNode] = new
            set parentTree[this] = new
            return this
        endmethod

        method unregister takes BoolExpr expr returns thistype
            local MasterList children
            local MasterList node
            local BoolExpr new
            local MasterList head = listHead[this]
            local Table t = instance[this]
            debug if not t.has(expr) then
                debug call debug("|CFFFF0000ERROR: Attempt to unregister an unregistered BoolExpr[" + I2S(expr) + "] from BooleanExpression[" + I2S(this) + "]|R")
                debug return 0
            debug endif
            set node = head.next
            loop
                exitwhen node == 0
                call BoolExpr(childTree[node]).destroy()
                set node = node.next
            endloop
            set node = t[expr]
            call node.removeNode()
            call node.deallocate()
            call t.remove(expr)
            set node = head.last
            call parentTree.remove(this)
            if node != 0 then
                loop
                    exitwhen node == head
                    if not parentTree.has(this) then
                        set new = BoolExpr.createEx(BoolExpr(childNode[node]).boolexpr)
                    else
                        set new = BoolExpr(parentTree[this]).boolexprOr(childNode[node])
                    endif
                    set childTree[node] = new
                    set parentTree[this] = new
                    set node = node.prev
                endloop
            endif
            return this
        endmethod

        method duplicate takes nothing returns thistype
            local MasterList head = listHead[this]
            local MasterList node = head.last
            set this = create()
            if node != 0 then
                loop
                    exitwhen node == head
                    call .register(childNode[node])
                    set node = node.prev
                endloop
            endif
            return this
        endmethod

        method operator expression takes nothing returns BoolExpr
            return parentTree[this]
        endmethod

        method clear takes nothing returns thistype
            local Table t = instance[this]
            local MasterList node = MasterList(listHead[this]).next
            loop
                exitwhen node == 0
                call BoolExpr(childTree[node]).destroy()
                call t.remove(childNode[node])
                call node.removeNode()
                call node.deallocate()
                set node = node.next
            endloop
            call instance.remove(this)
            call parentTree.remove(this)
            return this
        endmethod

        method destroy takes nothing returns nothing
            call .deallocate()
            call .clear()
            call MasterList(listHead[this]).deallocate()
            call listHead.remove(this)
        endmethod

        private static method init takes nothing returns nothing
            local TableArray table = TableArray[5]
            set listHead = table[0]
            set parentTree = table[1]
            set childTree = table[2]
            set childNode = table[3]
            set instance = table[4]
        endmethod

        implement Initializer

    endstruct


endlibrary