|| ||           || Doxygen's  

---

VxSegment.h

/*
 *  VxSegment
 *
 *  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/DK, 20Dec00: changed getIds(vector) into getTypes. */
/* JB/JV, 8 May01: push(HxFeatureBase) added */
/* JV, 04Sep01: added comparison function lesser for segments.
 * JV, 04Sep01: added intersect function
 * JV, 04Sep01: converted std namespace functions to Horus approach
 */


#ifndef VxSegment_h
#define VxSegment_h

#include "HxFeatureMap.h"
#include "HxIo.h"
//using namespace std;

class VxSegment
{
public:

                            VxSegment();

                            VxSegment(const int start, const int end);

                            VxSegment(const std::vector<HxString>& ids, const std::vector<HxString>& types, const HxString& str);

                            VxSegment(const VxSegment&);

    virtual                 ~VxSegment();

    VxSegment&              operator=(const VxSegment& rhs);

    VxSegment*              clone();

    int                     start() const;

    int                     end()   const;

    int                     length()  const;


    template<class T>
    HxFeatureResult         push(const HxString &id, const T& val)
                            {
                                return _data->_fMap.push(id,val);
                            }

    HxFeatureResult         push(const HxString &id, HxFeatureBase* feat)
                            {
                                return _data->_fMap.push(id,feat);
                            }

    template<class T>
    HxFeatureResult         get(const HxString& id, T& val) const
                            {
                                return _data->_fMap.get(id,val);
                            }

    template<class T>
    bool                    compare(const HxString& id, const T& val) const
                            {
                                return _data->_fMap.compare(id,val);
                            }


    const HxFeatureBase*    get(const HxString& id) const;

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

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

    VxSegment               intersect(const VxSegment& seg) const;
private:
    void                    scanString(const std::vector<HxString>& ids, const std::vector<HxString>& types, const HxString& str);

    struct VxSegmentRep {
        int                 _start, _end;
        HxFeatureMap        _fMap;
        int                 refCount;
        VxSegmentRep()      { refCount = 1;}
    };

    VxSegmentRep*           _data;
};

    bool                    lesser(const VxSegment s1, const VxSegment s2);
                            

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

inline
VxSegment::VxSegment() 
// : _start(-1), _end(-1)
{
    _data = new VxSegmentRep();
    _data->_start=-1;
    _data->_end=-1;
}

inline
VxSegment::VxSegment(const int start, const int end)
//: _start(start), _end(end) 
{
    _data = new VxSegmentRep();
    _data->_start=start;
    _data->_end=end;
}

inline
VxSegment::VxSegment(const std::vector<HxString>& ids, const std::vector<HxString>& types, const HxString& str) {
    _data = new VxSegmentRep(); 
    scanString(ids, types, str);
}

inline
VxSegment::VxSegment(const VxSegment& his)
    : _data(his._data)
// : _start(his._start), _end(his._end), _fMap(his._fMap) 
{
    _data->refCount++;  
}

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

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

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

inline int
VxSegment::start() const { 
    return _data->_start; 
}

inline int
VxSegment::end() const { 
    return _data->_end; 
}

inline int 
VxSegment::length() const {
    return (_data->_end-_data->_start+1);
}

inline const HxFeatureBase*
VxSegment::get(const HxString& id) const
{
    return _data->_fMap.get(id);
}
    
inline std::vector<HxString>
VxSegment::getIds() const
{
    return _data->_fMap.getIds();
}
    
inline std::vector<HxString>
VxSegment::getTypes() const
{
    return _data->_fMap.getTypes();
}

#endif

---