ModuleElement.h

#ifndef MODULEELEMENT_H
#define MODULEELEMENT_H
#include "Sct/Exception.h"
#include "Sct/SctParameters.h"
#include "Sct/OutOfRangeError.h"

using namespace Sct;

namespace SctData {
    class ModuleElement{
    public:

    static ModuleElement Module() throw();  
    
    static ModuleElement Link(unsigned int link);
    
    static ModuleElement Chip(unsigned int chip);
    
    static ModuleElement Channel(unsigned int channel); 
    
    
    ModuleElement(const unsigned first, const unsigned last);
    ~ModuleElement() throw() {;}
    unsigned getFirst() const throw() {return first;}
    unsigned getLast() const throw() {return last;}
    unsigned getNChannels() const throw();
    bool isChannel() const throw();
    bool isChip() const throw();
    bool isLink() const throw();
    bool isModule() const throw();
    bool operator == (const ModuleElement&) const throw();
    bool isWithin(const ModuleElement&) const throw();
    bool contains(const ModuleElement&) const throw();
    bool overlaps(const ModuleElement&) const throw();
    bool adjacentTo(const ModuleElement&) const throw();
    private:
    unsigned first, last;
    ModuleElement() throw(); 
    };

//==========================================================================
// inlines
//==========================================================================
    inline ModuleElement::ModuleElement(const unsigned lo, const unsigned hi) {
#ifndef NDEBUG
    if (hi>nChannelModule ) {
        throw OutOfRangeError<unsigned>("ModuleElement last", __FILE__, __LINE__, hi, 0, nChannelModule);
    }
    if (lo>hi ){
        throw OutOfRangeError<unsigned>("ModuleElement first ", __FILE__, __LINE__, lo, 0, hi);
    }
#endif
    last=hi;
    first=lo;

    }
    inline unsigned int ModuleElement::getNChannels() const throw() {
    return getLast() - getFirst() + 1;
    }
    inline bool ModuleElement::isChannel() const throw(){
    return (getNChannels() == 1);
    }
    inline bool ModuleElement::isChip() const throw(){
    return (getFirst() % nChannelChip == 0 && getNChannels() == nChannelChip);
    }
    inline bool ModuleElement::isLink() const throw(){
    return (getFirst() % nChannelLink == 0 && getNChannels() == nChannelLink);
    }
     inline bool ModuleElement::isModule() const throw(){
    return (getFirst() % nChannelModule == 0 && getNChannels() == nChannelModule);
    }

    inline bool ModuleElement::operator == (const ModuleElement& el) const throw(){
    return (getFirst()==el.getFirst() && getLast()==el.getLast() );
    }

    inline bool ModuleElement::isWithin(const ModuleElement& el) const throw(){
    return (getFirst()>=el.getFirst() && getLast()<=el.getLast() );
    }
    inline bool ModuleElement::contains(const ModuleElement& el) const throw(){
    return (getFirst()<=el.getFirst() && getLast()>=el.getLast() );
    }
    
    inline bool ModuleElement::overlaps(const ModuleElement& el) const throw(){
    return ( (getFirst()<=el.getFirst() && getLast()>=el.getFirst() )  // my first element contained
         || ( getFirst()>el.getFirst() && getFirst()<=el.getLast() ) ); // my last element contained
    }
    
    inline bool ModuleElement::adjacentTo(const ModuleElement& el) const throw(){
      if ( overlaps(el) ) return false;
      return ( getFirst()==el.getLast()+1 || getLast()==el.getFirst()-1 );
    }

    inline ModuleElement ModuleElement::Chip(const unsigned ichip) { 
    return ModuleElement(ichip*nChannelChip, (ichip+1)*nChannelChip-1);
    }
    
    inline ModuleElement ModuleElement::Link(const unsigned ilink) { 
    return ModuleElement(ilink*nChannelLink, (ilink+1)*nChannelLink-1);
    }
    
    inline ModuleElement ModuleElement::Channel(const unsigned ichannel) { 
    return ModuleElement(ichannel, ichannel);
    }
    
    inline ModuleElement ModuleElement::Module() throw() { 
    return ModuleElement(0, nChannelModule-1);
    }

} // end of namespace SctData
#endif //#ifndef MODULEELEMENT_H

---