Association.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------




/* @{ */

#ifndef __STD_ROBOT_H_
#define __STD_ROBOT_H_

#ifdef MIP_HOST_APPLE
#include </usr/include/time.h>
#include <ctime>
#endif

#include <stdio.h>
#include <math.h>
#include <vector>
#include <iostream>
#include <string>
#include <sstream>
#include <sys/time.h>
#include <sys/select.h>
#include <assert.h>
#include <pthread.h>

#include "Types.h"

#ifdef FOUND_BOOST_SER
 #include <boost/serialization/vector.hpp>
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
#endif

using namespace std;


class Meaner{
 private:
  Decimal  _mean;
  long int _n;
 public:
  Meaner (void){
   _mean = 0.0;
   _n  = 0;
  }
  Meaner (Decimal value){
   _mean = value;
   _n  = 1;
  }
   void reset(void){
   _mean = 0.0;
   _n  = 0;
  }
  void reset(Decimal value){
   _mean = value;
   _n  = 1;
  }
  Decimal mean(){
   return _mean;
  }
  Decimal mean(Decimal value){
   if(_n!=0){
    _mean = (((Decimal) _n)/((Decimal) _n+1))*_mean + ( value / ((Decimal) _n+1) );
   }else{
    _mean = value;
   }
    _n++;
   return _mean;
  }
};

/*TODO fondere tutto in SequenceStats che ha media meadiapesata min max std var (e a questo punto anche la sequenza con i vector)*/
// class MinMaxer{
//  private:
//   Decimal  _max;
//   Decimal  _min;
//   bool   _on;
//  public:
//   /** default constructor 
//    */
//   MinMaxer (void){
//    _min = 0.0;
//    _max = 0.0;
//    _on  = false;
//   }
//   /** Decimal constructor 
//    * \param value first value
//    */
//   MinMaxer (Decimal value){
//    _min = value;
//    _max = value;
//    _on  = true;
//   }
//   /** reset the values at null
//    */
//   void reset(void){
//    _min = 0.0;
//    _max = 0.0;
//    _on  = false;
//   }
//   /** reset the mean at another value
//    * \param value first value
//    */
//   void reset(Decimal value){
//    _mean = value;
//    _n  = 1;
//   }
//   /** current mean
//    * \return currrent mean
//    */
//   Decimal min(){
//    return _min;
//   }
//   /** update the mean and return the updated mean
//    * \return updated mean
//    * \param value another value
//    */
//   Decimal min(Decimal value){
//    if(_n!=0){
//     _mean = (((Decimal) _n)/((Decimal) _n+1))*_mean + ( value / ((Decimal) _n+1) );
//    }else{
//     _mean = value;
//    }
//    _n++;
//    return _mean;
//   }
// };



template <class T, class assocType>
class Association{
 private:
#ifdef FOUND_BOOST_SER
  friend class boost::serialization::access;
  template<class Archive>
    void serialize(Archive & ar, const unsigned int version){
   ar & _obj; 
   ar & _assoObj;
   ar & _isAsso;
  }
#endif

  T    _obj;   
  assocType  _assoObj; 
  bool  _isAsso; 
 public:
  Association(){
   _isAsso = false;

  }
  Association(const T& o){
   _obj = o;
   _isAsso = false;
  }
  Association(const T& o, const assocType& ao){
   _obj = o;
   _assoObj = ao;
   _isAsso  = true;
  }

  Association(const Association& a){
   _obj = a._obj;
   _assoObj = a._assoObj;
   _isAsso  = a._isAsso;
  };
  
  
  Association& operator=(const Association& a){
   if (this != &a){      // Not necessary in this case but it is useful to don't forget it
    _obj   = a._obj;
    _assoObj = a._assoObj;
    _isAsso  = a._isAsso;
   }
   return *this;
  }

  void associate(const assocType& ao){
   _assoObj = ao;
   _isAsso  = true;
  }
  void unassociate() {
   _isAsso  = false;
  }
  bool associated(void) const {
   return _isAsso;
  }

  T getObj(void) const {
   return _obj;
  }

        // open the object in edit mode
  // TODO: (mriedel:) I would rather return a reference here.
        T* setObj(void) {
         return &_obj;
        }
                
        // open the object in edit mode
        void setObj(const T& pp){
         _obj = pp;
        }
                
  assocType getAsso(void) const {
   return _assoObj;
  }
};



#endif

/* @} */