Jint.cxx

Go to the documentation of this file.

#include "Jint.h"

#include <JobControl/JobC.h>
#include <JobControl/JobCResult.h>
#include <JobControl/JobCPath.h>
#include <JobControl/JobCPathModule.h>
#include <JobControl/JobCPathRegistry.h>
#include <MinosObjectMap/MomNavigator.h>

#include <sigc++/sigc++.h>
using namespace SigC;


static void chirp(const char* what)
{
    cerr << what << endl;
}

Jint::Jint(JobC& jc)
    : fJC(jc)
      ,fJobState(false)
      ,fFirstPath(0)
{
    fJobState.SetName("Job State");
    Registry paths(false);      // holds all existing paths
    paths.SetName("Paths");
    fJobState.Set("paths",paths);

    const JobCPathRegistry* jcpr = fJC.Path.GetPathRegistry();
    if (!jcpr) {
        cerr << "Jint: no JobCPathRegistry, I may miss some paths\n";
    }
    else {
        JobCPathRegistry::PathIterator pit, end = jcpr->GetPathEnd();
        for (pit = jcpr->GetPathBegin(); pit != end; ++pit) 
            this->AddPath(*pit);
    }

    fJC.Path.SigNewPath.connect(slot(*this,&Jint::AddPath));

    // Connect to I/O sigs
    fJC.Input.SigGet.connect(bind(slot(chirp),"Get"));
    fJC.Input.SigNext.connect(bind(slot(chirp),"Next"));
    fJC.Input.SigPrev.connect(bind(slot(chirp),"Prev"));
    fJC.Input.SigGoTo.connect(bind(slot(chirp),"GoTo"));
}

Jint::~Jint(void)
{
}

void Jint::AddPath(JobCPath* jcp)
{
    Registry paths;
    bool ok = fJobState.Get("paths",paths);
    if (!ok) {
        cerr << "Jint::AddPath - no paths in JobState!\n";
        return;
    }
    cerr << "Jint::AddPath: \"" << jcp->GetName() << "\" added\n";

    if (!fFirstPath) fFirstPath = jcp->GetName();
        
    Registry path(false);       // holds info about this path.
    paths.Set(jcp->GetName(),path);
    fJobState.Set("paths",paths);

    // Connect to this JCP's signals
    jcp->SigDelete.connect(slot(*this,&Jint::RemovePath));
    jcp->SigUpdate.connect(slot(*this,&Jint::UpdatePath));
    jcp->SigStartRun.connect(slot(*this,&Jint::StartPathRun));
    jcp->SigEndRun.connect(slot(*this,&Jint::EndPathRun));

    job_modified.emit();
}

void Jint::RemovePath(JobCPath* jcp)
{
    cerr << "Path: " << jcp->GetName() << " removed\n";
}

void Jint::UpdatePath(JobCPath* jcp, JobCPath::Update_t utype)
{
    cerr << "Path: " << jcp->GetName() << " updated by: " << utype << endl;
}

void Jint::StartPathRun(JobCPath* /*jcp*/)
{
//    cerr << "Path: " << jcp->GetName() << " started a run\n";
//    cerr << "  State of job:\n  " << fJobState << endl;
}

void Jint::EndPathRun(JobCPath* jcp)
{
//    cerr << "Path: " << jcp->GetName() << " ended a run\n";
    if (jcp->LastResult().EndOfInputStream()) {
        cerr << "Path: " << jcp->GetName() << " end of input stream\n";
        return;
    }
    mom_modified();
}

const MomNavigator* Jint::GetMom() const
{
    return &fJC.Mom;
}



void Jint::Next(int n, const char* path_name)
{
    if (path_name) {
        cerr << "Jint: Next on path \"" << path_name << "\"\n";
        fJC.Input.Next(n);
        fJC.Path(path_name).Run(0);
        return;
    }

    if (!fFirstPath) {
        cerr << "Jint:: no paths created yet\n";
        return;
    }
    fJC.Input.Next(n);
    fJC.Path(fFirstPath).Run(0);
}
void Jint::NextPass(int n, const char* path_name)
{
    if (!path_name && !fFirstPath) {
        cerr << "Jint::NextPass no path name given and not default\n";
        return;
    }

    if (!path_name) path_name = fFirstPath;

    fJC.Path(path_name).RunNpass(n);
}
void Jint::Prev(int n, const char* path_name)
{
    if (path_name) {
        fJC.Input.Prev(n);
        fJC.Path(path_name).Run(0);
        return;
    }

    if (!fFirstPath) {
        cerr << "Jint:: no paths created yet\n";
        return;
    }
    fJC.Input.Prev(n);
    fJC.Path(fFirstPath).Run(0);
}
void Jint::Rerun(const char* path_name)
{
    if (path_name) {
        fJC.Path(path_name).Run(0);
        return;
    }

    if (!fFirstPath) {
        cerr << "Jint:: no paths created yet\n";
        return;
    }

    fJC.Path(fFirstPath).Run(0);
}
void Jint::GoTo(int run, int snarl)
{
    fJC.Input.GoTo(run,snarl);
    fJC.Path(fFirstPath).Run(0);
}
void Jint::Run(int n, JobCPath::RunMode_t mode, const char* path_name)
{
    if (path_name) {
        fJC.Path(path_name).Run(n,mode);
        return;
    }

    if (!fFirstPath) {
        cerr << "Jint:: no paths created yet\n";
        return;
    }

    fJC.Path(fFirstPath).Run(n,mode);
}

---