src/bundles.h

#ifndef express_bundles_h
#define express_bundles_h

#include <boost/thread.hpp>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <vector>

class Target;
typedef size_t TargID;
typedef boost::unordered_map<size_t, float> CovarMap;

class CovarTable {
  CovarMap _covar_map;

public:
  CovarTable() {};
  void increment(TargID targ1, TargID targ2, double covar);
   double get(TargID targ1, TargID targ2);
  size_t size() const { return _covar_map.size(); }
};

class BundleTable;

class Bundle {
  std::vector<Target*> _targets;
  size_t _counts;
  double _mass;
  Bundle* _merged_into;
  mutable boost::mutex _mut;
  
  friend class BundleTable;

public:
  Bundle(Target* targ);
  const Bundle* get_rep() const;
  void incr_counts(size_t incr_amt=1);
  void incr_mass(double incr_amt);
  void reset_mass();
  size_t size() const;
  const std::vector<Target*>* targets() const { return &_targets; }
  size_t counts() const;
  double mass() const;
};

typedef boost::unordered_set<Bundle*> BundleSet;

class BundleTable {
  BundleSet _bundles;
  bool _threadsafe_mode;
  mutable boost::mutex _mut;
  Bundle* get_rep(Bundle* b);
public:
  BundleTable();
  ~BundleTable();
  const BundleSet& bundles() const { return _bundles; }
  size_t size() const { return _bundles.size(); }
  Bundle* create_bundle(Target* targ);
  Bundle* merge(Bundle* b1, Bundle* b2);
  void collapse();
  bool threadsafe_mode() const { return _threadsafe_mode; }
  void threadsafe_mode(bool mode) { _threadsafe_mode = mode; }
};

#endif