added haxe.EnumFlags

doc/CHANGES.txt

@@ -36,6 +36,7 @@
 	all : neko.io.Path, cpp.io.Path and php.io.Path are now haxe.io.Path
 	neko, cpp, php : added Sys class, sys.io and sys.net packages and "sys" define
 	all : allow to access root package with std prefix (std.Type for example)
+	all : added haxe.EnumFlags
 
 2011-09-25: 2.08
 	js : added js.JQuery

std/haxe/EnumFlags.hx

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package haxe;
+
+/**
+	A typed interface for bit flags. This is not a real object, only a typed interface for an actual Int. Each flag can be tested/set with the corresponding enum value. Up to 32 flags can be stored that way.
+**/
+@:native("Int")
+extern class EnumFlags<T:EnumValue> {
+
+	/**
+		Initialize the bitflags (set it to 0)
+	**/
+	public inline function init() : Void {
+		untyped __this__ = 0;
+	}
+
+	/**
+		Check if the bitflag has the corresponding enum set. This will be compiled as a single bit & mask != 0 in case the enum value is directly passed to the method.
+	**/
+	public inline function has( v : T ) : Bool {
+		return (cast this) & (1 << Type.enumIndex(cast v)) != 0;
+	}
+
+	/**
+		Set the bitflag for the corresponding enum value.
+	**/
+	public inline function set( v : T ) : Void {
+		untyped __this__ |= 1 << Type.enumIndex(cast v);
+	}
+
+	/**
+		Unset the bitflag for the corresponding enum value.
+	**/
+	public inline function unset( v : T ) : Void {
+		untyped __this__ &= 0xFFFFFFF - (1 << Type.enumIndex(cast v));
+	}
+
+	/**
+		Convert a integer bitflag into a typed one (this is a no-op, it doesn't have any impact on speed).
+	**/
+	public inline static function ofInt( i : Int ) : EnumFlags<Dynamic> {
+		return cast i;
+	}
+
+	/**
+		Convert the typed bitflag into the corresponding int value (this is a no-op, it doesn't have any impact on speed).
+	**/
+	public inline function toInt() : Int {
+		return cast this;
+	}
+}

std/sys/db/SpodMacros.hx

@@ -185,7 +185,6 @@ class SpodMacros {
 			case "String": DText;
 			case "Date": DDateTime;
 			case "haxe.io.Bytes": DBinary;
-			case "sys.db.SFlags": DFlags(getFlags(p[0]),false);
 			default: throw "Unsupported " + name;
 			}
 		case TEnum(e, p):
@@ -205,6 +204,7 @@ class SpodMacros {
 				case "SString": return DString(makeInt(p[0]));
 				case "SBytes": return DBytes(makeInt(p[0]));
 				case "SNull", "Null": isNull = true; return makeType(p[0]);
+				case "SFlags": return DFlags(getFlags(p[0]),false);
 				case "SSmallFlags": return DFlags(getFlags(p[0]),true);
 				default:
 				}

std/sys/db/Types.hx

@@ -116,28 +116,8 @@ typedef SSerialized = String
 typedef SNekoSerialized = haxe.io.Bytes
 
 /** a set of bitflags of different enum values **/
-@:native("Int")
-extern class SFlags<T> {
-	public inline function init() : Void {
-		untyped __this__ = 0;
-	}
-	public inline function get( v : T ) : Bool {
-		return (cast this) & (1 << Type.enumIndex(cast v)) != 0;
-	}
-	public inline function set( v : T ) : Void {
-		untyped __this__ |= 1 << Type.enumIndex(cast v);
-	}
-	public inline function unset( v : T ) : Void {
-		untyped __this__ &= 0xFFFFFFF - (1 << Type.enumIndex(cast v));
-	}
-	public inline static function ofInt<E>( i : Int ) : SFlags<E> {
-		return cast i;
-	}
-	public inline function toInt() : Int {
-		return cast this;
-	}
-}
+typedef SFlags<T:EnumValue> = haxe.EnumFlags<T>
 
 /** same as [SFlags] but will adapt the storage size to the number of flags **/
-typedef SSmallFlags<T> = SFlags<T>;
+typedef SSmallFlags<T:EnumValue> = SFlags<T>;