JModuleLocation.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JMODULELOCATION__
#define __JDETECTOR__JMODULELOCATION__
 
#include <istream>
#include <ostream>
#include <iomanip>
#include <string>
 
#include "JLang/JComparable.hh"
#include "JLang/JString.hh"
#include "JIO/JSerialisable.hh"
 
 
/**
 * \file
 *
 * Logical location of module.
 * \author mdejong
 */
namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }
 
namespace JDETECTOR {
 
  using JLANG::JComparable;
  using JIO::JReader;
  using JIO::JWriter;
 
 
  /**
   * Logical location of module.
   *
   * The logical location of a module consists of a string and floor number.
   * This class implements the JLANG::JComparable interface.
   */
  class JModuleLocation :
    public JComparable<JModuleLocation>
  {
  public:
    /**
     * Default constructor.
     */
    JModuleLocation() :
      string(-1),
      floor (-1)
    {}
 
      
    /**
     * Constructor.
     *
     * \param  string     string
     * \param  floor      floor
     */
    JModuleLocation(const int string,
                    const int floor) 
    {
      this->string = string;
      this->floor  = floor;
    }
 
 
    /**
     * Get location.
     *
     * \return            location
     */
    const JModuleLocation& getLocation() const
    {
      return static_cast<const JModuleLocation&>(*this);
    }
 
 
    /**
     * Get location.
     *
     * \return            location
     */
    JModuleLocation& getLocation()
    {
      return static_cast<JModuleLocation&>(*this);
    }
 
 
    /**
     * Set location.
     *
     * \param  location   location
     */
    void setLocation(const JModuleLocation& location)
    {
      static_cast<JModuleLocation&>(*this) = location;
    }
 
 
    /**
     * Convert module location to string.
     *
     * \return            string
     */
    std::string toString() const
    {
      return toString("% %");
    }
 
 
    /**
     * Convert module loation to string.
     *
     * The targets <tt>target</tt> in the format string <tt>fmt</tt> are
     * consecutively replaced by <tt>floor</tt> and <tt>string</tt>.
     *
     * \param  fmt        format
     * \param  target     target
     * \return            string
     */
    std::string toString(const std::string& fmt, const std::string target = "%") const
    {
      JLANG::JString buffer(fmt);
 
      buffer.replace(target, string, 1);
      buffer.replace(target, floor,  1);
 
      return buffer;
    }
 
 
    /**
     * Get string number.
     *
     * \return            string number
     */
    int getString() const 
    {
      return string;
    }
 
 
    /**
     * Get floor number.
     *
     * \return            floor number
     */
    int getFloor() const 
    {
      return floor;
    }
 
 
    /**
     * Less than method.
     *
     * \param  location    module location
     * \result             true if first location before second location; else false
     */
    bool less(const JModuleLocation& location) const
    {
      if (this->getString() == location.getString())
        return this->getFloor()  < location.getFloor();
      else
        return this->getString() < location.getString();
    }
 
 
    /**
     * Read module location from input.
     *
     * \param  in         input stream
     * \param  location   module location
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JModuleLocation& location)
    {
      in >> location.string;
      in >> location.floor;
 
      return in;
    }
 
 
    /**
     * Write module location to output.
     *
     * \param  out        output stream
     * \param  location   module location
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JModuleLocation& location)
    {
      using namespace std;
      
      out << setw(3) << location.string;
      out << ' ';
      out << setw(2) << location.floor;
 
      return out;
    }
 
 
    /**
     * Read module location from input.
     *
     * \param  in         reader
     * \param  location   module location
     * \return            reader
     */
    friend inline JReader& operator>>(JReader& in, JModuleLocation& location)
    {
      in >> location.string;
      in >> location.floor;
 
      return in;
    }
 
 
    /**
     * Write module location to output.
     *
     * \param  out        writer
     * \param  location   module location
     * \return            writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JModuleLocation& location)
    {
      out << location.string;
      out << location.floor;
 
      return out;
    }
 
 
  protected:
    int string;
    int floor;
  };
}
 
#endif