u_abs_hod.hpp

/* u_abs_hod.hpp */
/* $Id: u_abs_hod.hpp 21267 2011-11-23 15:19:39Z guser1 $ */
#ifndef __u_abs_hod_hpp
#define __u_abs_hod_hpp

#include <map>
#include <vector>

#ifdef GE_BUILD
#include <u3d_point.hpp>
#else
#include <mth/u3d_point.hpp>
#endif

//#include "service.hpp"


typedef std::pair<int, int> FBDTraceKey;


struct UHodEl 
{
  UHodEl();
  UHodEl(size_t ndp,
     size_t nsp,
     size_t nrp,
     float l,
     float tfb,
     float wht,
     int ntr,
     int nmgl,
     U3dPoint _sp,
     U3dPoint _rp);
  
  size_t NDP;    
  size_t NSP;    
  size_t NRP;    
  float L;       
  float TFB;     
  float weight;  
  size_t NTR;
  size_t NMGL;
  
  U3dPoint sp;
  U3dPoint rp;
  
  static bool ndp_eq(const UHodEl& h1, const UHodEl& h2) { return h1.NDP == h2.NDP; }
  
  static bool nsp_eq(const UHodEl& h1, const UHodEl& h2) { return h1.NSP == h2.NSP; }
  
  static bool nrp_eq(const UHodEl& h1, const UHodEl& h2) { return h1.NRP == h2.NRP; }
  
  static bool ofst_eq(const UHodEl& h1, const UHodEl& h2) { return h1.L == h2.L; }
  
  static bool ndp_asc(const UHodEl& h1, const UHodEl& h2) { return h1.NDP < h2.NDP; }
  
  static bool nsp_asc(const UHodEl& h1, const UHodEl& h2) { return h1.NSP < h2.NSP; }
  
  static bool nrp_asc(const UHodEl& h1, const UHodEl& h2) { return h1.NRP < h2.NRP; }
  
  static bool ofst_asc(const UHodEl& h1, const UHodEl& h2) { return h1.L < h2.L; }
  
  static bool pts_rev_eq(const UHodEl& h1, const UHodEl& h2) { return (h1.sp == h2.rp && h1.rp == h2.sp); }
}; 

typedef std::vector<UHodEl> UHod;

typedef std::map<FBDTraceKey, UHodEl> FBDHodMap;


class UAbstractHod
{
public:
  
  enum SortType
    {
      CDP=0,
      CSP,
      CRP,
      OFST
    };
  
  UAbstractHod() { m_st_defined = false; }
  
  UAbstractHod(UHod hod) : m_hod(hod) { m_st_defined = false; }
  
  ~UAbstractHod() {}
  
  /* ================== Members access ================== */
  
  size_t getNMGLs(std::vector<float> &nmgls);
  
  size_t getNDPS(std::vector<int> &dps_id);
  
  size_t getSPS(std::vector<int> &sps_id); 
  
  size_t getRPS(std::vector<int> &rps_id); 
  
  size_t getOffsets(std::vector<float> &offsets); 
  
  bool getHod(UHod &hod, float id=-1) const;
  
  const UHod& getHod() const { return m_hod; }
  
  void getHod(FBDHodMap &hod_map) const;
  
  bool getSortType(SortType& sort_type) const;
  
  /* ================== Modifiers ================== */
  
  bool setSortType(SortType sort_type);
  
  void resetSortType() { m_st_defined = false; }
  
  void setHod(UHod hod);
  
  bool setHod(FBDHodMap hod_map);
  
protected:

  bool checkId(const UHodEl& h1, float id) const;

  bool m_st_defined;
  
  SortType m_st;
  
  UHod m_hod;
  
};




#endif /* u_abs_hod.hpp */