CodeInstrumentationReceiver.class.php

Go to the documentation of this file.

<?php
class CodeInstrumentationReceiver implements UmlSequenceDiagramFactoryInterface
{
    protected static $objCodeInstrumentationReceiver;

    protected $arrStack = array();

    protected $arrActors = array();

    protected $arrClasses = array();

    protected $arrMessages = array();

    protected $objUmlSequence = null;

    protected $objConfiguration;

    protected $objActualMessage;

    protected $objActualActor;
    
    public function setConfiguration( CodeInstrumentationReceiverConfiguration $objConfiguration )
    {
        $this->objConfiguration = $objConfiguration;
        return $this;
    }

    public function getConfiguration()
    {
        return $this->objConfiguration;
    }

    public function __construct()
    {
        // set the configuration file //
        $objConfiguration = new CodeInstrumentationReceiverConfiguration();
        $this->setConfiguration( $objConfiguration );

        // create the uml sequence diagram object //
        $this->objUmlSequence = new UmlSequenceDiagram();

        // create the user actor //     
        $objActorFrom = new UmlSequenceDiagramActor();
        $objActorFrom->setType( 'user' );
        $objActorFrom->setName( "user" );
        $objActorFrom->setId( sizeof( $this->arrActors ) + 1 );
        $this->arrActors[] = $objActorFrom;
        $this->arrStack[] = $objActorFrom;
        $this->objUmlSequence->addActor($objActorFrom);
    }

    public static function getInstance()
    {
        if( self::$objCodeInstrumentationReceiver ==  null )
        {
            self::$objCodeInstrumentationReceiver = new CodeInstrumentationReceiver();
        }
        return self::$objCodeInstrumentationReceiver;
    }

    public function renameMethod( $strMethod , $strClass )
    {
        switch( $strMethod )
        {
                // 1. if __construct replace by <<create>> //
            case "__construct":
            {
                $strMethod = ( "<<create>>" );
                break;
            }
            // 2. if __destruct replace by <<destroy>> //
            case "__destruct":
            {
                $strMethod = ( "<<destroy>>" );
                break;
            }
            // 3. other cases should append the "()" //
            default:
            {
                $objReflectedClass = new CodeReflectionClass( $strClass );
                $objReflectedMethod = $objReflectedClass->getMethod( $strMethod );
                $arrReflectedParameter = $objReflectedMethod->getParameters();
                $arrParams = array();
                foreach( $arrReflectedParameter as $objReflectedParameter )
                {
                    $arrParams[] = $objReflectedParameter->getCode();
                }
                $strMethod .= "( " . implode( " , " , $arrParams ) . " )";
                break;
            }
        }
        return $strMethod;
    }

    protected function shouldBeLog( $strClass , $strMethod )
    {
        if( ! $this->getConfiguration()->getActive() )
        {
            return false;
        }
        
        if( $this->getConfiguration()->getGatekeeperClasses()->match( $strClass ) == false )
        {
            return false;
        }

        // returns of it is a ignored method
        if( $this->getConfiguration()->getGatekeeperMethods()->match( $strMethod ) == false )
        {
            return false;
        }
        
        return true;
    }
    
    public function onEnterMethod( $uid , $strClassDefinition , $strMethod, $arrArguments )
    {
        // get the name of method as the diagram standart //
        $strClass               = CorujaClassManipulation::getClassNameFromClassDefinition( $strClassDefinition );
        $arrMethod      = explode( "::" , $strMethod );
        $strRealMethod  = array_pop( $arrMethod );
        $strMethod      = $this->renameMethod( $strRealMethod , $strClass);

        // get the namespace name //
        $strNamespace   = CorujaClassManipulation::getNamespaceFromClassDefinition( $strClassDefinition );

        if( ! array_key_exists( $strClass, $this->arrClasses ) )
        {
            $this->arrClasses[ $strClass ] = 0;
        }
        
         // apply receiver configurations
        if( $this->getConfiguration()->getMergeSameClassObjects() )
        {
            $uid = $strClass;
        }        

        if( ! $this->shouldBeLog( $strClass , $strRealMethod ) )
        {
                return $this;
        }
        
        // get the actor what the message is bring from  //
        $objActorFrom = current( $this->arrStack );
        //$objActorFrom = $this->arrStack[0];
        if( $objActorFrom  === false )
        {
            return $this;
        }

        // get the actor what the message is bring to //
        if( ! array_key_exists( $uid , $this->arrActors ) )
        {
                // create the actor to if he not exists //
            $this->arrClasses[ $strClass ]++;
            $objActorTo = new UmlSequenceDiagramActor();
            $objActorTo->setStereotype( $this->getConfiguration()->getMatchGroupStereotypes()->match( $strClass ) );
            $objActorTo->setClassName( $strClass );

            // object counter by class only make sence when has more the one
            // object of the same class
            if( $this->getConfiguration()->getMergeSameClassObjects() )
            {
                    $objActorTo->setName( $strClass );
            }
            else
            {
                    $objActorTo->setName( $strClass . '(' . $this->arrClasses[ $strClass ] . ')');
            }
            
            $objActorTo->setId(sizeof( $this->arrActors ) + 1  );
            $this->arrActors[ $uid ] = $objActorTo;
            $this->objUmlSequence->addActor($objActorTo);
        }
        else
        {
            $objActorTo = $this->arrActors[ $uid ];
        }
        
        if( !$this->getConfiguration()->getIgnoreRecursiveCalls() || ( $objActorFrom != $objActorTo ) )
        {
            // create the message //
            $objMessage = new UmlSequenceDiagramMessage();

            // set the message attributes //
            $objMessage->setMethod( $strRealMethod );
            $objMessage->setText( $strMethod );
            $objMessage->setActorFrom( $objActorFrom );
            $objMessage->setActorTo( $objActorTo );
            $objMessage->setType( 'call' );

            $objReflectedClass = new CodeReflectionClass( $strClass );
            $objReflectedMethod = $objReflectedClass->getMethod( $strRealMethod );
            $arrReflectedParameter = $objReflectedMethod->getParameters();

            // set the message values //
            foreach( $arrArguments as $intPos => $mixValue )
            {
                $objValue = new UmlSequenceDiagramValue();
                $objReflectedParameter = $arrReflectedParameter[ $intPos ];
                $strName = $objReflectedParameter->getName();
                $objValue->setName( $strName );
                $objValue->setValue( $mixValue );
                $objMessage->addValue( $objValue );
            }
            $objMessage->setTimeStart( microtime( true ) );

            // append the message  //
            $this->objUmlSequence->addMessage( $objMessage );
            $this->objActualMessage = $objMessage;
            $this->arrMessages[]        = $objMessage;
        }
        
        array_unshift( $this->arrStack , $objActorTo );

        $this->objActualActor = $objActorFrom;
        return $this;
    }

    public function onLeaveMethod( $uid , $strClassDefinition, $strMethod, $mixReturn )
    {
        // get the name of method as the diagram standart //
        $strClass               = CorujaClassManipulation::getClassNameFromClassDefinition( $strClassDefinition );
        $arrMethod      = explode( "::" , $strMethod );
        $strRealMethod  = array_pop( $arrMethod );
        $strMethod      = $this->renameMethod( $strRealMethod , $strClass );

        // get the namespace name //
        $strNamespace   = CorujaClassManipulation::getNamespaceFromClassDefinition( $strClassDefinition );

            if( ! $this->shouldBeLog( $strClass , $strRealMethod ) )
        {
                return $this;
        }
                
        // get the actor what the message is bring from //
        reset( $this->arrStack );
        $objActorFrom = array_shift( $this->arrStack );
        
        // get the actor what the message is bring to //
        //$objActorTo = $this->arrStack[0];
        $objActorTo = current( $this->arrStack );

        $boolCreateMessage = true;

        if( $mixReturn == null and $this->getConfiguration()->getIgnoreNullReturns() )
        {
            $boolCreateMessage = false;
        }

        if( ( $objActorFrom == $objActorTo ) and $this->getConfiguration()->getIgnoreRecursiveCalls() )
        {
            $boolCreateMessage = false;
        }

        if( $boolCreateMessage )
        {
                // create the message //
            $objMessage = new UmlSequenceDiagramMessage();
            
            // set the message attributes //
            $objMessage->setMethod( $strRealMethod );
            $objMessage->setText( $strMethod );
            $objMessage->setActorFrom( $objActorFrom );
            $objMessage->setActorTo( $objActorTo );
            $objMessage->setType( 'return' );

            // set the message values //
            if( $mixReturn !== null )
            {
                $objValue = new UmlSequenceDiagramValue();
                $objValue->setName( "return" );
                $objValue->setValue( $mixReturn );
                $objMessage->addValue( $objValue );
            }

            // append the message  //
            $this->objUmlSequence->addMessage( $objMessage );
            $objMessage->setTimeEnd( microtime( true ) );
            $this->objActualMessage = $objMessage;
        }
        $this->objActualActor = $objActorTo;
        
        return $this;
    }

    public function getUmlSequenceDiagram()
    {
        return $this->objUmlSequence;
    }

    public function setUmlSequenceDiagram( UmlSequenceDiagram $objUmlSequence )
    {
        $this->objUmlSequence = $objUmlSequence;
        return $this;
    }

    public function restart()
    {
        // clean actors //
        $this->arrActors = array();
        // clean classes //
        $this->arrClasses = array();
        // clean messages //
        $this->arrMessages = array();
        // clean stack //
        $this->arrStack = array();
        // clean object uml sequence diagram //
        $this->objUmlSequence->restart();
        // restart the receiver //
        $this->__construct();
        return $this;
    }

    public function perform()
    {
        return $this->getUmlSequenceDiagram();
    }

    public function getActualActor()
    {
        return $this->objActualActor;
    }

    public function getActualMessage()
    {
        return ( $this->objActualMessage );
    }
}

?>