Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   **** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Eclipse Public
   * License Version 1.0 (the "License"); you may not use this file
   * except in compliance with the License. You may obtain a copy of
   * the License at http://www.eclipse.org/legal/epl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2013 The JRuby team <jruby@jruby.org>
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the EPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the EPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 package org.jruby.ir.listeners;
 
 import java.util.List;
 
 public class InstructionsListenerDecorator implements List<Instr> {
     private final List<Instrinstrs;
     private final InstructionsListener listener;
 
     private class InstructionsListIterator implements ListIterator<Instr> {
         private Instr currentInstr;
         private int currentIndex;
         private final ListIterator<InstrlistIterator;
 
         public InstructionsListIterator() {
             this. = null;
             this. = -1;
             this. = .listIterator();
         }
 
         @Override
         public boolean hasNext() {
             return .hasNext();
         }
 
         @Override
         public Instr next() {
              = .next();
              += 1;
             return ;
         }
 
         @Override
         public boolean hasPrevious() {
             return .hasPrevious();
         }
 
         @Override
         public Instr previous() {
              = .previous();
              -= 1;
             return ;
         }
 
         @Override
         public int nextIndex() {
             int index =  + 1;
 
             return index < .size() ? index : .size();
         }
 
         @Override
         public int previousIndex() {
             int index =  - 1;
 
             return index > -1 ? index : -1;
         }
 
         @Override
         public void remove() {
             .remove();
         }
 
         @Override
         public void set(Instr e) {
            .set(e);
        }
        @Override
        public void add(Instr e) {
            .add(e);
        }
    }
    public InstructionsListenerDecorator(List<InstrinstrsInstructionsListener listener) {
        this. = instrs;
        this. = listener;
    }
    @Override
    public int size() {
        return .size();
    }
    @Override
    public boolean isEmpty() {
        return .isEmpty();
    }
    @Override
    public boolean contains(Object o) {
        return .contains(o);
    }
    @Override
    public Iterator<Instriterator() {
        return new InstructionsListIterator();
    }
    @Override
    public Object[] toArray() {
        return .toArray();
    }
    @Override
    public <T> T[] toArray(T[] a) {
        return .toArray(a);
    }
    @Override
    public boolean add(Instr e) {
        int index = .size() + 1;
        .instrChanged(nulleindex..);
        return .add(e);
    }
    @Override
    public boolean remove(Object o) {
        int index = .indexOf(o);
        if (index != -1) .instrChanged(, (Instronullindex..);
        return .remove(o);
    }
    @Override
    public boolean containsAll(Collection<?> c) {
        return .containsAll(c);
    }
    @Override
    public boolean addAll(Collection<? extends Instrc) {
        int lastIndex = .size() - 1;
        return addAll(lastIndexc);
    }
    @Override
    public boolean addAll(int indexCollection<? extends Instrc) {
        ListIterator<Instriterator = listIterator(index);
        if (c.isEmpty()) return false;
        for (Instr instr : c) {
            iterator.add(instr);
        }
        return true;
    }
    @Override
    public boolean removeAll(Collection<?> c) {
        boolean hasChanged = false;
        for (Object item : c) {
            boolean hasRemoved = remove(item);
            if (!hasChangedhasChanged = hasRemoved;
        }
        return hasChanged;
    }
    @Override
    public boolean retainAll(Collection<?> c) {
        boolean hasChanged = false;
        ListIterator<Instriterator = listIterator();
        while(iterator.hasNext()) {
            int index = iterator.nextIndex();
            Instr instr = iterator.next();
            if (!c.contains(instr)) {
                boolean hasRemoved = remove(instr);
                if(!hasChangedhasChanged = hasRemoved;
            }
        }
        return hasChanged;
    }
    @Override
    public void clear() {
        retainAll(Collections.emptySet());
    }
    @Override
    public Instr get(int index) {
        return .get(index);
    }
    @Override
    public Instr set(int indexInstr element) {
        .instrChanged(nullelementindex..);
        return .set(indexelement);
    }
    @Override
    public void add(int indexInstr element) {
        .instrChanged(nullelementindex..);
        .add(indexelement);
    }
    @Override
    public Instr remove(int index) {
        .instrChanged(nullnullindex..);
        return .remove(index);
    }
    @Override
    public int indexOf(Object o) {
        return .indexOf(o);
    }
    @Override
    public int lastIndexOf(Object o) {
        return .lastIndexOf(o);
    }
    @Override
    public ListIterator<InstrlistIterator() {
        return new InstructionsListIterator();
    }
    @Override
    public ListIterator<InstrlistIterator(int index) {
        InstructionsListIterator iterator = new InstructionsListIterator();
        while (iterator.nextIndex() < index) {
            iterator.next();
        }
        return iterator;
    }
    @Override
    public List<InstrsubList(int fromIndexint toIndex) {
        return .subList(fromIndextoIndex);
    }
New to GrepCode? Check out our FAQ X