---

ModuleElement.h

Go to the documentation of this file.

#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:
    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();
    private:
    unsigned first, last;
    ModuleElement() throw(); 
    };

    //--------------------------------------------------------------------
    class Chip : public ModuleElement{
    public:
    Chip(const unsigned ichip) throw (LogicError);
    ~Chip() throw(){;}
    };
    
    //--------------------------------------------------------------------
    class Link : public ModuleElement{
    public:
    Link(const unsigned ilink) throw (LogicError);
    ~Link() throw(){;}
    };

    //--------------------------------------------------------------------
    class Channel : public ModuleElement{
    public:
    Channel(const unsigned ichannel) throw (LogicError);
    ~Channel() throw(){;}
    };
     //--------------------------------------------------------------------
    class Module : public ModuleElement{
    public:
    Module() throw (LogicError);
    ~Module() 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.getLast() && getFirst()>=el.getFirst() )  // my first element contained
         || ( getLast()<=el.getLast() && getLast()>=el.getFirst() ) ); // my last element contained
    }
    inline Chip::Chip(const unsigned ichip) throw (LogicError) : 
    ModuleElement(ichip*nChannelChip, (ichip+1)*nChannelChip-1) {
    }
    
    inline Link::Link(const unsigned ilink) throw (LogicError) : 
    ModuleElement(ilink*nChannelLink, (ilink+1)*nChannelLink-1) {
    }
    inline Channel::Channel(const unsigned ichannel) throw (LogicError) : 
    ModuleElement(ichannel, ichannel){
    }
    
    inline Module::Module() throw (LogicError) : 
    ModuleElement(0, nChannelModule-1) {
    }

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

---