VRS - The Virtual Rendering System

version 3.3

array.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2004 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: array.h 4594 2004-12-10 14:40:30Z baumann $
//
// $Log$
// Revision 1.44  2004/12/10 14:40:23  baumann
// moved serialization of std::vector<T> into stl_serialization.h
//

#ifndef VRS_CONTAINER_ARRAY_H
#define VRS_CONTAINER_ARRAY_H

#include <vrs/container/sequencecontainerstl.h>
#include <vector>

namespace VRS {

inline bool* NonPersistentArray_Pointer_Impl(const std::vector<bool>& v) {
    return NULL;
}

template<typename T>
inline T* NonPersistentArray_Pointer_Impl(const std::vector<T>& v) {
    return const_cast<T*>(&(v[0]));
}

template<typename T>
class NonPersistentArray : public SequenceContainerSTL<T, std::vector<T> > {
public:
    NonPersistentArray() : SequenceContainerSTL<T, std::vector<T> >() { }
    NonPersistentArray(unsigned int size) : SequenceContainerSTL<T, std::vector<T> >(size) { }
    NonPersistentArray(unsigned int size, const T& initValue) : SequenceContainerSTL<T, std::vector<T> >(size, initValue) { }
    NonPersistentArray(const Iterator<T>* sourceItr) : SequenceContainerSTL<T, std::vector<T> >(sourceItr) { }

    T*       pointer()       { return NonPersistentArray_Pointer_Impl(this->containerSTL()); }
    const T* pointer() const { return NonPersistentArray_Pointer_Impl(this->containerSTL()); }
    
    virtual Iterator<T>* newIterator() const;
    
    void reserve(unsigned int value) { this->containerSTL().reserve(value); }
    
    VRS_TYPEINFO(NonPersistentArray, VRS_TEMPLATE_ARGS_2(T, std::vector<T>, SequenceContainerSTL));
    VRS_SERIALIZABLE_ABSTRACT_CLASS(NonPersistentArray);
};

template<typename T>
void NonPersistentArray<T>::serialize(SerializationManager&) {
    VRS_NoImpl(NonPersistentArray<T>::ClassNameVRS() << "::serialize() not supported: use "
               "Array<T> for serialization instead!");
}


template<typename T>
class ArrayIterator : public SequenceContainerIteratorSTL<T, std::vector<T> > {
public:
    ArrayIterator(const NonPersistentArray<T>* container)
        : SequenceContainerIteratorSTL<T, std::vector<T> >(container) { }

    virtual const T* pointer() const { return static_cast<NonPersistentArray<T>*>(this->container())->pointer(); }

    VRS_TYPEINFO(ArrayIterator, VRS_TEMPLATE_ARGS_2(T, std::vector<T>, SequenceContainerIteratorSTL));
    VRS_SERIALIZABLE(ArrayIterator);

protected:
    ArrayIterator() { } // only for serialization
};

template<typename T>
void ArrayIterator<T>::serialize(SerializationManager& doc) {
        // typedef, because the serialization macro doesn't like templates with 2 template parameter
        typedef SequenceContainerIteratorSTL<T, std::vector<T> > Parent;
        VRS_SERIALIZATION_PARENT_CLASS(doc, Parent);
}

template<typename T>
Iterator<T>* NonPersistentArray<T>::newIterator() const {
    return (this->iterator_ ? this->iterator_ : new ArrayIterator<T>(this));
}


template<typename T>
class Array : public NonPersistentArray<T> {
public:
    Array() : NonPersistentArray<T>() { }
    Array(unsigned int size) : NonPersistentArray<T>(size) { }
    Array(unsigned int size, const T& initValue) : NonPersistentArray<T>(size, initValue) { }
    Array(const Iterator<T>* sourceItr) : NonPersistentArray<T>(sourceItr) { }

    VRS_TYPEINFO(Array, NonPersistentArray<T>);
    VRS_SERIALIZABLE(Array);
};

template<typename T>
void Array<T>::serialize(SerializationManager& doc) {
    VRS_SERIALIZATION_PARENT_CLASS(doc, SharedObj); // skip some super-classes!!!
    serialization(doc, "Container", this->containerSTL());
}

VRS_SERIALIZATION_REGISTRATION_TEMPLATE(Array);
VRS_SERIALIZATION_REGISTRATION_TEMPLATE(ArrayIterator);

} // namespace VRS

#include <vrs/container/stl_serialization.h>

#endif // VRS_CONTAINER_ARRAY_H

---

Generated on Tue May 21 06:00:17 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact