blocksel.h

#ifndef __BLOCKSEL_H__
#define __BLOCKSEL_H__

#include <set>
#include <vector>
#include "blockmodel.h"
#include <iostream>

using namespace std;
//using std::set;
//using std::vector;

namespace delphos{ 


class BlockSelection : public BlockModelEntity {
private:
    set<BlockIndexType> * _blocks;
    vector<BlockIndexType> * _block_indexes;
    bool _is_ordered;
    
    void init();
    void Fast_AddBlock(const delphos::BlockIndexType & index);
    
public:
    BlockSelection(delphos::BlockModel & bm);
    #ifndef DOXYGEN
    BlockSelection(const delphos::BlockModel & bm);
    #endif

    BlockSelection(delphos::BlockModel & bm, const string & column);

    BlockSelection(delphos::BlockSelection&  bs);
    #ifndef DOXYGEN
    BlockSelection(const delphos::BlockSelection&  bs);
    #endif
    
    delphos::BlockSelection& operator=(const delphos::BlockSelection&  bs);
    delphos::BlockSelection* Intersect(const delphos::BlockSelection& bs);
    
    #ifndef DOXYGEN

    BlockSelection* IntersectOrdered(const delphos::BlockSelection& bs);
    #endif
    
    delphos::BlockSelection* Complement() ;
    
    #ifndef DOXYGEN

    BlockSelection* ComplementOrdered();
    #endif
    
    bool Union(const delphos::BlockSelection& bs) ;
    
    #ifndef DOXYGEN

    bool UnionOrdered(const BlockSelection& bs) ;
    #endif
    
    virtual ~BlockSelection();
    
    void ClearSelection();

    bool Contains(const delphos::BlockIndexType & index) const;

    bool Contains(const delphos::Coordinates & coords) const;

    bool Contains(const double & x, const double & y, const double & z) const;
        
    //bool ContainsIndex(const unsigned long & index) const;

    bool AddBlock(const delphos::BlockIndexType & index);

    bool AddBlock(const delphos::Coordinates & coords);

    bool AddBlock(const double & x, const double & y, const double & z);

    delphos::BlockIndexType GetIndex(const delphos::BlockIndexType & index) const;
    
    delphos::BlockIndexType GetIndexInBS(const delphos::BlockIndexType & index) const;
    
    delphos::Block GetBlock(const delphos::BlockIndexType & index);

    delphos::BlockIndexType Size() const;
    
    delphos::BlockIndexType GetSize() const;
    
    void StoreAsAttribute(const string & new_attr);
    
    #ifndef DOXYGEN

    delphos::BlockModel* ToBlockModel();
    
    delphos::BlockModel* ToBlockModel(const string& column);
    #endif
    
     bool RemoveBlock(const delphos::BlockIndexType& index ); 
};


class SelectionFunctor {
public:
    virtual double Eval(const delphos::BlockSelection & bsel) const = 0;
    virtual ~SelectionFunctor(){}
};


class SelectionSum : public SelectionFunctor {
private:
    const string _column;
public:
    SelectionSum(const string & column_to_add);
    virtual const string& ColumnToAdd() const;
    virtual double Eval(const delphos::BlockSelection & bsel) const;
};

class SelectionAvg : public SelectionSum {
private:
    const string* _weight;
public:
    static string NO_WEIGHT_COLUMN;
    SelectionAvg(const string & column_to_add);
    SelectionAvg(const string & column_to_add, const string& weight);
    virtual ~SelectionAvg();
    const string& WeightColumn() const;
    virtual double Eval(const delphos::BlockSelection & bsel) const;
};


class SelectionMin : public SelectionFunctor {
private:
    const string _column;
public:
    SelectionMin(const string & column_to_minimize);
    const string ColumnToMinimize() const;
    
    virtual double Eval(const delphos::BlockSelection & bsel) const;
};


class SelectionMax : public SelectionFunctor {
private:
    const string _column;
public:
    SelectionMax(const string & column_to_maximize);
    const string ColumnToMaximize() const;
    virtual double Eval(const delphos::BlockSelection & bsel) const;
};

class SelectionMajor : public SelectionFunctor {
private:
    const string _column;
public:
    SelectionMajor(const string & column_to_majorize);
    const string ColumnToMajorize() const;
    virtual double Eval(const delphos::BlockSelection & bsel) const;
};

}
#endif