VectorIterator.h

Go to the documentation of this file.

#ifndef SimTK_SIMMATRIX_VECTORITERATOR_H_
#define SimTK_SIMMATRIX_VECTORITERATOR_H_

/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2005-13 Stanford University and the Authors.        *
 * Authors: Peter Eastman                                                     *
 * Contributors: Michael Sherman                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */

#include <cstddef>

namespace SimTK {

//==============================================================================
//                            VECTOR ITERATOR
//==============================================================================
template <class ELT, class VECTOR_CLASS>
class VectorIterator {
public:
    typedef ELT value_type;
    typedef ptrdiff_t difference_type;
    typedef ELT& reference;
    typedef ELT* pointer;
    typedef std::random_access_iterator_tag iterator_category;
    VectorIterator(VECTOR_CLASS& vector, ptrdiff_t index) 
    :   vector(vector), index(index) {}
    VectorIterator(const VectorIterator& iter) 
    :   vector(iter.vector), index(iter.index) {}
    VectorIterator& operator=(const VectorIterator& iter) {
        vector = iter.vector;
        index = iter.index;
        return *this;
    }
    ELT& operator*() {
        assert (index >= 0 && index < vector.size());
        return vector[(int)index];
    }
    ELT& operator[](ptrdiff_t i) {
        assert (i >= 0 && i < vector.size());
        return vector[(int)i];
    }
    VectorIterator operator++() {
        assert (index < vector.size());
        ++index;
        return *this;
    }
    VectorIterator operator++(int) {
        assert (index < vector.size());
        VectorIterator current = *this;
        ++index;
        return current;
    }
    VectorIterator operator--() {
        assert (index > 0);
        --index;
        return *this;
    }
    VectorIterator operator--(int) {
        assert (index > 0);
        VectorIterator current = *this;
        --index;
        return current;
    }
    VectorIterator operator+=(ptrdiff_t n) {
        assert (0 <= index+n && index+n <= vector.size());
        index += n;
        return *this;
    }
    VectorIterator operator-=(ptrdiff_t n) {
        assert (0 <= index-n && index-n <= vector.size());
        index -= n;
        return *this;
    }
    bool operator<(VectorIterator iter) const {
        return (index < iter.index);
    }
    bool operator>(VectorIterator iter) const {
        return (index > iter.index);
    }
    bool operator<=(VectorIterator iter) const {
        return (index <= iter.index);
    }
    bool operator>=(VectorIterator iter) const {
        return (index >= iter.index);
    }
    ptrdiff_t operator-(VectorIterator iter) const {
        return (index - iter.index);
    }
    VectorIterator operator-(ptrdiff_t n) const {
        return VectorIterator(vector, index-n);
    }
    VectorIterator operator+(ptrdiff_t n) const {
        return VectorIterator(vector, index+n);
    }
    bool operator==(VectorIterator iter) const {
        return (index == iter.index);
    }
    bool operator!=(VectorIterator iter) const {
        return (index != iter.index);
    }
private:
    VECTOR_CLASS& vector;
    ptrdiff_t index;
};

} //namespace SimTK

#endif // SimTK_SIMMATRIX_VECTORITERATOR_H_