Clover coverage report - Maven Clover report
Coverage timestamp: Sun Jun 1 2008 20:05:13 EST
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 216   Methods: 16
NCLOC: 167   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
ValueUpdaterInfo.java 67.5% 81.4% 81.2% 77.5%
coverage coverage
 1    /**
 2    * Copyright 2007 The Apache Software Foundation
 3    *
 4    * Licensed under the Apache License, Version 2.0 (the "License");
 5    * you may not use this file except in compliance with the License.
 6    * You may obtain a copy of the License at
 7    *
 8    * http://www.apache.org/licenses/LICENSE-2.0
 9    *
 10    * Unless required by applicable law or agreed to in writing, software
 11    * distributed under the License is distributed on an "AS IS" BASIS,
 12    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13    * See the License for the specific language governing permissions and
 14    * limitations under the License.
 15    */
 16    package org.codehaus.wadi.aop.tracker.basic;
 17   
 18    import java.io.Externalizable;
 19    import java.io.IOException;
 20    import java.io.ObjectInput;
 21    import java.io.ObjectOutput;
 22    import java.lang.reflect.Constructor;
 23    import java.lang.reflect.Field;
 24    import java.lang.reflect.Member;
 25    import java.lang.reflect.Method;
 26    import java.util.HashSet;
 27    import java.util.Set;
 28   
 29    import org.codehaus.wadi.aop.ClusteredStateMarker;
 30    import org.codehaus.wadi.aop.tracker.InstanceRegistry;
 31    import org.codehaus.wadi.aop.tracker.InstanceTracker;
 32    import org.codehaus.wadi.core.reflect.ClassIndexer;
 33    import org.codehaus.wadi.core.reflect.ClassIndexerRegistry;
 34    import org.codehaus.wadi.core.reflect.MemberUpdater;
 35   
 36    /**
 37    *
 38    * @version $Revision: 1538 $
 39    */
 40    public class ValueUpdaterInfo implements Externalizable {
 41    private final InstanceAndTrackerReplacer replacer;
 42    private final ClassIndexerRegistry classIndexerRegistry;
 43   
 44    private Class targetClass;
 45    private int memberUpdaterIndex;
 46    protected Object[] parameters;
 47    protected Object[] parametersReplacedWithTrackers;
 48    protected Set<InstanceTracker> instanceTrackers;
 49    protected String instanceId;
 50   
 51  15 public static void applyTo(InstanceRegistry instanceRegistry, ValueUpdaterInfo[] valueUpdaterInfos) {
 52  15 for (ValueUpdaterInfo valueUpdaterInfo : valueUpdaterInfos) {
 53  50 valueUpdaterInfo.execute(instanceRegistry);
 54    }
 55    }
 56   
 57  51 public ValueUpdaterInfo(InstanceAndTrackerReplacer replacer, ClassIndexerRegistry classIndexerRegistry) {
 58  51 if (null == replacer) {
 59  0 throw new IllegalArgumentException("replacer is required");
 60  51 } else if (null == classIndexerRegistry) {
 61  0 throw new IllegalArgumentException("classIndexerRegistry is required");
 62    }
 63  51 this.replacer = replacer;
 64  51 this.classIndexerRegistry = classIndexerRegistry;
 65    }
 66   
 67  155 public ValueUpdaterInfo(InstanceAndTrackerReplacer replacer, int memberUpdaterIndex, Object[] parameters) {
 68  155 if (null == replacer) {
 69  0 throw new IllegalArgumentException("replacer is required");
 70  155 } else if (null == parameters) {
 71  0 throw new IllegalArgumentException("parameters is required");
 72    }
 73  155 this.replacer = replacer;
 74  155 this.memberUpdaterIndex = memberUpdaterIndex;
 75  155 this.parameters = parameters;
 76   
 77  155 classIndexerRegistry = null;
 78    }
 79   
 80  60 public ValueUpdaterInfo(InstanceAndTrackerReplacer replacer,
 81    Class targetClass,
 82    int memberUpdaterIndex,
 83    Object[] parameters) {
 84  60 if (null == replacer) {
 85  0 throw new IllegalArgumentException("replacer is required");
 86  60 } else if (null == targetClass) {
 87  0 throw new IllegalArgumentException("targetClass is required");
 88  60 } else if (null == parameters) {
 89  0 throw new IllegalArgumentException("parameters is required");
 90    }
 91  60 this.replacer = replacer;
 92  60 this.targetClass = targetClass;
 93  60 this.memberUpdaterIndex = memberUpdaterIndex;
 94  60 this.parameters = parameters;
 95   
 96  60 classIndexerRegistry = null;
 97    }
 98   
 99  39 protected ValueUpdaterInfo(ValueUpdaterInfo prototype) {
 100  39 if (null == prototype) {
 101  0 throw new IllegalArgumentException("prototype is required");
 102  39 } else if (null == prototype.instanceId) {
 103  0 throw new IllegalArgumentException("prototype does not have an instanceId");
 104    }
 105   
 106  39 memberUpdaterIndex = prototype.memberUpdaterIndex;
 107  39 instanceId = prototype.instanceId;
 108  39 replacer = prototype.replacer;
 109  39 parameters = null;
 110  39 if (null != prototype.parametersReplacedWithTrackers) {
 111  26 parametersReplacedWithTrackers = prototype.parametersReplacedWithTrackers;
 112    } else {
 113  13 parametersReplacedWithTrackers =
 114    (Object[]) replacer.replaceWithTracker(prototype.parameters, new HashSet<InstanceTracker>());
 115    }
 116   
 117  39 classIndexerRegistry = null;
 118    }
 119   
 120  0 public String getInstanceId() {
 121  0 return instanceId;
 122    }
 123   
 124  293 public void setInstanceId(String instanceId) {
 125  293 if (null != this.instanceId) {
 126  1 throw new IllegalStateException("instanceId is already set");
 127    }
 128  292 this.instanceId = instanceId;
 129    }
 130   
 131  63 public Set<InstanceTracker> getInstanceTrackers() {
 132  63 if (null != instanceTrackers) {
 133  23 return instanceTrackers;
 134    }
 135  40 instanceTrackers = new HashSet<InstanceTracker>();
 136  40 parametersReplacedWithTrackers = (Object[]) replacer.replaceWithTracker(parameters, instanceTrackers);
 137  40 return instanceTrackers;
 138    }
 139   
 140  1 public Object[] getParametersReplacedWithTrackers() {
 141  1 if (null == parametersReplacedWithTrackers) {
 142  0 throw new IllegalStateException("parametersReplacedWithTrackers not set.");
 143    }
 144  1 return parametersReplacedWithTrackers;
 145    }
 146   
 147  0 public Object[] getParameters() {
 148  0 if (null == parameters) {
 149  0 throw new IllegalStateException("parameters not set. This is a snapshotForSerialization instance.");
 150    }
 151  0 return parameters;
 152    }
 153   
 154  51 public void execute(InstanceRegistry instanceRegistry) {
 155  51 Object[] newParameters =
 156    (Object[]) replacer.replaceWithInstance(instanceRegistry, parametersReplacedWithTrackers);
 157   
 158  51 ClassIndexer classIndexer;
 159  51 if (null != targetClass) {
 160  14 classIndexer = classIndexerRegistry.getClassIndexer(targetClass);
 161    } else {
 162  37 ClusteredStateMarker instance = (ClusteredStateMarker) instanceRegistry.getInstance(instanceId);
 163  37 classIndexer = instance.$wadiGetTracker().getClassIndexer();
 164    }
 165   
 166  51 MemberUpdater memberUpdater = classIndexer.getMemberUpdater(memberUpdaterIndex);
 167  51 ValueUpdater valueUpdater = newValueUpdater(memberUpdater);
 168  51 valueUpdater.executeWithParameters(instanceRegistry, instanceId, newParameters);
 169    }
 170   
 171  53 protected ValueUpdater newValueUpdater(MemberUpdater memberUpdater) throws AssertionError {
 172  53 Member member = memberUpdater.getMember();
 173  53 if (member instanceof Constructor) {
 174  15 return new ConstructorInfo(memberUpdater);
 175  38 } else if (member instanceof Method) {
 176  11 return new MethodInfo(memberUpdater);
 177  27 } else if (member instanceof Field) {
 178  27 return new FieldInfo(memberUpdater);
 179    }
 180  0 throw new AssertionError(memberUpdater);
 181    }
 182   
 183  38 public ValueUpdaterInfo snapshotForSerialization() {
 184  38 return new ValueUpdaterInfo(this);
 185    }
 186   
 187  51 public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
 188  51 boolean constructor = in.readBoolean();
 189  51 if (constructor) {
 190  14 targetClass = (Class) in.readObject();
 191    }
 192   
 193  51 memberUpdaterIndex = in.readInt();
 194  51 parametersReplacedWithTrackers = (Object[]) in.readObject();
 195  51 instanceId = in.readUTF();
 196    }
 197   
 198  51 public void writeExternal(ObjectOutput out) throws IOException {
 199  51 if (null != targetClass) {
 200  14 out.writeBoolean(true);
 201  14 out.writeObject(targetClass);
 202    } else {
 203  37 out.writeBoolean(false);
 204    }
 205   
 206  51 out.writeInt(memberUpdaterIndex);
 207  51 out.writeObject(parametersReplacedWithTrackers);
 208  51 out.writeUTF(instanceId);
 209    }
 210   
 211  0 @Override
 212    public String toString() {
 213  0 return "ValueUpdaterInfo for [" + instanceId + "]; Index [" + memberUpdaterIndex + "]";
 214    }
 215   
 216    }
 
CloverReport generated by Clover Code Coverage v1.3.13
Sun Jun 1 2008 20:05:21 EST.		   Open Source License registered to the WADI Project. This license of Clover is provided to support the development of WADI only.