Range.h

Go to the documentation of this file.

//
// $Id: Range.h,v 1.15 2005/07/21 20:26:36 bv Exp $
//
// Range
//
// Package: MIDAD
//
// Range: models a (templated) range (min/max) of values.  Triggers
// "modified" signal when changed.
//
// RangePtr: ref counted handle used to share ranges.
//
// Contact: bv@bnl.gov
//
// Created on: Mon Nov  5 13:39:16 2001
//

#ifndef MIDAD_RANGE_H
#define MIDAD_RANGE_H

// include TMath.h so that it (and it's overloaded function Range)
// is seen before the one below, lest the compiler get confused.
#include "TMath.h"

#include <Midad/Util/Signals.h>

#include <string>

template <class TYPE>
class Range : public SigC::Object
{
public:

    struct RangeState {
        TYPE min, max;
        RangeState(TYPE mi, TYPE ma) : min(mi), max(ma) {};
        RangeState() : min(-0.0001), max(0.0001) {};
        virtual ~RangeState() {};
    };
    
    SigC::Signal0<void> modified;

    Range(TYPE min=0, TYPE max=0, const char* name = 0)
        : fState(min,max), fName(name) {}
    virtual ~Range() { /*cerr << "~Range()\n";*/}

    void Set(TYPE min, TYPE max) 
        { fState.min = min; fState.max = max; this->modified(); }
    void SetMin(TYPE min) { fState.min = min; this->modified(); }
    void SetMax(TYPE max) { fState.max = max; this->modified(); }
    void Get(TYPE& min, TYPE& max) const { min=fState.min, max=fState.max; }
    TYPE Min(void) const { return fState.min; }
    TYPE Max(void) const { return fState.max; }
    bool InRange(TYPE val) { return val >= fState.min && val <= fState.max; }
    TYPE Relative(TYPE val) { 
        val = this->RelativeUnclipped(val);
        if (val < 0) return 0.0;
        if (val > 1) return 1.0;
        return val;
    }
    TYPE RelativeUnclipped(TYPE val) { 
        return (val - fState.min) / (fState.max - fState.min); 
    }
    const char* GetName(void) const
        { return fName; }
    void SetName(const char* name) 
        { fName = name; }
    void Merge(const Range& r) {
        bool dirty = false;
        if (r.Min() < fState.min) { fState.min = r.Min(); dirty=true; }
        if (r.Max() > fState.max) { fState.max = r.Max(); dirty=true; }
        if (dirty) this->modified();
    }
    void SetFrom(const Range& r) { this->Set(r.Min(),r.Max()); }
    void SetState(RangeState rs) { fState = rs; this->modified(); }
    RangeState GetState(void) { return fState; }

private:

    // copy constructor, assignment:
    Range(const Range& rhs) { SetFrom(rhs); } // copy constructor
    Range& operator=(const Range& rhs) { SetFrom(rhs); return *this; } // assignment

    RangeState fState;
    const char* fName;
};                              // end of class Range

typedef Range<double> RangeDouble;

template <typename TYPE>
struct Range2D {
    SigC::Ptr<Range<TYPE> > x, y;

    Range2D()
        : x(SigC::manage(new Range<TYPE>)), 
          y(SigC::manage(new Range<TYPE>)) 
    {};

    Range2D(TYPE x1, TYPE y1, TYPE x2, TYPE y2)
        : x(SigC::manage(new Range<TYPE>(x1,x2))), 
          y(SigC::manage(new Range<TYPE>(y1,y2))) 
    {};

    Range2D(const Range2D& rhs) 
        { this->x = rhs.x; this->y = rhs.y; };
    Range2D& operator=(Range2D& rhs) {
        if (this == &rhs) return rhs;
        this->x = rhs.x; this->y = rhs.y; return *this;
    };

};

typedef Range2D<double> RangeDouble2D;
typedef Range2D<int> RangeInt2D;

#endif  // MIDAD_RANGE_H

---