move to new repo

Kenmegne

6 days ago 8cbaa370347e6fc997381cf35d6c295685b90f98

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
/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.megatim.dynamicjsonparser.extender;
 
import com.megatim.dynamicjsonparser.pojo.CustomError;
import com.megatim.dynamicjsonparser.pojo.JsonField;
import com.megatim.dynamicjsonparser.pojo.JsonParsedData;
import com.megatim.dynamicjsonparser.pojo.Node;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import org.burningwave.core.Virtual;
 
/**
 *
 * @author ASUS
 */
public class DataRetrieverAction extends RecursiveTask<JsonParsedData> {
 
    //Liste des données extraites du fichier json
    private final List<Virtual> finalVirtuals = Collections.synchronizedList(new ArrayList<>());
 
    //Liste des erreurs recontrées dans le fichier json
    private final Deque<CustomError> deque = new ConcurrentLinkedDeque<>();
 
    private final List<Node> nodes;
    private final Class classOfEntity;
    private final List<JsonField> jsonFields;
    private final String rootClass;
    private final int nbThreads;
 
    public DataRetrieverAction(List<Node> nodes, Class classOfEntity, List<JsonField> jsonFields, String rootClass, int nbThreads) {
        this.nodes = nodes;
        this.classOfEntity = classOfEntity;
        this.jsonFields = jsonFields;
        this.rootClass = rootClass;
        this.nbThreads = nbThreads;
    }
 
    @Override
    protected JsonParsedData compute() {
        if (nbThreads > 1) {
            ForkJoinTask
                    .invokeAll(createSubtasks())
                    .stream()
                    .map(DataRetrieverAction::join)
                    .forEach(p -> {
                        deque.addAll(p.getErrors());
                        finalVirtuals.addAll(p.getVirtuals());
                    });
            return new JsonParsedData(finalVirtuals, new ArrayList<>(deque));
        } else {
            return new JsonDataProcessor(nodes, classOfEntity, jsonFields, rootClass).iterateThroughNodes();
        }
    }
 
    private List<DataRetrieverAction> createSubtasks() {
        List<DataRetrieverAction> subtasks = new ArrayList<>();
        int nbEltsPerTask = nodes.size() / nbThreads;
        int remainder = nodes.size() % nbThreads;
 
        for (int i = 0; i < nbThreads; i++) {
            if (remainder > 0 && i == nbThreads - 1) {
                subtasks.add(new DataRetrieverAction(nodes.subList(nbEltsPerTask * i, nbEltsPerTask * i + nbEltsPerTask + remainder), classOfEntity, jsonFields, rootClass, 1));
            } else {
                subtasks.add(new DataRetrieverAction(nodes.subList(nbEltsPerTask * i, nbEltsPerTask * i + nbEltsPerTask), classOfEntity, jsonFields, rootClass, 1));
            }
        }
 
        return subtasks;
    }
 
}