UN_Iterator.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UN_Iterator.h ( UN Library, C++)
 *
 * COMMENTS:
 *      
 */

#ifndef __UN_Iterator_h__
#define __UN_Iterator_h__

#include "UN_API.h"
#include "UN_Include.h"
#include <UT/UT_StringArray.h>
#include <iterator>

class UN_GraphData;


// ============================================================================
/// Iterator for traversing the given data ID array and 
/// returning a data handle when the iterator is dereferenced.
///     HANDLE - is a class derived from UN_Handle or UN_ConstHandle
///     GRAPH_DATA is UN_GraphData class, either const or non-const
///     ID_ITERATOR is an underlying iterator to the UN_DataID entries,
///             usually UN_Array<ID>, and can be either forward or backward.
template <typename HANDLE, typename GRAPH_DATA, typename DATA_ID_ITERATOR>
class UN_HandleIterator
{
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = HANDLE;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;

    /// Constructor for the start iterator of the given data ID array.
    UN_HandleIterator( GRAPH_DATA *graph_data, 
            const DATA_ID_ITERATOR &data_id_iterator )
        : myGraphData( graph_data )
        , myDataIDIterator( data_id_iterator )
    {}

    /// @{ Comparison operators.
    bool operator ==( const UN_HandleIterator &other ) const
                { return myDataIDIterator == other.myDataIDIterator; }
    bool operator !=( const UN_HandleIterator &other) const
                { return myDataIDIterator != other.myDataIDIterator; }
    /// @}

    /// Increment operator.
    UN_HandleIterator &operator++()     
    { 
        ++myDataIDIterator; 
        return *this; 
    }

    /// Dereferencing operator, returns the handle to the current data object.
    HANDLE operator*() const
    {
        return handle();
    }

    /// Dereferencing operator, returns the handle to the current data object.
    HANDLE handle() const
    {
        return HANDLE( myGraphData, *myDataIDIterator );
    }

private:
    /// The graph that owns the data objects.
    GRAPH_DATA *        myGraphData;

    /// The underlying data ID iterator to which to delegate the calls.
    DATA_ID_ITERATOR    myDataIDIterator;
};


// ============================================================================
/// Iterator for traversing two string arrays at the same time. 
class UN_API UN_NameAndTypeIterator
{
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = std::pair<const UT_StringHolder&,const UT_StringHolder&>;
    using difference_type = exint;
    using pointer = value_type*;
    using reference = value_type&;

    UN_NameAndTypeIterator( const UT_StringArray &names,
            const UT_StringArray &types, 
            exint current )
        : myNames( names )
        , myTypes( types )
        , myCurrent( current )
    {
        UT_ASSERT( names.size() == types.size() );
        UT_ASSERT( current >= 0 );
        UT_ASSERT( current <= names.size() ); // curr == size for end iterator
    }


    /// Equality comparison operator.
    bool operator ==( const UN_NameAndTypeIterator &b ) const
    { 
        return myCurrent == b.myCurrent; 
    }

    /// Inequality comparison operator.
    bool operator !=( const UN_NameAndTypeIterator &b ) const
    { 
        return myCurrent != b.myCurrent; 
    }

    /// Pre-increment operator.
    UN_NameAndTypeIterator& operator++()        
    { 
        ++myCurrent; 
        return *this;
    }

    /// Returns the current pair of strings (usually name and type).
    value_type operator*() const
    { 
        return myCurrent < myNames.size() 
            ? value_type( name(), type() )
            : value_type( UT_StringHolder::theEmptyString,
                          UT_StringHolder::theEmptyString );
    }

    /// Returns the name string.
    const UT_StringHolder & name() const
    {
        return myNames[ myCurrent ]; 
    }

    /// Returns the type string.
    const UT_StringHolder & type() const
    {
        return myTypes[ myCurrent ]; 
    }

private:
    /// The arrays the iterator is iterating over, and the current positon.
    const UT_StringArray &  myNames;
    const UT_StringArray &  myTypes;
    exint                   myCurrent = 0;
};


#endif