interpret/test/script/BasicClass.hx at master · jeremyfa/interpret · GitHub

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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
package test.script;

import test.native.NativeGroup.Class2;

class BasicClass {

    public static var sVar1:Int = 451;

    public static var sVar2(get,set):Int;

    static function get_sVar2():Int {
        return sVar1 + 1000;
    }

    static function set_sVar2(value:Int):Int {
        BasicClass.sVar1 = value - 1000;
        return value;
    }

    public static var sVar3(get,set):Int;

    static function get_sVar3():Int {
        return sVar1 + 1001;
    }

    static function set_sVar3(value:Int):Int {
        sVar1 = value - 1001;
        return value;
    }

    public var mVar1:Float = 451.5;

    public var mVar2(get,set):Float;

    function get_mVar2():Float {
        return mVar1 + 10000.75;
    }

    function set_mVar2(value:Float):Float {
        this.mVar1 = value - 10000.75;
        return value;
    }

    public var mVar3(get,set):Float;

    function get_mVar3():Float {
        return mVar1 + 10001;
    }

    function set_mVar3(value:Float):Float {
        mVar1 = value - 10001;
        return value;
    }

    public var mVar4(get,set):Float;

    function get_mVar4():Float {
        return sVar1 + 4000;
    }

    function set_mVar4(value:Float):Float {
        sVar1 = Std.int(value - 4000);
        return value;
    }

    public var mVar5(get,set):Float;

    function get_mVar5():Float {
        return BasicClass.sVar1 + 5000;
    }

    function set_mVar5(value:Float):Float {
        BasicClass.sVar1 = Std.int(value - 5000);
        return value;
    }

    public var mVar6(get,set):Float;

    function get_mVar6():Float {
        return test.script.BasicClass.sVar1 + 6000;
    }

    function set_mVar6(value:Float):Float {
        test.script.BasicClass.sVar1 = Std.int(value - 6000);
        return value;
    }

    public function new() {

    } //new

    public function hello(subject:String):Void {

        // Basic string interpolation
        trace('Hello $subject');

    } //hello

    public function hi(subject:String):Void {

        // More advanced string interpolation
        trace('Hi ${subject+'!'}');

    } //hi

    public function isBasicClass() {

        return Std.is(this, BasicClass);

    } //isBasicClass

    public function isBasicClass2() {

        return Std.is(this, test.script.BasicClass);

    } //isBasicClass2

    public function bonjour(firstName:String, lastName:String = 'Snow'):Void {

        // Last name with default value
        trace('Bonjour $firstName $lastName.');

    } //bonjour

    public static function staticHello(subject:String):Void {

        // Basic string concatenation
        trace('Static Hello ' + subject);

    } //staticHello

    public function mathDotPiPlus3() {

        trace(('' + (Math.PI + 3)).substr(0, 8));

    } //mathDotPiPlus3

    public static function nativeGroupClass1IsClass1() {

        return new test.native.NativeGroup.Class1().isClass1();

    } //nativeGroupClass1IsClass1

    public static function nativeGroupClass1IsClass2() {

        return new test.native.NativeGroup.Class1().isClass2();

    } //nativeGroupClass1IsClass2

    public static function nativeGroupClass2IsClass1() {

        return new Class2().isClass1();

    } //nativeGroupClass2IsClass1

    public static function nativeGroupClass2IsClass2() {

        return new Class2().isClass2();

    } //nativeGroupClass2IsClass2

    public static function nativeGroupClass1StaticMethod1() {

        return test.native.NativeGroup.Class1.staticMethod1();

    } //nativeGroupClass1StaticMethod1

    public static function nativeGroupClass2StaticMethod2() {

        return Class2.staticMethod2();

    } //nativeGroupClass2StaticMethod2

} //BasicClass