src.main/CjNetworkProcess.hh

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * mitie
 * Copyright (C) Jason Spencer 2009 <mitie@jasonspencer.org>
 * 
 * mitie 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.
 * 
 * mitie 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _CJNETWORKPROCESS_H_
#define _CJNETWORKPROCESS_H_ 1

#include <string>
#include <stdexcept>
#include "CjNLTopology.hh"
#include "CjMatrix.hh"
#include "CjNetworkProcessException.hh"
#include <boost/random.hpp>
#include "CjVisitorFactory.hh"

namespace jmitie {

class CjNodeSelector;
class CjLinkSelector;
class CjNetworkDimensioner;


struct CjNetworkProcess_ctor_va_t {
        typedef CjVisitorFactory< CjVisitorFactoryEntry< CjNetworkDimensioner > > CjDimFactory_t;
        typedef CjVisitorFactory< CjVisitorFactoryEntry< CjNodeSelector > > CjNodeSelectorFactory_t;
        typedef CjVisitorFactory< CjVisitorFactoryEntry< CjLinkSelector > > CjLinkSelectorFactory_t; 

        CjDimFactory_t & m_dim_fac;
        CjNodeSelectorFactory_t & m_nodsel_fac;
        CjLinkSelectorFactory_t & m_lnksel_fac;

        boost::mt19937 * m_rng;
        CjNLTopology * m_top;

        CjNetworkProcess_ctor_va_t(CjDimFactory_t & dim_fac, CjNodeSelectorFactory_t & nodsel_fac, CjLinkSelectorFactory_t & lnksel_fac, \
                        boost::mt19937 * rng, CjNLTopology * top ): \
                        m_dim_fac(dim_fac), \
                        m_nodsel_fac(nodsel_fac), \
                        m_lnksel_fac(lnksel_fac), \
                        m_rng(rng), \
                        m_top(top) {}
};


struct CjNetworkProcess_act_va_t {
        boost::mt19937 * m_rng;
        int m_epoch;

        CjNetworkProcess_act_va_t(boost::mt19937 * rng, int epoch ):m_rng(rng),m_epoch(epoch) {}
};


class CjNetworkProcess {
// TODO: Make the timing format and functions a inheritable temaplte policy? Hmm.. probably not - would prevent CjNetworkProcess's with different policies being held in homogenous container
// TODO: better idea: put timing in a class and make it to impl to this pimpl.

public:
typedef CjNetworkProcess_ctor_va_t ctor_va_t;   // the variable argument type for the constructor of a type derived from CjNetworkProcess
typedef CjNetworkProcess_act_va_t action_va_t;

CjNetworkProcess(std::string args, ctor_va_t va):m_orig_args(args),m_cmd(args),m_start(0),m_lifetime(0),m_step(1),m_priority(0),m_atEnd( parseEpochs(m_cmd, m_name, m_start, m_lifetime, m_step, m_priority ) ),m_top(va.m_top) {
        JLOG(4, std::cout << "CjNetworkProcess(std::string args): Timing parsed as: args = \"" << args << "\" start = " << m_start << " lifetime = " << m_lifetime << " step = " << m_step << " prio = " << m_priority << " atEnd = " << m_atEnd << std::endl; )
        }

// Timing related methods
virtual bool activeEpoch (const unsigned int t) const { return ( (t>=m_start) && ( (m_lifetime==0) || (t<(m_start+m_lifetime)) ) && ((t-m_start)%m_step==0) ); }
virtual bool expiredPolicy (const unsigned int t) const { return ((m_lifetime==0)?false:( t>(m_start+m_lifetime))); }
// timing accessors
virtual unsigned int getStartEpoch() const { return m_start; }
virtual unsigned int getLifetime() const { return m_lifetime; }
virtual unsigned int getEpochStep() const { return m_step; }
virtual unsigned int getProcessPriority() const { return m_priority; }
virtual bool atEnd() const { return m_atEnd; }

// Naming and properties
static std::string getName_static() { throw std::logic_error("CjNetworkProcess::getName_static() called."); }
static std::string getProperty_static(const std::string &) { throw std::logic_error("CjNetworkProcess::getProperty_static(..) called."); }      // name is not a "property" as it is inherent to the class
// virtual std::string getName() const { return getName_static(); }
virtual std::string getName() const = 0;
virtual std::string getProperty (const std::string &) const = 0;

virtual std::string toString() const { return m_orig_args; }
virtual std::string getCmd() const { return m_cmd; }

virtual void performAction( const action_va_t & opts  ) = 0;
virtual ~CjNetworkProcess() = 0;

static std::string getProcName( const std::string & instr );

static bool parseEpochs( std::string & instr, std::string & proc_name, unsigned int & start, unsigned int & lifetime, unsigned int & step, unsigned int & prio );

protected:
std::string m_orig_args;
std::string m_cmd;
std::string m_name;

unsigned int m_start;
unsigned int m_lifetime;
unsigned int m_step;
unsigned int m_priority;
bool m_atEnd;

CjNLTopology * m_top;

private:

};

} // namespace jmitie

#endif // _CJNETWORKPROCESS_H_