 		 */
 		protected var _eventClass:Class;
 		
-		public function get eventClass ():Class {
+		public function get eventClass ():Class 
+		{
 			return _eventClass;
 		}
 		
-		private var _propertyFilterFunction:Function = null;
+		private var _mappingFunction:Function = null;
 		
 		/*open for extension but closed for modifications*/
-		protected function get propertyFilterFunction ():Function {
-			return _propertyFilterFunction;
+		protected function get mappingFunction ():Function 
+		{
+			return _mappingFunction;
 		}
 		
 		/**

		 * 
		 * @param	target	An object that implements the flash.events.IEventDispatcher interface.
		 * @param	eventType The event string name that would normally be passed to IEventDispatcher.addEventListener().
		 * @param 	valueClass The Class that the eventType will be mapped to
		 * @param	mapToObjectOrFunction an object or a Function that should return an object of the same type as the valueClass argument. 
		 * If mapTo is an Object then this is what will be sent along with the signal as a value class. 
		 * If mapTo is a function the Object returned from the function is passed along as the argument with the signal. 
		 * If the mapping function can have zero or one argument. In the case of a single argument it should be of type Event. 
		 * If the mapping function does not need to know about the event then implement it with zero arguments are no Event will passed to it.  
		 */
		public function NativeMappedSignal(target:IEventDispatcher, eventType:String, eventClass:Class=null, ... propertyTypes)
		{
			/*We keep this class but it is not our valueClass.*/
			_eventClass = eventClass || Event;
			
			/*I want to use the super-contructor,
			but the implicit call of setValueClasses(Event) will only be temporarily,
			instead we want the valueClasses given as parameter in this constructor*/
			super(target, eventType);
			
			/*if valueClasses are not provided this will call the listeners with no parameter*/
			setValueClasses(propertyTypes);
		}
		
		/**
		 * @param objectOrFunction This can either be a list of object literals or a function that returns list of objects. 
		 * If the argument is a list of object literals <code>mapTo()</code>: then this list is passed along with the Signal dispatch.
		 * 
		 * Here's an example passing an object literal:

		 */		
		public function mapTo(...objectListOrFunction):NativeMappedSignal
		{
			if (isArgumentListAFunction(objectListOrFunction))
			{
				_mappingFunction = objectListOrFunction[0] as Function;
				
				if (hasFunctionMoreThanOneArgument(_mappingFunction))
				{	
					throw new ArgumentError('Mapping function has ' + _mappingFunction.length 
						+ ' arguments but it needs zero or one of type Event');
				}
			}
			else
			{
				_mappingFunction = function ():Object { return objectListOrFunction; };
			}
			
			return this
		}
		
		private function isArgumentListAFunction(argList:Array):Boolean
		{
			return argList.length == 1 && argList[0] is Function
		}
		
		private function hasFunctionMoreThanOneArgument(f:Function):Boolean
		{
			return f.length > 1
		}
		
		/**
