|| ||           || Doxygen's  

---

VxSegmentList.h

/*
 *  VxSegmentList
 *
 *  Copyright (c) 2000, TNO TPD, The Netherlands.
 *  All rights reserved. No part of this software may be handed to or used by persons 
 *  or organisation outside Kenniscentrum Watergraafsmeer (UvA-ISIS, TNO TPD) without 
 *  the written permission of TNO TPD.
 *
 *  Author(s):
 *      Jan Baan (baan@tpd.tno.nl)
 *
 */

/* JV, 04Sep01: added sort function.
 * JV, 04Sep01: added highest and lowest frame function
 * JV, 04Sep01: added intersect function
 * JV, 04Sep01: added push_back for lists (merge)
 * JV, 04Sep01: converted std namespace functions to Horus approach
 * JV, 18Jun02: added updateSeg function
 */

#ifndef VxSegmentList_h
#define VxSegmentList_h

#pragma warning( disable : 4786 )  

#include <vector>
#include "HxFeatureMap.h"
#include "VxSegment.h"
#include "HxIo.h"

//using namespace std;

class VxSegmentList
{
public:
    
    typedef std::vector<VxSegment>::const_iterator  const_iterator;
    typedef std::vector<VxSegment>::iterator            iterator;

                                VxSegmentList();

                                VxSegmentList(const HxString& filename);

                                VxSegmentList(const VxSegmentList&);

                                ~VxSegmentList();

    VxSegmentList&              operator=(const VxSegmentList& rhs);

    VxSegmentList*              clone() const;

    void                        push_back(const VxSegment& seg);

    void                        push_back(const VxSegmentList& sl);

    VxSegment                   get(int i) const;

    int                         size() const;

    const_iterator              begin_const() const;

    const_iterator              end_const() const;

    iterator                    begin();

    iterator                    end();

    STD_OSTREAM&                put(
                                    STD_OSTREAM& os = STD_COUT, 
                                    const std::vector<HxString>& fm = std::vector<HxString>()
                                    ) const;

    std::vector<HxString>       getIds() const;

    std::map<HxString,HxString> getTypes() const;

    void                        pushComment(const HxString &s) 
                                    {_data->_comment.push_back(s);}

    std::vector<HxString>       getComments() const 
                                    {return _data->_comment;}

    VxSegmentList               sort();
    
    int                         highestFrame();

    int                         lowestFrame();

    bool                        equal(VxSegmentList& sl);

    VxSegmentList               intersect(VxSegmentList& sl);

/*  VxSegmentList               unite(VxSegmentList& sl); // TO DO */

    bool                        updateSeg(int pos, VxSegment& seg);

private:
    void                        read(STD_ISTREAM& is);

    struct VxSegmentListRep{
        std::vector<VxSegment>  _segVec;

        std::vector<HxString>   _comment;

        int                     refCount;
        VxSegmentListRep()      { refCount = 1;}
    };

    VxSegmentListRep*           _data; /* Pointer to actual data. */

};


inline STD_OSTREAM& operator<<(STD_OSTREAM&  os,const VxSegmentList& sl)
{
    return sl.put(os);
}


inline 
VxSegmentList::VxSegmentList() {
    _data = new VxSegmentListRep();
}

inline 
VxSegmentList::VxSegmentList(const VxSegmentList& his)
    : _data(his._data)
{
    _data->refCount++;  
}

inline 
VxSegmentList::~VxSegmentList() {
    _data->refCount--;
    if (_data->refCount == 0)   
        delete _data;
}

inline VxSegmentList& 
VxSegmentList::operator=(const VxSegmentList& rhs)
{
    if (--_data->refCount<= 0 && _data != rhs._data)
        delete _data;
    (_data=rhs._data)->refCount++;     
    return *this;   
}

inline VxSegmentList*
VxSegmentList::clone() const {
    return new VxSegmentList(*this);
}


inline int
VxSegmentList::size() const {
    return _data->_segVec.size();
}


inline void 
VxSegmentList::push_back(const VxSegment& seg) {
    _data->_segVec.push_back(seg);
}

inline void 
VxSegmentList::push_back(const VxSegmentList& sl) {
    for (VxSegmentList::const_iterator it=sl.begin_const(); it!=sl.end_const(); it++)
        push_back(*it);
}

inline VxSegment
VxSegmentList::get(int i) const {
    return _data->_segVec[i];
}


inline VxSegmentList::const_iterator 
VxSegmentList::begin_const() const {
    return _data->_segVec.begin();
}

inline VxSegmentList::const_iterator 
VxSegmentList::end_const() const {
    return _data->_segVec.end();
}


inline VxSegmentList::iterator 
VxSegmentList::begin() {
    return _data->_segVec.begin();
}

inline VxSegmentList::iterator 
VxSegmentList::end() {
    return _data->_segVec.end();
}


#endif

---