HaxeFoundation.haxe/std/lua/PairTools.hx

/*
 * Copyright (C)2005-2019 Haxe Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

package lua;

/**
	A set of utility methods for working with the Lua table extern.
**/
class PairTools {
	public static function ipairsEach<T>(table:Table<Dynamic, T>, func:Int->T->Void):Void {
		untyped __lua__("for i,v in _G.ipairs(table) do func(i,v) end");
	}

	public static function pairsEach<A, B>(table:Table<A, B>, func:A->B->Void):Void {
		untyped __lua__("for k,v in _G.pairs(table) do func(k,v) end");
	}

	public static function ipairsMap<A, B>(table:Table<Dynamic, A>, func:Int->A->B):Table<Int, B> {
		var ret:Table<Int, B> = Table.create();
		untyped __lua__("for i,v in _G.ipairs(table) do ret[i] = func(i,v) end;");
		return ret;
	}

	public static function pairsMap<A, B, C>(table:Table<A, B>, func:A->B->C->C):Table<A, C> {
		var ret:Table<A, C> = Table.create();
		untyped __lua__("for k,v in _G.pairs(table) do ret[k] = func(k,v) end;");
		return ret;
	}

	public static function ipairsFold<A, B>(table:Table<Int, A>, func:Int->A->B->B, seed:B):B {
		untyped __lua__("for i,v in _G.ipairs(table) do seed = func(i,v,seed) end");
		return untyped __lua__("seed");
	}

	public static function pairsFold<A, B, C>(table:Table<A, B>, func:A->B->C->C, seed:C):C {
		untyped __lua__("for k,v in _G.pairs(table) do seed = func(k,v,seed) end");
		return untyped __lua__("seed");
	}

	public static function ipairsConcat<T>(table1:Table<Int, T>, table2:Table<Int, T>) {
		var ret:Table<Int, T> = Table.create();
		ipairsFold(table1, function(a, b, c:Table<Int, T>) {
			c[a] = b;
			return c;
		}, ret);
		var size = lua.TableTools.maxn(ret);
		ipairsFold(table2, function(a, b, c:Table<Int, T>) {
			c[a + size] = b;
			return c;
		}, ret);
		return ret;
	}

	public static function pairsMerge<A, B>(table1:Table<A, B>, table2:Table<A, B>) {
		var ret = copy(table1);
		pairsEach(table2, function(a, b:B) ret[cast a] = b);
		return ret;
	}

	public static function ipairsExist<T>(table:Table<Int, T>, func:Int->T->Bool) {
		untyped __lua__("for k,v in _G.ipairs(table) do if func(k,v) then return true end end");
	}

	public static function pairsExist<A, B>(table:Table<A, B>, func:A->B->Bool) {
		untyped __lua__("for k,v in _G.pairs(table) do if func(k,v) then return true end end");
	}

	public static function copy<A, B>(table1:Table<A, B>):Table<A, B> {
		var ret:Table<A, B> = Table.create();
		untyped __lua__("for k,v in _G.pairs(table1) do ret[k] = v end");
		return ret;
	}

	public static function pairsIterator<A, B>(table:Table<A, B>):Iterator<{index:A, value:B}> {
		var p = Lua.pairs(table);
		var next = p.next;
		var i = p.index;
		return {
			next: function() {
				var res = next(table, i);
				i = res.index;
				return {index: res.index, value: res.value};
			},
			hasNext: function() {
				return Lua.next(table, i).value != null;
			}
		}
	}

	public static function ipairsIterator<A, B>(table:Table<A, B>):Iterator<{index:Int, value:B}> {
		var p = Lua.ipairs(table);
		var next = p.next;
		var i = p.index;
		return {
			next: function() {
				var res = next(table, i);
				i = res.index;
				return {index: res.index, value: res.value};
			},
			hasNext: function() {
				return next(table, i).value != null;
			}
		}
	}
}