P15GEN2\59518
2025-10-10 9f6890646993d16260d4201d613c092132856127
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
package foundation.capacity;
 
import java.util.Iterator;
 
import foundation.json.IJSONProvider;
import foundation.json.IJSONWriter;
import foundation.json.JSONReader;
import foundation.util.MapList;
import foundation.util.Util;
 
public class ActorsRuntime implements Iterable<ActorTarget>, IJSONProvider {
 
    private MapList<String, ActorTarget> actors;
    private CurrentActor current;
    private ActorTarget defalut;
    
    
    public ActorsRuntime() {
        actors = new MapList<String, ActorTarget>();
        current = new CurrentActor();
    }
 
    public void loadOne(ActorTarget actor) {
        //1. 添加 Actor
        String id = actor.getId();
                
        if (!actors.contains(id)) {
            actors.add(id, actor);
        }
        
        if (actor.isDefault()) {
            defalut = actor;
        }
    }
    
    public void setCurrentActor() {
        ActorTarget defaultCurrent = getCurrent(null);
        boolean isSetCurrent = true;
        
        if (defaultCurrent != null) {
            String actorId = defaultCurrent.getId().toLowerCase();
            
            if (actors.get(actorId) != null) {
                isSetCurrent = false;
            }
        }
        
        if (isSetCurrent) {
            current.setDefault(defalut == null ? actors.get(0) : defalut);
        }
    }
    
    public ActorTarget changeCurrent(String onlineCode, String targetId) {
        if (actors == null || actors.size() == 0) {
            return null;
        }
        
        ActorTarget result = defalut == null ? actors.get(0) : defalut;
        
        if (!Util.isEmpty(targetId)) {
            result = actors.get(targetId);
        }
        current.set(onlineCode, result);
        
        return result;
    }
 
    public ActorTarget getCurrent(String onlineCode) {
        return current.get(onlineCode);
    }
    
    public ActorTarget get(String actorId) {
        return actors.get(actorId);
    }
 
    public void saveChanges(JSONReader changes) {
        //1. translate changes to capacity list
        MapList<String, Actor> actors = new MapList<String, Actor>();
        ActorBucket actorBucket = ActorBucket.getInstance();
        
        for (JSONReader reader: changes) {
            String id = reader.getString("id");
            
            if (Util.isEmpty(id)) {
                return;
            }
            
            Actor actor = actorBucket.get(id);
            
            if (actor == null) {
                continue;
            }
            
            actors.add(id, actor);
        }
        
        /*
        //2. add new
        for (Actor actor: itemList) {
            String id = actor.getId();
            
            if (!contains(id)) {
                add(id, actor);
            }
        }
        
        //3. delete 
        for (Actor actor: itemList) {
            String id = actor.getId();
            
            if (!actors.contains(id)) {
                remove(id);
                
                if (isEmpty()) {
                    current = null;
                }
            }
        }
        */
    }
 
    public boolean isVerified() {
        return current.isVerified();
    }
 
    public void setVetified(boolean vetify) throws Exception {
        current.setVerified(vetify);
    }
 
    public void clear() {
        actors.clear();
    }
 
    @Override
    public Iterator<ActorTarget> iterator() {
        return actors.iterator();
    }
    
    @Override
    public void writeJSON(IJSONWriter writer) {
        writer.beginArray();
        
        for (ActorTarget actor: actors) {
            actor.writeJSON(writer);
        }
        
        writer.endArray();
    }
}