Coverage Report - com.sun.javafx.runtime.location.SequenceConstant
 
Classes in this File Line Coverage Branch Coverage Complexity
SequenceConstant
15%
5/33
N/A
0
 
 1  
 package com.sun.javafx.runtime.location;
 2  
 
 3  
 import java.util.Iterator;
 4  
 
 5  
 import com.sun.javafx.runtime.sequence.Sequence;
 6  
 import com.sun.javafx.runtime.sequence.SequencePredicate;
 7  
 
 8  
 /**
 9  
  * SequenceConstant
 10  
  *
 11  
  * @author Brian Goetz
 12  
  */
 13  0
 public class SequenceConstant<T> extends AbstractConstantLocation<Sequence<T>> implements SequenceLocation<T> {
 14  
     private Sequence<T> $value;
 15  
 
 16  
     public static<T> SequenceLocation<T> make(Sequence<T> value) {
 17  1
         return new SequenceConstant<T>(value);
 18  
     }
 19  
 
 20  1
     protected SequenceConstant(Sequence<T> value) {
 21  1
         this.$value = value;
 22  1
     }
 23  
 
 24  
 
 25  
     public Sequence<T> getAsSequence() {
 26  2
         return $value;
 27  
     }
 28  
 
 29  
     public Sequence<T> get() {
 30  0
         return $value;
 31  
     }
 32  
 
 33  
     public Sequence<T> setAsSequence(Sequence<? extends T> value) {
 34  0
         throw new UnsupportedOperationException();
 35  
     }
 36  
 
 37  
     public Sequence<T> setAsSequenceFromLiteral(Sequence<? extends T> value) {
 38  0
         throw new UnsupportedOperationException();
 39  
     }
 40  
 
 41  0
     public void addChangeListener(SequenceChangeListener<T> listener) { }
 42  
 
 43  0
     public void removeChangeListener(SequenceChangeListener<T> listener) { }
 44  
 
 45  
     public T get(int position) {
 46  0
         return $value.get(position);
 47  
     }
 48  
 
 49  
     public Sequence<T> getSlice(int startPos, int endPos) {
 50  0
         return $value.getSlice(startPos, endPos);
 51  
     }
 52  
 
 53  
     public Sequence<? extends T> replaceSlice(int startPos, int endPos, Sequence<? extends T> newValues) {
 54  0
         throw new UnsupportedOperationException();
 55  
     }
 56  
 
 57  
     public void deleteSlice(int startPos, int endPos) {
 58  0
         throw new UnsupportedOperationException();
 59  
     }
 60  
 
 61  
     public void deleteAll() {
 62  0
         throw new UnsupportedOperationException();
 63  
     }
 64  
 
 65  
     public void deleteValue(T value) {
 66  0
         throw new UnsupportedOperationException();
 67  
     }
 68  
 
 69  
     public void delete(SequencePredicate<T> tSequencePredicate) {
 70  0
         throw new UnsupportedOperationException();
 71  
     }
 72  
 
 73  
     public void insertBefore(T value, SequencePredicate<T> tSequencePredicate) {
 74  0
         throw new UnsupportedOperationException();
 75  
     }
 76  
 
 77  
     public void insertBefore(Sequence<? extends T> values, SequencePredicate<T> tSequencePredicate) {
 78  0
         throw new UnsupportedOperationException();
 79  
     }
 80  
 
 81  
     public void insertAfter(T value, SequencePredicate<T> tSequencePredicate) {
 82  0
         throw new UnsupportedOperationException();
 83  
     }
 84  
 
 85  
     public void insertAfter(Sequence<? extends T> values, SequencePredicate<T> tSequencePredicate) {
 86  0
         throw new UnsupportedOperationException();
 87  
     }
 88  
 
 89  
     public void delete(int position) {
 90  0
         throw new UnsupportedOperationException();
 91  
     }
 92  
 
 93  
     public T set(int position, T value) {
 94  0
         throw new UnsupportedOperationException();
 95  
     }
 96  
 
 97  
     public void insert(T value) {
 98  0
         throw new UnsupportedOperationException();
 99  
     }
 100  
 
 101  
     public void insert(Sequence<? extends T> values) {
 102  0
         throw new UnsupportedOperationException();
 103  
     }
 104  
 
 105  
     public void insertFirst(T value) {
 106  0
         throw new UnsupportedOperationException();
 107  
     }
 108  
 
 109  
     public void insertFirst(Sequence<? extends T> values) {
 110  0
         throw new UnsupportedOperationException();
 111  
     }
 112  
 
 113  
     public void insertBefore(T value, int position) {
 114  0
         throw new UnsupportedOperationException();
 115  
     }
 116  
 
 117  
     public void insertBefore(Sequence<? extends T> values, int position) {
 118  0
         throw new UnsupportedOperationException();
 119  
     }
 120  
 
 121  
     public void insertAfter(T value, int position) {
 122  0
         throw new UnsupportedOperationException();
 123  
     }
 124  
 
 125  
     public void insertAfter(Sequence<? extends T> values, int position) {
 126  0
         throw new UnsupportedOperationException();
 127  
     }
 128  
 
 129  
     public Iterator<T> iterator() {
 130  0
         throw new UnsupportedOperationException();
 131  
     }
 132  
 }