<project xmlns="http://maven.apache.org/POM/4.0.0"
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
	<modelVersion>4.0.0</modelVersion>
	<groupId>net.kaustic.flexmojos.test</groupId>
	<artifactId>flexmojos-test-swc</artifactId>
	<packaging>swc</packaging>
	<version>1.0-SNAPSHOT</version>
 
	<developers>
		<developer>
			<id>vancoja</id>
			<name>Jan Van Coppenolle</name>
		</developer>
	</developers>
 
	<properties>
		<flexmojos.version>4.0-RC2</flexmojos.version>
		<flex.sdk.version>4.6.0.23201</flex.sdk.version>
		<apparat.version>1.0-RC9</apparat.version>
		<flexunit.version>4.1.0-beta3</flexunit.version>
		<flashplayer.version.swf>13</flashplayer.version.swf>
		<flashplayer.version.major>11</flashplayer.version.major>
		<flashplayer.version.minor>1</flashplayer.version.minor>
		<flashplayer.version>${flashplayer.version.major}.${flashplayer.version.minor}</flashplayer.version>
		<locale>en_US</locale>
	</properties>
 
	<dependencies>
		<dependency>
			<groupId>com.adobe.flex.framework</groupId>
			<artifactId>flex-framework</artifactId>
			<version>${flex.sdk.version}</version>
			<type>pom</type>
			<exclusions>
				<exclusion>
					<groupId>com.adobe.flex.framework</groupId>
					<artifactId>playerglobal</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>com.adobe.flex.framework</groupId>
			<artifactId>playerglobal</artifactId>
			<classifier>${flashplayer.version.major}.${flashplayer.version.minor}</classifier>
			<version>${flex.sdk.version}</version>
			<type>swc</type>
			<scope>external</scope>
		</dependency>
		<dependency>
			<groupId>com.adobe.flexunit</groupId>
			<artifactId>flexunit</artifactId>
			<version>${flexunit.version}</version>
			<type>swc</type>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>com.googlecode.apparat</groupId>
			<artifactId>apparat-ersatz</artifactId>
			<version>${apparat.version}</version>
			<type>swc</type>
		</dependency>
	</dependencies>
 
	<build>
		<defaultGoal>install</defaultGoal>
		<sourceDirectory>src/main/as3</sourceDirectory>
		<testSourceDirectory>src/test/as3</testSourceDirectory>
		<plugins>
			<plugin>
				<artifactId>maven-clean-plugin</artifactId>
				<configuration>
					<filesets>
						<fileset>
							<directory>src/test/as3</directory>
							<includes>
								<include>FlexUnitApplication.mxml</include>
							</includes>
						</fileset>
					</filesets>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.sonatype.flexmojos</groupId>
				<artifactId>flexmojos-maven-plugin</artifactId>
				<version>${flexmojos.version}</version>
				<extensions>true</extensions>
				<dependencies>
					<dependency>
						<groupId>com.adobe.flex</groupId>
						<artifactId>compiler</artifactId>
						<version>${flex.sdk.version}</version>
						<type>pom</type>
					</dependency>
				</dependencies>
				<configuration>
					<coverage>true</coverage>
					<configurationReport>true</configurationReport>
					<targetPlayer>${flashplayer.version}</targetPlayer>
					<swfVersion>${flashplayer.version.swf}</swfVersion>
					<locales>
						<param>${locale}</param>
					</locales>
					<updateSecuritySandbox>true</updateSecuritySandbox>
				</configuration>
			</plugin>
			<plugin>
				<groupId>com.googlecode.apparat</groupId>
				<artifactId>apparat-maven-plugin</artifactId>
				<version>${apparat.version}</version>
				<executions>
					<execution>
						<goals>
							<goal>reducer</goal>
							<goal>tdsi</goal>
						</goals>
					</execution>
					<execution>
						<id>tsdi-test</id>
						<phase>process-test-classes</phase>
						<goals>
							<goal>tdsi</goal>
						</goals>
						<configuration>
							<overrideArtifact>${project.build.testOutputDirectory}/TestRunner.swf</overrideArtifact>
						</configuration>
					</execution>
				</executions>
				<configuration>
					<mergeABC>false</mergeABC>
					<sortCPool>false</sortCPool>
					<mergeCF>false</mergeCF>
					<alchemyExpansion>true</alchemyExpansion>
					<inlineExpansion>true</inlineExpansion>
					<macroExpansion>true</macroExpansion>
				</configuration>
			</plugin>
		</plugins>
	</build>
 
	<pluginRepositories>
		<pluginRepository>
			<id>central</id>
			<name>Maven Plugin Repository</name>
			<url>http://repo1.maven.org/maven2</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</pluginRepository>
		<pluginRepository>
			<id>flexmojos-repository</id>
			<url>http://repository.sonatype.org/content/groups/flexgroup/</url>
		</pluginRepository>
		<pluginRepository>
			<id>oss-sonatype</id>
			<url>http://oss.sonatype.org/content/repositories/snapshots</url>
		</pluginRepository>
	</pluginRepositories>
 
	<repositories>
		<repository>
			<id>flex-mojos-repository</id>
			<url>http://repository.sonatype.org/content/groups/flexgroup/</url>
			<releases>
				<enabled>true</enabled>
			</releases>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>
		</repository>
	</repositories>
 
</project>

package be.idamf.sofa.lang
{
	import org.flexunit.asserts.assertEquals;
	import org.flexunit.asserts.assertFalse;
	import org.flexunit.asserts.assertTrue;
 
	public class ImmutableEnumTest
	{
		public function ImmutableEnumTest()
		{
		}
 
		[Test]
		/**
		 * The Enum name should be a string literal equal to the name
		 * of the static constant member.
		 */
		public function test_name():void
		{
			assertEquals("A", ExampleEnum.A.name);
			assertEquals("B", ExampleEnum.B.name);
 
			assertTrue(ExampleEnum.A.name == AnotherEnum.A.name);
		}
 
		[Test]
		/**
		 * An Enum is only equal to itself or equal to a String literal
		 * representing its name.
		 */
		public function test_equals():void
		{
			assertTrue(ExampleEnum.A.equals(ExampleEnum.A));
 
			assertTrue(ExampleEnum.A.equals("A"));
			assertTrue(ExampleEnum.B.equals("B"));
 
			assertFalse(ExampleEnum.A.equals(ExampleEnum.B));
			assertFalse(ExampleEnum.A.equals(AnotherEnum.A));
		}
 
		[Test(expects="Error")]
		/**
		 * ImmutableEnum is an Abstract Class and cannot be instantiated.
		 */
		public function test_abstract():void
		{
			new ImmutableEnum();
		}
 
		[Test(expects="Error")]
		/**
		 * An ImmutableEnum implementation should be locked from within
		 * the Class using a Static Initializer.
		 */
		public function test_instantiate():void
		{
			new ExampleEnum();
		}
 
		[Test(expects="Error")]
		/**
		 * When no explicit Static Initialization lock was done the use
		 * of the Enum should be discouraged by throwing a runtime Error.
		 */
		public function test_mutable():void
		{
			MutableEnum.A.equals(ExampleEnum.A);
		}
	}
}
 
import be.idamf.sofa.lang.ImmutableEnum;
 
internal class ExampleEnum extends ImmutableEnum
{
	public static const A:ExampleEnum = new ExampleEnum();
	public static const B:ExampleEnum = new ExampleEnum();
 
	{
		lock(ExampleEnum);
	}
 
	public function ExampleEnum()
	{
		super();
	}
}
 
internal class AnotherEnum extends ImmutableEnum
{
	public static const A:AnotherEnum = new AnotherEnum();
 
	{
		lock(AnotherEnum);
	}
 
	public function AnotherEnum()
	{
		super();
	}
} 
 
internal class MutableEnum extends ImmutableEnum
{
	public static const A:MutableEnum = new MutableEnum();
 
	public function MutableEnum()
	{
		super();
	}
}

package be.idamf.sofa.lang
{
	import avmplus.DescribeType;
	import avmplus.HIDE_OBJECT;
	import avmplus.INCLUDE_TRAITS;
	import avmplus.INCLUDE_VARIABLES;
 
	import flash.utils.getQualifiedClassName;
 
	public class ImmutableEnum
	{
		use namespace _internal;
 
		private static const ENUMS:Object = {};
 
		public static function lock(Enum:Class):void
		{
			ENUMS[getQualifiedClassName(Enum)] = Enum;
		}
 
		_internal var _isInitialized:Boolean;
		_internal var _className:String;
		_internal var _name:String;
 
		public function ImmutableEnum()
		{
			_className = getQualifiedClassName(this);
 
			if (ENUMS.hasOwnProperty(_className))
				throw new Error("Locked Class");
 
			if (_className.split("::")[1] == "ImmutableEnum")
				throw new Error("Abstract Class");
		}
 
		public final function get name():String
		{
			if (!_isInitialized)
				init();
 
			return _name;
		}
 
		private function init():void
		{
			var Enum:Class = ENUMS[_className];
 
			if (Enum == null)
				throw new Error("Enum Class should be locked and immutable");
 
			var vars:Object = DescribeType.JSON(Enum, HIDE_OBJECT | INCLUDE_TRAITS | INCLUDE_VARIABLES).traits.variables;
			var enum:ImmutableEnum;
 
			for each (var member:Object in vars)
			{
				if (member.type == "readonly")
					continue;
 
				enum = Enum[member.name];
 
				if (!enum._isInitialized)
				{
					enum._name = member.name;
					enum._isInitialized = true;
				}
			}
		}
 
		public function equals(enum:Object):Boolean
		{
			if (!_isInitialized)
				init();
 
			switch (true)
			{
				case enum === this:
					return true;
 
				case enum is String:
					return (_name == enum);
 
				default:
					return false;
			}
		}
 
		public function toString():String
		{
			return _className + "/" + name;
		}
	}
}
 
internal namespace _internal;

<?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009" 
					   xmlns:s="library://ns.adobe.com/flex/spark" 
					   xmlns:mx="library://ns.adobe.com/flex/mx"
					   applicationComplete="applicationCompleteHandler(event)">
	<fx:Script>
		<![CDATA[
			import flash.utils.getTimer;
 
			import mx.events.FlexEvent;
 
			public var process:NativeProcess;
			public var sound:Sound;
			public var channel:SoundChannel;
			public var buffer:ByteArray;
			public var bufferSize:int = 4096;
			public var pos:uint = 0;
			public var t:int;
 
			protected function applicationCompleteHandler(event:FlexEvent):void
			{
				if (!NativeProcess.isSupported)
				{
					out.appendText("NativeProcess not supported");
					return;
				}
 
				var file:File = File.applicationDirectory.resolvePath("bin/flac.exe");
				var info:NativeProcessStartupInfo = new NativeProcessStartupInfo();
 
				info.executable = file;
				info.arguments.push("--decode");
				info.arguments.push("--stdout");
				info.arguments.push("--totally-silent");
				info.arguments.push("--force-raw-format");
				info.arguments.push("--endian=little");
				info.arguments.push("--sign=signed");
				info.arguments.push(File.applicationDirectory.resolvePath("test.flac").nativePath);
 
				process = new NativeProcess();
				process.addEventListener(ProgressEvent.STANDARD_OUTPUT_DATA, process_outputDataHandler);
				process.addEventListener(Event.STANDARD_OUTPUT_CLOSE, process_outputCloseHandler);
				process.start(info);
 
				buffer = new ByteArray();
				buffer.endian = Endian.LITTLE_ENDIAN;
 
				sound = new Sound();
				sound.addEventListener(SampleDataEvent.SAMPLE_DATA, sound_sampleDataHandler);
				channel = sound.play();
 
				out.appendText("Playing\n");
 
				t = getTimer();
			}
 
			protected function process_outputDataHandler(event:ProgressEvent):void
			{
				process.standardOutput.readBytes(buffer, buffer.length, process.standardOutput.bytesAvailable);
			}
 
			protected function process_outputCloseHandler(event:Event):void
			{
				out.appendText("FLAC decoded in " + (getTimer() - t) + " ms\n");
			}
 
			protected function sound_sampleDataHandler(event:SampleDataEvent):void
			{
				if (buffer.length < (bufferSize * 4))
				{
					for (var i:int = 0; i < (bufferSize * 2); ++i)
						event.data.writeFloat(0.0);
				}
				else if (buffer.position == buffer.length)
				{
					channel.stop();
					out.appendText("Stopped\n");
				}
				else
				{
					buffer.position = pos;
 
					for (var j:int = 0; j < (bufferSize * 2); ++j)
					{
						if (buffer.position == buffer.length)
							event.data.writeFloat(0.0);
						else
							event.data.writeFloat(buffer.readShort() / 32767.0);
					}
 
					pos += (bufferSize * 4);
				}
			}
 
		]]>
	</fx:Script>
 
	<s:TextArea id="out"
				width="100%"
				height="100%"/>
 
</s:WindowedApplication>