Changeset 13936


Ignore:
Timestamp:
Nov 2, 2019 2:05:51 PM (3 weeks ago)
Author:
jwedin
Message:

Restored the behavior for mutable annotation nodes. Changed so that public methods on GenericAnnotationNode does not cause state modifications on immutable nodes. An exception to this is the setValue method which will throw an UnsupportedOperationException if the node is immutable. Removed some unnecessary mutability checks in private methods. #5865

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/dev-jw-2590/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/annotations/GenericAnnotationNode.java

    r13926 r13936  
    6363    private final T parent;
    6464
    65     private final Collection<T> subNodes_cache;
    66     private final Map<String, T> subNodesNameMap_cache;
     65    private Collection<T> subNodes_cache;
     66    private Map<String, T> subNodesNameMap_cache;
    6767    private boolean nodeWasSet = false;
    6868    private boolean subNodeNodeWasSet = false;
     
    9999        this.mutability = mutability;
    100100        this.parent = parent;
    101         valueAnnotation_cacheComputed = isImmutable();
    102         subNodes_cache = isImmutable() ? Collections.unmodifiableList(new ArrayList<T>()) : new ArrayList<T>();
    103         subNodesNameMap_cache = isImmutable() ? Collections.unmodifiableMap(new HashMap<String, T>()) : new HashMap<String, T>();
    104         if (!isImmutable()) {
     101        if (mutability == Mutability.MUTABLE) {
    105102            setNode(name, node);
    106103        }
    107     }
    108 
    109     private boolean isImmutable() {
     104        else {
     105            subNodes_cache = Collections.unmodifiableList(new ArrayList<T>());
     106            subNodesNameMap_cache = Collections.unmodifiableMap(new HashMap<String, T>());
     107            valueAnnotation_cache = self();
     108            valueAnnotation_cacheComputed = true;
     109            this.name = name;
     110        }
     111    }
     112
     113    public boolean isImmutable() {
    110114        return mutability == Mutability.IMMUTABLE;
    111115    }
     
    117121        if (isSubNodesCacheFresh()) {
    118122            return;
     123        }
     124        if (subNodes_cache == null) {
     125            subNodes_cache = Collections.emptyList();
     126        }
     127        if (subNodesNameMap_cache == null) {
     128            subNodesNameMap_cache = Collections.emptyMap();
    119129        }
    120130
     
    147157            }
    148158        }
    149 
    150         subNodes_cache.clear();
    151         subNodes_cache.addAll(subNodes);
    152         subNodesNameMap_cache.clear();
    153         subNodesNameMap_cache.putAll(subNodesNameMap);
     159        subNodes_cache = subNodes;
     160        subNodesNameMap_cache = subNodesNameMap;
    154161        clearNodeWasSetFlags();
    155162    }
     
    256263
    257264    T forPath(String[] paths, int currentIndex) {
    258         if (isAmbiguous()) {
    259             return ambiguousNode();
    260         }
    261         if (currentIndex == paths.length) {
     265        if (isImmutable() || isAmbiguous() || currentIndex == paths.length) {
    262266            return self();
    263267        }
     
    265269        T subNode = subNodesNameMap_cache.get(paths[currentIndex]);
    266270        if (subNode == null) {
     271            makeEmptySubNodesCacheMutable();
    267272            subNode = createOrSetSubNodeAndAddToCaches(subNode, paths[currentIndex], null, subNodes_cache,
    268273                    subNodesNameMap_cache);
     
    271276    }
    272277
     278    private void makeEmptySubNodesCacheMutable() {
     279        if (subNodesNameMap_cache.isEmpty()) {
     280            subNodesNameMap_cache = new HashMap<String, T>();
     281        }
     282        if (subNodes_cache.isEmpty()) {
     283            subNodes_cache = new ArrayList<T>();
     284        }
     285    }
     286   
    273287    /**
    274288     * Returns reference to it self, but with correct type! This pattern
     
    318332     */
    319333    private boolean hasSubNodes() {
    320         computeSubNodesCache();
     334        if (!isImmutable()) {
     335            computeSubNodesCache();
     336        }
    321337        return !subNodes_cache.isEmpty();
    322338    }
     
    328344     */
    329345    public Iterable<T> subNodes() {
    330         computeSubNodesCache();
     346        if (!isImmutable()) {
     347            computeSubNodesCache();
     348        }
    331349        return filterExists(subNodes_cache);
    332350    }
     
    350368     */
    351369    public N node() throws AnnotationEditException {
    352         if (!hasNode()) {
     370        if (!hasNode() && !isImmutable()) {
    353371            if (parent == null) {
    354372                // This is a null pattern node without hope of creating
     
    428446     */
    429447    private void setNode(String newName, N node) {
    430         verifyMutability();
    431448        // This is an internal method because it does not update the caches in the parent node.
    432449        // it needs to be protected to be accessible from the parent node.
     
    450467     */
    451468    public V value() {
    452         if (!nodeExists() || isAmbiguous()) {
     469        if (!nodeExists() || isAmbiguous() || isImmutable()) {
    453470            return null;
    454471        }
     
    465482     */
    466483    public void setValue(V newValue) throws AnnotationEditException {
     484        verifyMutability();
    467485        try {
    468486            node().setAnnotationValue(newValue);
     
    481499    public T valueAsAnnotation() {
    482500        if (!valueAnnotation_cacheComputed) {
    483             verifyMutability();
     501            verifyMutability();
    484502            valueAnnotation_cacheComputed = true;
    485503            if (isAmbiguous()) {
     
    566584     */
    567585    public boolean nodeExists() {
    568         if (parent() != null) {
     586        if (parent() != null && !parent.isImmutable()) {
    569587            asGeneric(parent()).computeSubNodesCache();
    570588        }
     
    928946
    929947    private void setNodeWasSetFlags() {
    930         verifyMutability();
    931948        nodeWasSet = true;
    932949        if (parent() != null) {
     
    936953
    937954    private void setSubNodeNodeWasSet() {
    938         verifyMutability();
    939955        subNodeNodeWasSet = true;
    940956    }
    941957
    942958    private void clearNodeWasSetFlags() {
    943         verifyMutability();
    944959        nodeWasSet = false;
    945960        subNodeNodeWasSet = false;
Note: See TracChangeset for help on using the changeset viewer.