/home/marsyas/marsyas/src/marsyas/MarSystem.h

/*
** Copyright (C) 1998-2006 George Tzanetakis <gtzan@cs.uvic.ca>
**
** This program 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 2 of the License, or
** (at your option) any later version.
**
** This program 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, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#ifndef MARSYAS_MARSYSTEM_H
#define MARSYAS_MARSYSTEM_H

#include "common_header.h"
#include "MarControl.h"
#include "MarControlAccessor.h"
#include "realvec.h"
#include "Conversions.h"

#include "EvEvent.h"
#include "TmTime.h"
#include "Scheduler.h"
#include "TmControlValue.h"
#include "marostring.h"

#include <vector>
#include <iostream>
#include <map>
#include <string>
#include <cassert>
#include <utility>

namespace Marsyas
{
class marsyas_EXPORT MarSystem
{

//friend classes
    friend class MarSystemManager;
    friend class MarControl;

private:
    void addControls();//add MarSystem default controls
    virtual void activate(bool state);

protected:

    MarSystem* parent_;

    std::string type_;

    std::string name_;

    std::string prefix_;

    std::string absPath_;

    mrs_natural c,o,t;

    bool isComposite_;
    mrs_natural marsystemsSize_;

    std::vector<MarSystem*> marsystems_;

    std::vector<realvec*> slices_;

    std::vector<MarControlPtr> slPtrs_;

    mutable std::map<std::string, MarControlPtr> controls_;
    std::map<std::string, MarControlPtr>::iterator ctrlIter_;

    //in flow member vars
    mrs_natural inObservations_;
    mrs_natural inSamples_;
    mrs_real israte_;
    mrs_string inObsNames_;
    mrs_natural inStabilizingDelay_;

    //out flow member vars
    mrs_natural onObservations_;
    mrs_natural onSamples_;
    mrs_real osrate_;
    mrs_string onObsNames_;
    mrs_natural onStabilizingDelay_;

    //temporary in flow vars
    mrs_natural tinObservations_;
    mrs_natural tinSamples_;
    mrs_real        tisrate_;
    mrs_string  tinObsNames_;
    mrs_natural tinStabilizingDelay_;

    //temporary out flow vars
    mrs_natural tonObservations_;
    mrs_natural tonSamples_;
    mrs_real        tosrate_;
    mrs_string  tonObsNames_;
    mrs_natural tonStabilizingDelay_;

    mrs_natural irows_;
    mrs_natural icols_;
    mrs_natural orows_;
    mrs_natural ocols_;

    realvec inTick_;
    realvec outTick_;

    Scheduler scheduler_;

    mrs_natural count_;

    bool active_;

    mrs_natural addToStabilizingDelay_; 

    bool isUpdating_;

    std::string MATLABscript_;

    std::string getControlRelativePath(std::string cname) const;
    std::string getControlLocalPath(std::string cname) const;

    virtual void myUpdate(MarControlPtr sender);

    virtual void localActivate(bool state);

    virtual void myProcess(realvec& in, realvec& out) = 0;

    MarSystem& operator=(const MarSystem&)
    {
        assert(0);
        return *this;
    }

    virtual std::ostream& put_html_worker(std::ostream& o);

public:
    MarSystem(std::string type, std::string name);
    MarSystem(const MarSystem& a);  // copy constructor
    virtual ~MarSystem();

    virtual MarSystem* clone() const = 0;
    void relinkControls(const MarSystem& a);

    virtual void setName(std::string name);
    virtual void setType(std::string type);
    std::string getType() const;
    std::string getName() const;
    std::string getPrefix() const;
    std::string getAbsPath() const;
    void updatePath();

    bool linkControl(std::string cname1, std::string cname2, bool update = true);
    DEPRECATED(bool linkctrl(std::string cname1, std::string cname2, bool update = true))
    {
        return linkControl(cname1, cname2, update);
    }

    bool updControl(MarControlPtr control, MarControlPtr newcontrol, bool upd = true);
    bool updControl(const char* cname, MarControlPtr newcontrol, bool upd = true);
    bool updControl(std::string cname, MarControlPtr newcontrol, bool upd = true);
    void updControl(EvEvent* me);
    void updControl(TmTime t, EvEvent* ev);
    void updControl(TmTime t, Repeat r, EvEvent* ev);
    void updControl(TmTime t, std::string cname, MarControlPtr control);
    void updControl(TmTime t, Repeat r, std::string cname, MarControlPtr control);

    DEPRECATED(bool updctrl(MarControlPtr control, MarControlPtr newcontrol, bool upd = true))
    {
        return updControl(control, newcontrol, upd);
    }

    DEPRECATED(bool updctrl(const char *cname, MarControlPtr newcontrol, bool upd = true))
    {
        MarControlPtr control = getControl(cname);
        if (control.isInvalid())
        {
            MRSWARN("MarSystem::updctrl - " + std::string(cname) + " is an invalid control @ " + getAbsPath());
            return false;
        }
        return updControl(control, newcontrol, upd);
    }

    DEPRECATED(bool updctrl(std::string cname, MarControlPtr newcontrol, bool upd = true))
    {
        MarControlPtr control = getControl(cname);
        if (control.isInvalid())
        {
            MRSWARN("MarSystem::updctrl - " + cname + " is an invalid control @ " + getAbsPath());
            return false;
        }
        return updControl(control, newcontrol, upd);
    }

    bool setControl(std::string cname, MarControlPtr newcontrol)
    {
        return updControl(cname, newcontrol, NOUPDATE);
    }
    bool setctrl(const char *cname, MarControlPtr newcontrol)
    {
        return updControl(std::string(cname), newcontrol, NOUPDATE);
    }
    bool setctrl(std::string cname, MarControlPtr newcontrol)
    {
        return updControl(cname, newcontrol, NOUPDATE);
    }
    bool setctrl(MarControlPtr control, MarControlPtr newcontrol)
    {
        return updControl(control, newcontrol, NOUPDATE);
    }

    // query controls
    bool hasControl(MarControlPtr control, bool searchChildren = true);
    bool hasControlLocal(MarControlPtr control)
    {
        return hasControl(control, false);
    }
    bool hasControl(std::string cname, bool searchChildren = true);
    bool hasControlLocal(std::string cname)
    {
        return hasControl(cname, false);
    }
    
    bool isComposite()
    {
        return isComposite_;
    }

    // get controls
    MarControlPtr getControl(std::string cname, bool searchParent = false, bool searchChildren = true);
    MarControlPtr getControlLocal(std::string cname)
    {
        return getControl(cname, false, false);
    }
    MarControlPtr getctrl(std::string cname)
    {
        return getControl(cname);
    }

    //add controls
    bool addControl(std::string cname, MarControlPtr v);
    bool addControl(std::string cname, MarControlPtr v, MarControlPtr& ptr);
    bool addctrl(std::string cname, MarControlPtr v)
    {
        return addControl(cname, v);
    }
    bool addctrl(std::string cname, MarControlPtr v, MarControlPtr& ptr)
    {
        return addControl(cname, v, ptr);
    }

    std::map<std::string, MarControlPtr> getControls(std::map<std::string, MarControlPtr>* cmap = NULL);
    const std::map<std::string, MarControlPtr>& getLocalControls();

    // set control state
    void setControlState(std::string cname, bool state);
    void setctrlState(std::string cname, bool state)
    {
        setControlState(cname, state);
    }
    void setctrlState(const char * cname, bool state)
    {
        setControlState(std::string(cname), state);
    }
    void setctrlState(MarControlPtr control, bool state)
    {
        control->setState(state);
    }

    // get control state
    bool hasControlState(std::string cname);
    bool hasctrlState(std::string cname)
    {
        return hasControlState(cname);
    }
    bool hasctrlState(char* cname)
    {
        return hasControlState(std::string(cname));
    }
    bool hasctrlState(MarControlPtr control)
    {
        return control->hasState();
    }

    // Composite interface
    virtual bool addMarSystem(MarSystem *marsystem);
    virtual MarSystem* getChildMarSystem(std::string childPath);
    virtual void setParent(const MarSystem* parent);
    MarSystem* getParent() const
    {
        return parent_;
    }
    virtual std::vector<MarSystem*> getChildren();

    // Processing and update methods
    bool isUpdating();
    void checkFlow(realvec&in, realvec& out);
    void update(MarControlPtr sender = MarControlPtr());
    void process(realvec& in, realvec& out);
    void tick();

    std::string toString();
    std::string toStringShort();
    std::string toStringGraphViz();
    void toStringGraphViz(std::ostringstream& os_defs, std::ostringstream& os_links);

    virtual marostring& toString(marostring& m);
    
    // derived class such as Composite can override put
    // essentially overriding operator<<
    virtual std::ostream& put(std::ostream& o, bool verbose);

    virtual std::istream& put(std::istream& is);

    virtual std::ostream& put_html(std::ostream& o);

    marsyas_EXPORT friend std::ostream& operator<<(std::ostream&, MarSystem&);

    marsyas_EXPORT friend std::istream& operator>>(std::istream&, MarSystem&); //[!]
    marsyas_EXPORT friend std::ostream& operator<<(std::ostream&, const std::map<std::string,MarControlPtr>&);

    void setMATLABscript(std::string script);
    std::string getMATLABscript();

    // EvEvent methods
    mrs_natural getTime(std::string timer_name);
    void updtimer(std::string tmr_ctrl_path, TmControlValue value);
    void updtimer(std::string tmr_path, TmParam param);
    void updtimer(std::string tmr_path, std::vector<TmParam> params);
    void addTimer(std::string tmr_class, std::string tmr_ident);
    void addTimer(std::string tmr_class, std::string tmr_ident, std::vector<TmParam> params);
    //void addTimer(TmTimer* t);
    void removeTimer(std::string name);

    void updctrl(EvEvent* me);
    //void updctrl(std::string time, EvEvent* ev); //clashes with void upctrl(std::string cname, 0);
    //void updctrl(std::string time, Repeat rep, EvEvent* ev);
    //void updctrl(Repeat rep, EvEvent* ev);
    //void updctrl(std::string time, std::string cname, MarControlPtr control);
    //void updctrl(std::string time, Repeat rep, std::string cname, MarControlPtr control);
    //void updctrl(Repeat rep, std::string cname, MarControlPtr control);
    void updctrl(TmTime t, EvEvent* ev);
    void updctrl(TmTime t, Repeat rep, EvEvent* ev);
    void updctrl(TmTime t, std::string cname, MarControlPtr control);
    void updctrl(TmTime t, Repeat rep, std::string cname, MarControlPtr control);

    //control pointers [!] should these be public?
    MarControlPtr ctrl_inSamples_;
    MarControlPtr ctrl_inObservations_;
    MarControlPtr ctrl_israte_;
    MarControlPtr ctrl_inObsNames_;
    MarControlPtr ctrl_inStabilizingDelay_;
    MarControlPtr ctrl_onSamples_;
    MarControlPtr ctrl_onObservations_;
    MarControlPtr ctrl_osrate_;
    MarControlPtr ctrl_onObsNames_;
    MarControlPtr ctrl_onStabilizingDelay_;
    MarControlPtr ctrl_debug_;
    MarControlPtr ctrl_verbose_;
    MarControlPtr ctrl_mute_;
    MarControlPtr ctrl_active_;
    MarControlPtr ctrl_processedData_;
};

mrs_string obsNamesAddPrefix(mrs_string observationNames, mrs_string prefix);

std::vector<mrs_string> stringSplit(mrs_string input, mrs_string delimiter);

std::vector<mrs_string> obsNamesSplit(mrs_string observationNames);

}//namespace Marsyas

#endif

---