Namespaces

[[je]]

Lasst uns mal ein bisschen zusammentragen. Bisher habe ich Probleme die Namespaces sinnvoll einzusetzen.

Ich würde gerne wissen, wie ihr das hinbekommt. Z.b. könnte ich mir vor mein BitmapData neu zu definieren.

var x: BitmapData = new ImageProcessing::BitmapData();

Oder so ähnlich. Bisher kriege ich aber einen ganz dämlichen Fehler.

package ip.img
{	
	namespace ImageProcessing;
	
	public class Image
	{	
		public function Image()
		{
		}
	}
}
//fehler: file found in an actionscript-classpath can not have more than one externally visible definition. ip.img:ImageProcessing;ip.img:Image

So schnell schon falsch?

Wieso geht auch das nicht:

package ip.img
{		
	public class Image
	{	
		public function Image()
		{
		}
	}
	
	public class B
	{
	}
}
//fehler: A file found in an actionscript-classpath can not have more than one externally visible definition. ip.img:Image;ip.img:B

Wieso also geht es nicht? Kann man überhaupt Klassen innerhalb eines Namespace definieren?

Wenn ja, wie?

Und: Wieso kann ich in einer *.as Datei nicht zwei sichtbare Klassen haben? Das macht mich grade stuzig.

[[je]]

Beim teste grade, sehr confusing.

		namespace RGBMath;
		namespace BinMath;
		
		RGBMath function distance(a: int, b: int): int
		{
			return a-b;
		}
		
		BinMath function distance(a: int, b: int): int
		{
			return a*b;
		}

Das innerhalb einer Klasse. Ich bekomme die warnung das beide namespaces ins scope internal gelegt werden, ich kann aber über RGBMath::distance() und BinMath::distance() beide Funktionen gesondert ansprechen..?!

[[je]]

Bisher scheinen mir Namespaces wenig nützlich,
wenn ich nicht einmal eine Klasse in einem Namespace deklarieren kann?

Theoretisch ist jetzt so etwas möglich wie, bei einer Vektor-Klasse, dass man eine Klasse hat, die 2D und 3D ermöglicht. So könnte(!) man überladen.

Beispiel:

	public class VectorMath
	{
		namespace Math2D;
		namespace Math3D;
		
		Math3D static function distance( a: Vector3D, b: Vector3D ): Number
		{
			return ...
		}
		
		Math2D static function distance( a: Vector2D, b: Vector2D ): Number
		{
			return ...
		}
	}

Dann wäre so etwas möglich wie

VectorMath.Math3D::distance( a, b );
VectorMath.Math2D::distance( c, d );

Bisher alles nicht so wirklich das, was ich von Namespaces kenne :o)

[[je]]

so wie ich es jetzt durchblicke funktioniert ein namespace bisher nur innerhalb einer klasse. somit ist auch das vektor-beispiel quark, denn es funktioniert nur in der selben klasse.

use ist übrigens auch noch nicht implementiert, von daher ist das alles nicht so spaßig. schade :o(

[André Michelle]

Hast du auch ein Beispiel, was funktioniert ?

Wahrscheinlich sind diese Namespaces eher für Applikation gedacht und nicht für die Engineentwicklung (schnelle Views) geeignet. Sympathisch finde ich diese Doppelpunktschreibweise eh nicht.

[[je]]

import flash.util.trace;

	public class VectorMath
	{
		namespace Math2D;
		namespace Math3D;
		
static public function test(): void {
trace( 'VectorMath.test' );
Math2D::distance(0,0);
Math3D::distance(0,0);
}
		Math2D static function distance( a: int, b: int ): Number
		{
trace( 'Math2D::distance' );
			return 0;
		}
		
		Math3D static function distance( a: int, b: int ): Number
		{
trace( 'Math3D::distance' );
			return 0;
		}
	}

Dann VectorMath.test(); irgendwo. Das funktioniert so, aber nur innerhalb der Klasse mit den Namespaces.

André: Benutzt du Miranda? Weil dann solltest du mal updaten :o)

[flory]

Das neue Namespace Konzept ist wirklich etwas verwirrend.
Grundsätzlich gibt es eine Unterscheidung zwischen Packages, das ist die Art von Namespaces,
die man im Zusammenhang mit OOP normalerweise kennt - und das Namespace
Konzept das mit
E4X eingeführt wurde. Das ist das Namespace Konzept von XML, wo einem Element Attribute
aus verschiedenen XML-Namensräumen hinzugefügt werden können.
Namespaces machen also hauptsächlich dann Sinn, wenn Du mit XML hantierst.

Vielleicht klärt das ein paar Deiner Fragen.

Gruss
Florian

[hazy fantazy]

Ich habe irgendwo mal gelesen, dass private und public auch über Namespaces realisiert sind. Ich habe mir das noch nicht näher angeschaut, ist das überhaupt möglich? Mit den doppelten Doppelpunkten wohl kaum.

[bort]

Nicht nur das. Namespaces verhindern auch die Kollision von Variablen/Methoden mit gleichem Namen. Die flash.util.Proxy Klasse benutzt dafür z.B. den Namespace flash_proxy. Anstelle von :: kann man auch ein use benutzen, um einen Namespace auszuwählen.

Neben der Zugriffskontrolle lässt sich über Namespaces aber auch Verhalten implementieren. Hier ein Beispiel aus der Doku, das Namespaces zur Unterscheidung der zu verwendenen Füllfarbe bei einem Rollover benutzt:

package {
    import flash.display.Sprite;
  
    public class NamespaceExample extends Sprite {     
        public function NamespaceExample() {
            addChild(new StateButton("Press Me."));
        }
    }
}
 
import flash.display.Sprite;
import flash.display.TextField;
import flash.events.Event;
import flash.events.MouseEvent;
 
class StateButton extends Sprite{
    private namespace out;
    private namespace over;
    private namespace down;
    private var label:TextField;
    private var labelTxt:String;
    private var ns:Namespace;
    out var bgColor:Number = 0xFF0000;
    over var bgColor:Number = 0xFFFF00;
    down var bgColor:Number = 0xFFFFFF;
      
    public function StateButton(str:String) {
        buttonMode = true;
        labelTxt = str;
        ns = out;
        draw();
        addLabel();
        addListeners();
    }
 
    private function addLabel():void {
        label = new TextField();
        label.text = labelTxt;
        label.width = 50;
        label.height = 20;
        label.mouseEnabled = false;
        addChild(label);
    }
      
    private function addListeners():void {
        addEventListener(MouseEvent.MOUSE_UP, mouseOverHandler);
        addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
        addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
        addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
    }
 
    private function mouseOutHandler(e:Event):void {
        ns = out;
        draw();
    }
 
    private function mouseOverHandler(e:Event):void {
        ns = over;
        draw();
    }
 
    private function mouseDownHandler(e:Event):void {
        ns = down;
        draw();
    }
 
    private function draw():void {
        this.graphics.clear();
        this.graphics.beginFill(ns::bgColor);
        this.graphics.drawRect(0, 0, 120, 80);
    }
} 

Gruß,
bort.

[[je]]

Danke für die Antworten.
Damit klärt sich einiges. Die implementierung der Namespaces habe ich wohl auch falsch gesehen.

Eine Math-Klasse für Vektoren wäre somit immernoch möglich, wenn ich vorher immer das Namespace umstelle. Dann würde die add() Funktion 2D Vektoren addieren oder so. Interessant

Das Button Beispiel finde ich von MM schlecht gewählt. Da würde ich glaube ich einfach den Namen der Variablen mit einem Suffix wie Over, Out und Pressed versehen.

Bort: Unter welchem Link hast du das in der Doku gefunden? Habe auch mal gesucht, aber nicht viel gefunden.

[bort]

In der API Doku: Top Level --> Namespace
http://livedocs.macromedia.com/labs/...Namespace.html

Gruß,
bort.

[elias]

Die Namespaces für XML sind wohl notwendig und auch OK. Aber das Konzept
auf Klassen umzuwälzen finde ich ein wenig obskur. Mir fällt zumindest nichts ein
was ich nicht auch mit herkömmlichen Features realisieren könnte. Außerdem
verleitet es stark dazu alles in einer Klasse zu definieren.
Ich kann mir aber vorstellen das die Namespaces einen kleinen Performanceschub geben.

[[je]]

bort: Das ist ja die Dokumentation zur Namespace Klasse. Ich dachte jetzt eher an etwas wie zum arbeiten mit den Namespaces.

Es gibt ja auch irgendwo etwas über private, protected und public. Und eben das auch über Namespaces. Nur habe ich es nicht gefunden bisher.

Elias: Namespaces sind doch toll. Aber, ich kann verstehen wenn man die für unnütz empfindet, denn eigentlich sind die Packages schon ein Ersatz (in Flash, in C++ nicht).

[flory]

Ich kann mir vorstellen, dass man das vielleicht für UI Programmierung einsetzen kann,
um so was ähnliches wie Dependency Properties in XAML zu erreichen.
Oder, wenn man die Sichtbarkeit von Methoden/Eigentschaften im Zusammenspiel von Klassen
feiner regeln will als über private/protected/public.
Das Beispiel aus der Doku finde ich aber total daneben...

Florian

[bort]

Ok, hier ein Beispiel mit einem privaten Namespace, der nur von Klassen aufgerufen werden kann, die ein bestimmtes Interface implementieren. In der Klasse SecuredNameSpace ist ein privater Namespace deklariert. Die Funktion getHiddenNamespace prüft, ob das übergebene Objekt vom Typ ISecure ist. Wenn ja, dann wird der private Namespace zurückgegeben.

// Main.as
package {

	import flash.display.Sprite;
	import flash.util.trace;

	public class Main extends Sprite 
	{ 
		public function Main() 
		{
			try 
			{
				var testA:NameSpaceTestA = new NameSpaceTestA();
				trace(testA.tryToGetText());
				
				var testB:NameSpaceTestB = new NameSpaceTestB();
				trace(testB.tryToGetText());
			} 
			catch (e:Error)
			{
				trace("Error: " + e.message);
			}
		}
	}
}

interface ISecure 
{
}

class SecuredNameSpace
{
    private namespace hidden_namespace;
   
    public function getHiddenNamespace (obj:Object):Namespace 
    {
    	return (obj is ISecure)? hidden_namespace : null;
    }
   
    hidden_namespace function getText():String 
    {
		return "Hidden Text";
    }

}
       
class NameSpaceTestA implements ISecure 
{
	public function tryToGetText():String 
	{
	    var securedNameSpace:SecuredNameSpace = new SecuredNameSpace();
	    var ns:Namespace = securedNameSpace.getHiddenNamespace (this);
	    return securedNameSpace.ns::getText();
	}
}
       
class NameSpaceTestB 
{
	public function tryToGetText():String 
	{
	    var securedNameSpace:SecuredNameSpace = new SecuredNameSpace();
	    var ns:Namespace = securedNameSpace.getHiddenNamespace (this);
	    return securedNameSpace.ns::getText();
	}
}

Gruß,
bort.