AttributeArray.h

/*
 * Copyright (C) 2014 Google Inc.
 *
 * 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.
 */

#ifndef ATTRIBUTEARRAY_H
#define ATTRIBUTEARRAY_H

#include "RendererCommon.h"

template<typename T>
class AttributeArray {
public:
    class Iterator {
    public:
        Iterator(GLbyte* ptr, int stride) : mPtr(ptr), mStride(stride) {
        }

        bool operator== (const Iterator& other) const {
            return mPtr == other.mPtr;
        }

        bool operator!= (const Iterator& other) const {
            return !(this->operator ==(other));
        }

        const T& operator* () const {
            return *(T*) (mPtr);
        }

        T& operator* () {
            return *(T*) (mPtr);
        }

        T* operator-> () {
            return (T*) (mPtr);
        }

        void operator++ () {
            mPtr += mStride;
        }
        void operator++ (int) {
            mPtr += mStride;
        }
        void operator-- () {
            mPtr -= mStride;
        }
        void operator-- (int) {
            mPtr -= mStride;
        }
    private:
        GLbyte* mPtr = nullptr;
        int mStride = 0;
    };

    typedef Iterator iterator;
    typedef const Iterator const_iterator;

    AttributeArray() {
    }
    AttributeArray(int count, GLbyte* arrayBase, int stride, const Attribute* attribute)
            : mCount(count),
              mArrayBase(arrayBase),
              mStride(stride),
              mAttribute(attribute) {
    }

    bool isValid() const { return mArrayBase; }
    const Attribute* getAttribute() const { return mAttribute; }

    const T& operator[] (int index) const {
        assert(isValid() && index >= 0 && index < mCount);
        return *(const T*) (mArrayBase + mStride * index);
    }
    T& operator[] (int index) {
        assert(isValid() && index >= 0 && index < mCount);
        return *(T*) (mArrayBase + mStride * index);
    }

    const Iterator begin() const {
        assert(isValid());
        return Iterator(mArrayBase, mStride);
    }
    Iterator begin() {
        assert(isValid());
        return Iterator(mArrayBase, mStride);
    }
    const Iterator end() const {
        assert(isValid());
        return Iterator(mArrayBase + mStride * mCount, mStride);
    }
    Iterator end() {
        assert(isValid());
        return Iterator(mArrayBase + mStride * mCount, mStride);
    }

    template<typename Y> AttributeArray<Y> getAsType() const {
        return AttributeArray<Y>(mCount, mArrayBase, mStride, mAttribute);
    }
private:
    int mCount = 0;
    GLbyte* mArrayBase = nullptr;
    int mStride = 0;
    const Attribute* mAttribute = nullptr;
};

#endif // ATTRIBUTEARRAY_H