FilesExpand file tree

 development

/

Lib.hx

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

115 lines (94 loc) · 2.27 KB

 development

/

Lib.hx

Copy path

Top

File metadata and controls

• Code
• Blame

115 lines (94 loc) · 2.27 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

package python;

import python.lib.Types;

class HaxeIterable<T>

{

var x :NativeIterable<T>;

public inline function new (x:NativeIterable<T>) {

this.x = x;

}

public inline function iterator ():HaxeIterator<T> return new HaxeIterator(x.__iter__());

}

class HaxeIterator<T>

{

var it :NativeIterator<T>;

var x:Null<T> = null;

var has = false;

var checked = false;

public function new (it:NativeIterator<T>) {

this.it = it;

}

public inline function next ():T

{

checked = false;

return x;

}

public function hasNext ():Bool

{

if (checked) {

return has;

} else {

try {

x = it.__next__();

has = true;

} catch (s:StopIteration) {

has = false;

x = null;

}

checked = true;

return has;

}

}

}

class Lib

{

/*

public static inline function assert(value:Dynamic)

{

untyped __assert__(value);

}

public static function random(max:Int)

{

var r = new dart.math.Random(); //TODO(av) benchmark / test caching Random instance as static

return r.nextInt(max);

}

*/

public static function print(v:Dynamic)

{

python.lib.Sys.stdout.write(Std.string(v));

python.lib.Sys.stdout.flush();

}

public static function println(v:Array<Dynamic>)

{

for (e in v) {

untyped __python__("print")(Std.string(e));

}

}

public static function toPythonIterable <T>(it:Iterable<T>):python.lib.Types.NativeIterable<T>

{

return {

__iter__ : function () {

var it1 = it.iterator();

var self:PyIterator<T> = null;

self = new PyIterator({

__next__ : function ():T {

if (it1.hasNext()) {

return it1.next();

} else {

throw new python.lib.Types.StopIteration();

}

},

__iter__ : function () return self

});

return self;

}

}

}

public static inline function toHaxeIterable <T>(it:NativeIterable<T>):HaxeIterable<T>

{

return new HaxeIterable(it);

}

public static inline function toHaxeIterator <T>(it:NativeIterator<T>):HaxeIterator<T>

{

return new HaxeIterator(it);

}

}