vetBufferLink.h

#ifndef __VETLIB_VETBUFFERLINK_H__
 #define __VETLIB_VETBUFFERLINK_H__

 #include "../vetBuffer.h"


#define VETDEF_FPS_MAX                  1000  /* maximum number of frames per second */

#define VETRET_FRAME_NOT_FOUND      8254


template<class T>
class vetBufferLink : public vetBuffer<T>
 {
        protected:


                struct frameNode {
                        T* data;
                        struct frameNode * prev;
                        struct frameNode * next;
                 };

                frameNode* v_first;
                frameNode* v_current;
                frameNode* v_last;



        public:


                vetBufferLink() : vetBuffer<T>()
                 {
                        INFO("vetBufferLink::vetBufferLink()  : vetBuffer() [CONTRUCTOR]")

                        v_first = NULL;
                        v_current = NULL;
                        v_last = NULL;

                        reset();
                 }

                ~vetBufferLink()
                 {
                        INFO("vetBufferLink::~vetBufferLink() [DESTRUCTOR]")

                        if ( v_first == NULL)
                                return;

                        v_current = v_first->next;

                 }

                VETRESULT reset()
                 {
                        INFO("int vetBufferLink::reset() [SET DEFAULT PARAMETERS]")

                        v_first = NULL;
                        v_current = NULL;
                        v_last = NULL;
                        v_fcount = 0;

                        return VETRET_OK;
                 }

                VETRESULT deleteFrames()
                 {
                        if ( v_first != NULL)
                         {
                                v_current = v_first->next;

                                while ( v_current != NULL ) {
//BUGBUGBUG
                                        delete v_current->prev;
                                        delete v_current->data;
                                        v_current = v_current->next;
                                 }

                                delete v_last->data;
                                delete v_last;
                         }
                        else
                                return VETRET_ILLEGAL_USE;

                        return reset();
                 }





                VETRESULT addFrame(T* newFrame)
                 {
                        if ( &newFrame == NULL)
                                return VETRET_PARAM_ERR;

                        if ( v_fcount == 0) {
                                v_first = new frameNode;
                                v_first->next = NULL;
                                v_first->prev = NULL;

                                if ( copyData )
                                        v_first->data = new T(*newFrame);
                                else
                                        v_first->data = newFrame;

                                v_current = v_first;
                                v_last = v_first;
                                ++v_fcount;
                                return VETRET_OK;
                         }

                        frameNode* v_newlast = new frameNode;

                        if ( copyData )
                                v_newlast->data = new T(*newFrame);
                        else
                                v_newlast->data = newFrame;

                        v_newlast->prev = v_last;
                        v_newlast->next = NULL;
                        v_last->next = v_newlast;
                        v_last = v_newlast;
                        ++v_fcount;

                        return VETRET_OK;
                 }

                VETRESULT insertFrame(long index, T* newFrame)
                 {
                        if ( v_fcount == 0 && index != 0)
                                return VETRET_ILLEGAL_USE;

                        if ( &newFrame == NULL)
                                return VETRET_PARAM_ERR;

                        if ( v_fcount == 0 )
                                return addFrame(newFrame);

                        if ( index == v_fcount-1 )
                                return addFrame(newFrame);

                        if ( index == 0 )
                         {
                                frameNode* v_newNode = new frameNode;

                                if ( copyData )
                                        v_newNode->data = new T(*newFrame);
                                else
                                        v_newNode->data = newFrame;

                                v_newNode->prev = NULL;
                                v_newNode->next = v_first;
                                v_first->prev = v_newNode;
                                v_first = v_newNode;
                                ++v_fcount;
                                return VETRET_OK;
                         }

                        frameNode* iterFrame;
                        iterFrame = v_first;
                        long i = 0;
                        while ( iterFrame )
                         {
                                if ( i == index )
                                 {
                                        frameNode* v_newNode = new frameNode;

                                        if ( copyData )
                                                v_newNode->data = new T(*newFrame);
                                        else
                                                v_newNode->data = newFrame;

                                        v_newNode->prev = iterFrame->prev;
                                        v_newNode->next = iterFrame;
                                        iterFrame->prev->next = v_newNode;
                                        iterFrame->prev = v_newNode;
                                        ++v_fcount;
                                        return VETRET_OK;
                                 }
                                iterFrame = iterFrame->next;
                                i++;
                         }

                        return VETRET_INTERNAL_ERR;
                 }

                VETRESULT updateFrame(T* oldFrame, T* newFrame, bool removeold)
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        if ( &oldFrame == NULL || newFrame == NULL )
                                return VETRET_PARAM_ERR;

                        frameNode* iterFrame;
                        iterFrame = v_first;

                        while ( iterFrame  )
                         {
                                if ( iterFrame->data == oldFrame )
                                 {
                                        if (removeold)
                                                delete oldFrame;

                                        if ( copyData )
                                                iterFrame->data = new T(*newFrame);
                                        else
                                                iterFrame->data = newFrame;

                                        return VETRET_OK;
                                 }
                                iterFrame = iterFrame->next;
                         }

                        return VETRET_FRAME_NOT_FOUND;
                 }

                VETRESULT updateFrame(long index, T* newFrame, bool removeold)
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        if ( &newFrame == NULL)
                                return VETRET_PARAM_ERR;

                        if ( index > v_fcount-1 )
                                return VETRET_PARAM_ERR;

                        long distEnd = v_fcount - index;
                                frameNode* iterFrame;

                        if ( index < distEnd )
                         {
                                iterFrame = v_first;
                                long i = 0;
                                while ( iterFrame  )
                                 {
                                        if ( i == index )
                                         {
                                                        if ( removeold )
                                                                delete iterFrame->data;

                                                        if ( copyData )
                                                                iterFrame->data = new T(*newFrame);
                                                        else
                                                                iterFrame->data = newFrame;

                                                        return VETRET_OK;
                                         }
                                        iterFrame = iterFrame->next;
                                        i++;
                                 }
                         }
                        else
                         {
                                iterFrame = v_last;
                                long i = v_fcount-1;
                                while ( iterFrame  )
                                 {
                                        if ( i == index )
                                         {
                                                delete iterFrame->data;
                                                iterFrame->data = newFrame;
                                                return VETRET_OK;
                                         }
                                        iterFrame = iterFrame->prev;
                                        i--;
                                 }
                         }

                        return VETRET_FRAME_NOT_FOUND;
                 }

                VETRESULT removeFrame(T* frameToDelete, bool freeData = false)
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        if ( frameToDelete == NULL)
                                return VETRET_PARAM_ERR;

                        if ( v_fcount == 1)
                         {
                                delete v_first;
                                v_first = NULL;
                                v_current = NULL;
                                v_last = NULL;
                                v_fcount = 0;
                         }

                        if ( v_first->data == frameToDelete )
                         {
                                v_first = v_first->next;
                                delete v_first->prev;
                                v_first->prev = NULL;
                                --v_fcount;
                                return VETRET_OK;
                          }
                        else if ( v_last->data == frameToDelete)
                         {
                                v_last = v_last->prev;
                                delete v_last->next;
                                v_last->next = NULL;
                                --v_fcount;
                                return VETRET_OK;
                         }

                        frameNode* iterFrame;
                        iterFrame = v_first->next;
                        while ( iterFrame  )
                         {
                                if ( iterFrame->data == frameToDelete )
                                 {
                                        if ( freeData )
                                                delete frameToDelete;

                                        iterFrame->data = NULL;
                                        iterFrame->prev->next = iterFrame->next;
                                        iterFrame->next->prev = iterFrame->prev;

                                        delete iterFrame;
                                        --v_fcount;

                                        return VETRET_OK;
                                 }
                                iterFrame = iterFrame->next;
                         }

                        return VETRET_FRAME_NOT_FOUND;

                 }

                VETRESULT removeFrame(long index, bool freeData = false)
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        if ( index >= v_fcount)
                                return VETRET_PARAM_ERR;

                        if ( index == 0)
                         {
                                v_first->next = v_first;
                                delete v_first->prev;
                                v_first->prev = NULL;
                                return VETRET_OK;
                         }
                        else if ( index == v_fcount-1)
                         {
                                v_last->prev = v_last;
                                delete v_last->next;
                                v_last->next = NULL;
                                return VETRET_OK;
                         }


                        frameNode* iterFrame;
                        iterFrame = v_first->next;
                        long i = 0;
                        while ( iterFrame  )
                         {
                                if ( i == index )
                                 {
                                        if ( freeData )
                                                delete iterFrame->data;

                                        iterFrame->data = NULL;
                                        iterFrame->prev->next = iterFrame->next;
                                        iterFrame->next->prev = iterFrame->prev;

                                        delete iterFrame;
                                        --v_fcount;

                                        return VETRET_OK;
                                 }
                                iterFrame = iterFrame->next;
                                i++;
                         }

                        return VETRET_FRAME_NOT_FOUND;
                 }

                T* getCurrentFrame()
                 {
                        if ( v_fcount == 0)
                                throw "Video is Empty.";

                        return v_current->data;
                 }

                T* getPreviousFrame()
                 {
                        if ( v_fcount == 0)
                                throw "Video is Empty.";

                                if ( v_current->prev == NULL )
                                throw "Out of range.";

                        return v_current->prev->data;

                 }

                T* getNextFrame()
                 {
                        if ( v_fcount == 0)
                                throw "Video is Empty.";

                                if ( v_current->next == NULL )
                                throw "Out of range.";

                        return v_current->next->data;

                 }

                T* getFirstFrame()
                 {
                        if ( v_fcount == 0)
                                throw "Video is Empty.";

                        return v_first->data;
                 }


                T* getLastFrame()
                 {
                        if ( v_fcount == 0)
                                throw "Video is Empty.";

                        return v_last->data;
                 }

                long getCurrentFrameIndex() const
                 {
                                frameNode* iterFrame;
                                iterFrame = v_first;
                                long i = 0;
                                while ( iterFrame  )
                                 {
                                        if ( iterFrame->data == v_current->data )
                                                return i;

                                        iterFrame = iterFrame->next;
                                        i++;
                                 }

                        return -1;
                 }


                T* getFrame(long index)
                 {
                        if ( v_fcount == 0)
                                throw "Video is Empty.";

                        if ( index < 0 || index >= v_fcount )
                                throw "Out of range";

                        long distEnd = v_fcount - index;

                        if ( index < distEnd )
                         {

                                frameNode* iterFrame;
                                iterFrame = v_first;
                                long i = 0;
                                while ( iterFrame  )
                                 {
                                        if ( i == index )
                                                return iterFrame->data;

                                        iterFrame = iterFrame->next;
                                        i++;
                                 }

                         }
                        else
                         {
                                frameNode* iterFrame;
                                iterFrame = v_last;
                                long i = v_fcount-1;
                                while ( iterFrame  )
                                 {
                                        if ( i == index )
                                                return iterFrame->data;
                                        iterFrame = iterFrame->prev;
                                        i--;
                                 }

                         }

                        throw "Index not found, internal error.";
                 }

                VETRESULT goToNextFrame()
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        if ( v_current->next == NULL )
                                return VETRET_ILLEGAL_USE;

                                v_current = v_current->next;

                        return VETRET_OK;
                 }

                VETRESULT goToPreviousFrame()
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        if ( v_current->prev == NULL )
                                return VETRET_ILLEGAL_USE;

                        v_current = v_current->prev;

                        return VETRET_OK;
                 }

                VETRESULT goToFirstFrame()
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        v_current = v_first;

                        return VETRET_OK;
                 }

                VETRESULT goToLastFrame()
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        v_current = v_last;

                        return VETRET_OK;
                 }

                VETRESULT goToFrame(long index)
                 {
                        if ( v_fcount == 0)
                                return VETRET_ILLEGAL_USE;

                        if ( index < 0 || index >= v_fcount )
                                return VETRET_PARAM_ERR;

                        long distEnd = v_fcount - index;

                        if ( index < distEnd )
                         {
                                frameNode* iterFrame;
                                iterFrame = v_first;
                                long i = 0;
                                while ( iterFrame  )
                                 {
                                        if ( i == index )
                                         {
                                                v_current = iterFrame;
                                                return VETRET_OK;
                                         }
                                        iterFrame = iterFrame->next;
                                        i++;
                                 }

                         }
                        else
                         {
                                frameNode* iterFrame;
                                iterFrame = v_last;
                                long i = v_fcount-1;
                                while ( iterFrame  )
                                 {
                                        if ( i == index )
                                         {
                                                v_current = iterFrame;
                                                return VETRET_OK;
                                         }
                                        iterFrame = iterFrame->prev;
                                        i--;
                                 }

                         }

                        return VETRET_INTERNAL_ERR;
                 }

                VETRESULT goToStepFrame(long offset)
                 {
                        if ( v_fcount == 0 || offset == 0 )
                                return VETRET_ILLEGAL_USE;

                        if ( offset >= v_fcount  || offset <= -v_fcount )
                                return VETRET_PARAM_ERR;

                        frameNode* iterFrame;
                        iterFrame = v_current;

                        if ( offset > 0 )
                         {
                                long i = 0;
                                while ( iterFrame  )
                                 {
                                        if ( i == offset )
                                         {
                                                v_current = iterFrame;
                                                return VETRET_OK;
                                         }
                                        iterFrame = iterFrame->next;
                                        i++;
                                 }

                         }
                        else
                         {
                                long i = v_fcount-1;
                                while ( iterFrame  )
                                 {
                                        if ( i == offset )
                                         {
                                                v_current = iterFrame;
                                                return VETRET_OK;
                                         }
                                        iterFrame = iterFrame->prev;
                                        i--;
                                 }

                         }

                        return VETRET_INTERNAL_ERR;
                 }





 };


#endif /* __VETLIB_VETBUFFERLINK_H__ */

---