Mechanism

Complexity

Total Complexity

13

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	run()	0	11	1
A	_get_object_parameters()	0	12	2
D	_run_events()	0	25	8
A	_get_computed_object_event_parameters()	0	12	1
A	__init__()	0	3	1

from synergine.core.exceptions import UselessMechanism
from synergine.lib.process.tool import get_chunk


class Mechanism():
    """
    Mechanism prepare data for associated events.
    The principle: One mechanism compute once what multiple events need.
    """

    def __init__(self, events):
        self._events = events
        self._events_parameters = {}

    def run(self, context):
        """

        Prepare new mechanism cycle and return Action according to this mechanism events.

        :param context:
        :return: Actions to run this cycle
        :rtype: list (of Action objects)
        """
        self._events_parameters = {}
        return self._run_events(context)

    def _get_object_parameters(self, object_id, context):
        """

        Return concerned object parameters for event.

        :param object_id: Concerned object if
        :param context: The Context
        :return: parameters who will be used by event
        """
        if object_id not in self._events_parameters:
            self._events_parameters[object_id] = self._get_computed_object_event_parameters(object_id, context)
        return self._events_parameters[object_id]

    def _run_events(self, context):
        """

        Return Action according to this mechanism events.

        :param context: The Context
        :return: list (of Action)
        """
        actions = []
        for event in self._events:
            if context.get_cycle() % event.get_each_cycle() == 0 \
               or (event.is_first_cycle_force() and context.get_cycle() == 1):
                concerned_objects_ids = get_chunk(context.get_total_chunk(),
                                                  context.get_current_chunk_position(),
                                                  context.metas.collections.get(event.get_concern(), allow_empty=True))

                for object_id in concerned_objects_ids:
                    try:
                        event_parameters = self._get_object_parameters(object_id, context)
                        event_actions = event.observe(object_id, context, event_parameters)
                        for event_action in event_actions:
                            actions.append(event_action)
                    except UselessMechanism:
                        pass # If mechanism useless on this object, don't observe.
        return actions

    def _get_computed_object_event_parameters(self, object_id, context):

The name _get_computed_object_event_parameters does not conform to the method naming conventions ([a-z_][a-z0-9_]{2,30}$).

        """

        (You must override this method in child-class.)
        Compute concerned object event parameters.


        :param object_id: Concerned object id
        :param context: The Context
        :return: Concerned object event parameters
        """
        return {}