ImageVariable.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _PANODATA_IMAGEVARIABLE_H
#define _PANODATA_IMAGEVARIABLE_H


namespace HuginBase
{

template <class Type>
class ImageVariable
{
public:
    ImageVariable();
    
    ImageVariable(Type data);
    
    ImageVariable(ImageVariable<Type> * link);
    
    ImageVariable(const ImageVariable &source);
    
    ~ImageVariable();
    
    Type getData() const;
    
    void setData(const Type data);
    
    void linkWith(ImageVariable<Type> * link);
    
    void removeLinks();
    
    bool isLinked() const;
    
    bool isLinkedWith(const ImageVariable<Type> * otherVariable) const;
    
protected:
    bool searchBackwards(const ImageVariable<Type> * otherVariable) const;
    
    bool searchForwards(const ImageVariable<Type> * otherVariable) const;
    
    ImageVariable<Type> * findStart();
    
    ImageVariable<Type> * findEnd();
    
    void setBackwards(const Type data);
    
    void setForwards(const Type data);
    
    // Member variables
    
    Type m_data;
    
    ImageVariable<Type> * m_linkPrevious;
    ImageVariable<Type> * m_linkNext;
}; // ImageVariable class

// Public member functions //

// Constructors

template <class Type>
ImageVariable<Type>::ImageVariable()
{
    // Start not linked to anything, so the variable is independant.
    m_linkPrevious = 0;
    m_linkNext = 0;
}

template <class Type>
ImageVariable<Type>::ImageVariable(Type data)
{
    // Use the data given
    m_data = data;
    // ...and start not linked to anything.
    m_linkPrevious = 0;
    m_linkNext = 0;
}

template <class Type>
ImageVariable<Type>::ImageVariable(ImageVariable<Type> * link)
{
    // So we don't break linkWith:
    m_linkPrevious = 0;
    m_linkNext = 0;
    // make the link. Note this sets our data from linked variables.
    linkWith(link);
}

template <class Type>
ImageVariable<Type>::ImageVariable(const ImageVariable<Type> & source)
{
    // When creating a copy, make independant.
    m_data = source.m_data;
    m_linkNext = 0;
    m_linkPrevious = 0;
}

// Destructor

template <class Type>
ImageVariable<Type>::~ImageVariable()
{
    // We will need to remove the links to this variable to keep the list sane.
    removeLinks();
    // it is safe to delete this object now.
}

// Other public member functions

template <class Type>
Type ImageVariable<Type>::getData() const
{
    return m_data;
}

template <class Type>
void ImageVariable<Type>::setData(const Type data)
{
    /* We keep multiple copies of the data.
     * Hopefully the data isn't too large, and setData is called far less often
     * then getData, so it should be fast enough this way.
     */    
    // set all the linked variables.
    // these both set this variables data.
    setBackwards(data);
    setForwards(data);
}

template <class Type>
void ImageVariable<Type>::linkWith(ImageVariable<Type> * link)
{
    // We need to first check that we aren't linked already.
    if (searchBackwards(link) || searchForwards(link))
    {
        DEBUG_INFO("Attempt to link already linked variables");
        return;
    }
    else
    {
        // not linked, it is safe to merge them.
        /* we need to merge the two sets together. We link the end of the list
         * with this object in it to the beginning of the list passed to us.
         */
        ImageVariable<Type> *end = findEnd();
        ImageVariable<Type> *beginning = link->findStart();
        end->m_linkNext = beginning;
        beginning->m_linkPrevious = end;
        // now we must set the data from what we were linked to.
        /* the link target has the same data, but the stuff previously linked
         * with us might have something different.
         */
        setBackwards(link->m_data);
    }
}

template <class Type>
void ImageVariable<Type>::removeLinks()
{
    if (m_linkPrevious)
    {
        // there is something before us, link it to the item after, or 0 if none
        m_linkPrevious->m_linkNext = m_linkNext;
    }
    if (m_linkNext)
    {
        // there is something after us, link it to the item before, or 0 if none
        m_linkNext->m_linkPrevious = m_linkPrevious;
        m_linkNext = 0;
    }
    m_linkPrevious = 0;
}

template <class Type>
bool ImageVariable<Type>::isLinked() const
{
    // return true if there are any links, false if this variable is independant
    return (m_linkPrevious || m_linkNext);
}

template <class Type>
bool ImageVariable<Type>::isLinkedWith(const ImageVariable<Type> * otherVariable) const
{
    // return true if we can find a link with the given item.
    return (searchBackwards(otherVariable) || searchForwards(otherVariable));
}

// Protected member functions //

template <class Type>
bool ImageVariable<Type>::searchBackwards(const ImageVariable<Type> * otherVariable) const
{
    // is this what we are looking for?
    if (this == otherVariable) return true;
    // are there any more items to check?
    if (!m_linkPrevious) return false;
    // try another one.
    return m_linkPrevious->searchBackwards(otherVariable);
}

template <class Type>
bool ImageVariable<Type>::searchForwards(const ImageVariable<Type> * otherVariable) const
{
    // is this what we are looking for?
    if (this == otherVariable) return true;
    // are there any more items to check?
    if (!m_linkNext) return false;
    // try another one.
    return m_linkNext->searchForwards(otherVariable);
}

template <class Type>
ImageVariable<Type> * ImageVariable<Type>::findStart()
{
    // Is this the start of the list?
    if (!m_linkPrevious) return this;
    // look father back
    return m_linkPrevious->findStart();
}

template <class Type>
ImageVariable<Type> * ImageVariable<Type>::findEnd()
{
    // Is this the end of the list?
    if (!m_linkNext) return this;
    // look father forwards
    return m_linkNext->findEnd();
}

template <class Type>
void ImageVariable<Type>::setBackwards(const Type data)
{
    // set this and all proceeding items.
    m_data = data;
    if (m_linkPrevious) m_linkPrevious->setBackwards(data);
}

template <class Type>
void ImageVariable<Type>::setForwards(const Type data)
{
    // set this and all proceeding items.
    m_data = data;
    if (m_linkNext) m_linkNext->setForwards(data);
}

} // HuginBase namespace

#endif // ndef _PANODATA_IMAGEVARIABLE_H

---