hash.inc

<?php
class Hash
{

    var $hash;
    
    var $tree_propagation;

    function Hash()
    {
        $this->hash = Array();
        $this->tree_propagation = Array();

    }//end constructor


    function isEmpty()
    {
        return empty($this->hash);

    }//end isEmpty()


    function _set($name, $value)
    {
        if (!isset($this->hash[$name])) {
            $this->hash[$name] = Array();
        }

        if (!is_array($value)) $value = Array($value);

        foreach ($value as $one_value) {
            if (!in_array($one_value, $this->hash[$name])) {
                $this->hash[$name][] = $one_value;
            }
        }

    }//end _set()


    function setEvent($event)
    {
        $this->_set('event',$event);

    }//end setEvent()


    function setAssetId($assetid)
    {
        $this->_set('assetid',$assetid);

    }//end setAssetId()


    function setAssetType($asset_type, $descendants=FALSE)
    {
        if (!empty($asset_type) && $GLOBALS['SQ_SYSTEM']->am->installed($asset_type)) {

            if ($descendants) {

                // Grab the list of types, put into the 'asset_type' field
                $type_descendants = $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($asset_type, TRUE);
                if (!empty($type_descendants)) {
                    $this->_set('asset_type', $type_descendants);
                }

            } else {
                $this->_set('asset_type', $asset_type);
            }

        }

    }//end setAssetType()


    function setLinkTree($tree_id, $propagation)
    {
        $this->_set('treeid',$tree_id);
        
        if (!is_array($tree_id)) $tree_id = Array($tree_id);
        foreach ($tree_id as $id){
            $this->tree_propagation[$id] = $propagation;
        }

    }//end setLinkTree()


    function setTriggerId($trigger_id)
    {
        $this->_set('triggerid',$trigger_id);

    }//end setTriggerId()


    function setLinkedId($linked_id, $is_major)
    {
        if (!$is_major) {
            $this->_set('parentid',$linked_id);
        } else {
            $this->_set('childid',$linked_id);
        }

    }//end setLinkedId()


    function setLinkedType($linked_type, $is_major)
    {
        if (!$is_major) {
            $this->_set('parent_type',$linked_type);
        } else {
            $this->_set('child_type',$linked_type);
        }

    }//end setLinkedType()


    function getHashCombinations()
    {
        $result = $this->hash;

        // make sure every field has data, and that no fields are null
        foreach ($result as $id => $data) {
            if (empty($result[$id])) $result[$id] = '-1';
        }


        $indicies = Array(
                        'event',
                        'assetid',
                        'asset_type',
                        'treeid',
                        'tree_propagate',
                        'triggerid',
                        'parentid',
                        'parent_type',
                        'childid',
                        'child_type',
                    );
        foreach ($indicies as $index) {
            if (!isset($result[$index])) $result[$index] = '-1';
        }
        
        $combinations = $this->_createCombinations($result);
        
        // Bug #5612, we should not create combinations of the 'tree_propagate' index, so manually populate.
        if ($result['treeid'] != '-1'){
            foreach ($combinations as &$data){
                $data['tree_propagate'] = $this->tree_propagation[$data['treeid']];
            }   
        }

        return $combinations;

    }//end getHashCombinations()


    function _createCombinations($source)
    {
        $result = Array();

        // step through each item in the source array
        // and make combinations of it with the other items,
        // preserving the position (index)
        // so the item with index 'a' will always be at index 'a'
        // if given an array of type Array(1=>'a',2=>'b',3=>'c'), the result will be the same array
        // if given Array(1=>Array('a','b'), 2=>Array('c')), the result is Array(Array(1=>'a',2=>'c'),Array(1=>'b',2=>'c'))
        // in short, this function creates a flat representation of the deep array, which can
        // easily be converted back to the deep version if needed, i.e. no information is lost

        // let's roll this one
        foreach ($source as $source_key => $source_item) {
            reset($result);
            $new_result = Array();

            if (!is_array($source_item)) {
                $source_item = Array($source_item);
            }

            if (empty($result)) {
                foreach ($source_item as $one_item) {
                    $new_result[] = Array($source_key => $one_item);
                }
            } else {
                foreach ($result as $res) {
                    foreach ($source_item as $one_item) {
                        $new_res = $res;
                        $new_res[$source_key] = $one_item;
                        $new_result[] = $new_res;
                    }
                }
            }

            $result = $new_result;
        }

        return $result;

    }//end _createCombinations()


}//end class


?>