Subversion Repositories w11

// $Id: RtclContext.cpp 492 2013-02-24 22:14:47Z mueller $
//
// Copyright 2011-2013 by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>
//
// This program is free software; you may redistribute and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 2, 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 complete details.
// 
// Revision History: 
// Date         Rev Version  Comment
// 2013-02-03   481   1.0.3  use Rexception
// 2013-01-12   474   1.0.2  add FindProxy() method
// 2011-03-12   368   1.0.1  drop fExitSeen, get exit handling right
// 2011-02-18   362   1.0    Initial version
// 2011-02-13   361   0.1    First draft
// ---------------------------------------------------------------------------
 
/*!
  \file
  \version $Id: RtclContext.cpp 492 2013-02-24 22:14:47Z mueller $
  \brief   Implemenation of RtclContext.
*/
 
#include <iostream>
 
#include "RtclContext.hpp"
 
#include "librtools/Rexception.hpp"
 
using namespace std;
 
/*!
  \class Retro::RtclContext
  \brief FIXME_docs
*/
 
// all method definitions in namespace Retro
namespace Retro {
 
typedef std::pair<RtclContext::cset_it_t, bool>  cset_ins_t;
typedef std::pair<RtclContext::pset_it_t, bool>  pset_ins_t;
 
RtclContext::xmap_t RtclContext::fMapContext;
 
//------------------------------------------+-----------------------------------
//! Default constructor
 
RtclContext::RtclContext(Tcl_Interp* interp)
  : fInterp(interp),
    fSetClass(),
    fSetProxy()
{}
 
//------------------------------------------+-----------------------------------
//! Destructor
 
RtclContext::~RtclContext()
{}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RtclContext::RegisterClass(RtclClassBase* pobj)
{
  cset_ins_t ret = fSetClass.insert(pobj);
  if (ret.second == false)                  // or use !(ret.second)
    throw Rexception("RtclContext::RegisterClass()",
                     "Bad args: duplicate pointer");
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RtclContext::UnRegisterClass(RtclClassBase* pobj)
{
  fSetClass.erase(pobj);
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RtclContext::RegisterProxy(RtclProxyBase* pobj)
{
  pset_ins_t ret = fSetProxy.insert(pobj);
  if (ret.second == false)                  // or use !(ret.second)
    throw Rexception("RtclContext::RegisterProxy()",
                     "Bad args: duplicate pointer");
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RtclContext::UnRegisterProxy(RtclProxyBase* pobj)
{
  fSetProxy.erase(pobj);
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
bool RtclContext::CheckProxy(RtclProxyBase* pobj)
{
  pset_it_t it = fSetProxy.find(pobj);
  return it != fSetProxy.end();
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
bool RtclContext::CheckProxy(RtclProxyBase* pobj, const string& type)
{
  pset_it_t it = fSetProxy.find(pobj);
  if (it == fSetProxy.end()) return false;
  return (*it)->Type() == type;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
void RtclContext::ListProxy(std::vector<RtclProxyBase*>& list,
                            const std::string& type)
{
  list.clear();
  for (pset_it_t it = fSetProxy.begin(); it != fSetProxy.end(); it++) {
    if (type.length() == 0 || (*it)->Type()==type) {
      list.push_back(*it);
    }
  }
  return;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
RtclProxyBase* RtclContext::FindProxy(const std::string& type, 
                                      const std::string& name)
{
  for (pset_it_t it = fSetProxy.begin(); it != fSetProxy.end(); it++) {
    if (type.length() == 0 || (*it)->Type()==type) {
      const char* cmdname = Tcl_GetCommandName(fInterp, (*it)->Token());
      if (name == cmdname) return *it;
    }
  }
  return 0;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
RtclContext& RtclContext::Find(Tcl_Interp* interp)
{
  RtclContext* pcntx = 0;
  xmap_it_t it = fMapContext.find(interp);
  if (it != fMapContext.end()) {
    pcntx = it->second;
  } else {
    pcntx = new RtclContext(interp);
    fMapContext.insert(xmap_val_t(interp, pcntx));
    Tcl_CreateExitHandler((Tcl_ExitProc*) ThunkTclExitProc, (ClientData) pcntx);
 
  }
  return *pcntx;
}
 
//------------------------------------------+-----------------------------------
//! FIXME_docs
 
// Note: tcl exit handlers are executed in inverse order of creation.
//       If Find() is called before any Class or Proxy cleanup handlers
//       are created the exit handler created in Find() will be called
//       last, when all map entries have been erased.
 
void RtclContext::ThunkTclExitProc(ClientData cdata)
{
  RtclContext* pcntx = (RtclContext*) cdata;
  if (pcntx->fSetClass.empty() && pcntx->fSetProxy.empty()) {
    delete pcntx;
  } else {
    cerr << "RtclContext::ThunkTclExitProc called when maps non-empty" << endl;
  }
  return;
}
 
} // end namespace Retro