Attachment 147786 Details for Bug 290137 – Java file that breaks iajc

Java file that breaks iajc

OneToMany.java (text/plain), 3.83 KB, created by Troy Anderson

on 2009-09-22 11:14:26 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Troy Anderson

Created: 2009-09-22 11:14:26 EDT

Size: 3.83 KB

patch

obsolete

>package com.webroot.models.account;
>
>import org.terracotta.modules.annotations.*;
>
>import java.util.*;
>import java.util.concurrent.*;
>
>@InstrumentedClass
>@HonorTransient
>abstract public class OneToMany<C, K> implements ConcurrentMap<K,C>, ParentAssociation<C>
>{
>// ------------------------------ FIELDS ------------------------------
>
>    ConcurrentHashMap<K, C> map = new ConcurrentHashMap<K, C>();
>
>// ------------------------ CANONICAL METHODS ------------------------
>
>    public boolean equals(Object o) {return map.equals(o);}
>
>    public int hashCode() {return map.hashCode();}
>
>    public String toString() {return map.toString();}
>
>// ------------------------ INTERFACE METHODS ------------------------
>
>
>// --------------------- Interface Map ---------------------
>
>    public int size() {return map.size();}
>
>    public boolean isEmpty() {return map.isEmpty();}
>
>    public boolean containsKey(Object key) {return map.containsKey(key);}
>
>    public boolean containsValue(Object value) {return map.containsValue(value);}
>
>    public C get(Object key) {return map.get(key);}
>
>    @Override
>    @AutolockWrite
>    synchronized
>    public C put(K key, C child)
>    {
>        synchronized (child)
>        {
>            assignParent( child);
>            return map.put( key, child);
>        }
>    }
>
>    @Override
>    @AutolockWrite
>    synchronized
>    public C remove(Object key)
>    {
>        final C child = map.remove(key);
>        if (child != null) {unassignParent(child);}
>        return child;
>    }
>
>    @AutolockWrite
>    synchronized
>    public void putAll(Map<? extends K, ? extends C> children)
>    {
>        map.putAll(children);
>        for (C child : children.values())
>        {
>            unassignParent(child);
>        }
>    }
>
>    @Override
>    public void clear()
>    {
>        for (C child : map.values())
>        {
>            unassignParent(child);
>        }
>        map.clear();
>    }
>
>    public Set<K> keySet() {return map.keySet();}
>
>    public Collection<C> values() {return map.values();}
>
>    public Set<Entry<K, C>> entrySet() {return map.entrySet();}
>
>// --------------------- Interface ConcurrentMap ---------------------
>
>    @AutolockWrite
>    synchronized
>    public C putIfAbsent(K key, C child)
>    {
>        C c = map.putIfAbsent(key, child);
>        if (c == null)
>        {
>            assignParent(child);
>        }
>        return c;
>    }
>
>    @Override
>    @AutolockWrite
>    synchronized
>    public boolean remove(Object key, Object value)
>    {
>        C child = (C) value;
>        unassignParent(child);
>        return map.remove(key, value);
>    }
>
>    @AutolockWrite
>    synchronized
>    public boolean replace(K key, C oldValue, C newValue)
>    {
>        final boolean success = map.replace( key,  oldValue,  newValue);
>        if (success)
>        {
>            unassignParent( oldValue);
>            assignParent( newValue);
>        }
>        return success;
>    }
>
>    @AutolockWrite
>    synchronized
>    public C replace(K key, C value)
>    {
>        final C child = map.replace( key,  value);
>        if (child != null) {unassignParent(child);}
>        return child;
>    }
>
>// --------------------- Interface ParentAssociation ---------------------
>
>                                                        
>    public abstract void assignParent(C child);
>    
>    public abstract void unassignParent(C child);
>
>// -------------------------- OTHER METHODS --------------------------
>
>    public boolean contains(Object value) {return map.contains(value);}
>
>    public Enumeration<C> elements() {return map.elements();}
>
>    public Enumeration<K> keys() {return map.keys();}
>}
>
>interface ParentAssociation<C> {
>
>    abstract void assignParent(C child);
>    
>    abstract void unassignParent(C child);
>}

Actions: View

Attachments on bug 290137: 147786 | 147837