-
Notifications
You must be signed in to change notification settings - Fork 71
/
CMutablePrimitive.java
165 lines (136 loc) · 3.26 KB
/
CMutablePrimitive.java
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
package com.laytonsmith.core.constructs;
import com.laytonsmith.PureUtilities.Version;
import com.laytonsmith.annotations.typeof;
import com.laytonsmith.core.CHVersion;
import com.laytonsmith.core.exceptions.CRE.CRECastException;
import com.laytonsmith.core.exceptions.CRE.CREFormatException;
import com.laytonsmith.core.natives.interfaces.Sizeable;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
*
*/
@typeof("ms::lang::mutable_primitive")
public class CMutablePrimitive extends CArray implements Sizeable {
@SuppressWarnings("FieldNameHidesFieldInSuperclass")
public static final CClassType TYPE = CClassType.get("ms::lang::mutable_primitive");
private Construct value = CNull.NULL;
public CMutablePrimitive(Target t) {
this(null, t);
}
public CMutablePrimitive(Construct value, Target t) {
super(t, 0);
set(value, t);
}
@Override
public boolean isDynamic() {
return true;
}
/**
* Sets the value of the underlying primitive. Only primitives (and null) may be stored.
*
* @param value
* @param t
*/
public void set(Construct value, Target t) {
if(value instanceof CArray) {
throw new CREFormatException("mutable_primitives can only store primitive values.", t);
}
this.value = value;
}
@Override
public void set(Construct index, Construct c, Target t) {
throw new CRECastException("mutable_primitives cannot have values set in them", t);
}
/**
* Sets the value as if
* {@link #set(com.laytonsmith.core.constructs.Construct, com.laytonsmith.core.constructs.Target)} were called, then
* returns a reference to this object.
*
* @param value
* @param t
* @return
*/
public CMutablePrimitive setAndReturn(Construct value, Target t) {
set(value, t);
return this;
}
public Construct get() {
return value;
}
@Override
public Construct get(Construct index, Target t) {
return value;
}
@Override
public String val() {
return value.val();
}
@Override
public String toString() {
return value.toString();
}
@Override
public CMutablePrimitive clone() {
return this;
}
@Override
protected String getQuote() {
return value.getQuote();
}
@Override
public long size() {
if(value instanceof CString) {
return ((CString) value).size();
} else {
return 0;
}
}
@Override
public boolean canBeAssociative() {
return false;
}
@Override
public List<Construct> asList() {
return getArray();
}
@Override
public void clear() {
value = CNull.NULL;
}
@Override
public CArray createNew(Target t) {
return new CMutablePrimitive(value, t);
}
@Override
protected List<Construct> getArray() {
List<Construct> array = new ArrayList<>();
array.add(value);
return array;
}
@Override
protected String getString(Stack<CArray> arrays, Target t) {
return value.val();
}
@Override
public void push(Construct c, Integer i, Target t) {
set(c, t);
}
@Override
public String docs() {
return "A mutible primitive is a special data type that allows you to store primitives by reference, instead of value.";
}
@Override
public Version since() {
return CHVersion.V3_3_1;
}
@Override
public CClassType[] getSuperclasses() {
return new CClassType[]{CArray.TYPE};
}
@Override
public CClassType[] getInterfaces() {
return new CClassType[]{Sizeable.TYPE};
}
}