ThirdParty-6/ParaView-5.0.1/ParaViewCore/Common/vtkClientServerInterpreterInitializer.cxx

/*=========================================================================

  Program:   ParaView
  Module:    vtkClientServerInterpreterInitializer.cxx

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#include "vtkClientServerInterpreterInitializer.h"

#include "vtkClientServerInterpreter.h"
#include "vtkObjectFactory.h"
#include "vtkSmartPointer.h"
#include "vtkWeakPointer.h"

#include <vector>

class vtkClientServerInterpreterInitializer::vtkInternals
{
public:
  typedef std::vector<vtkWeakPointer<vtkClientServerInterpreter> >
    VectorOfInterpreters;
  VectorOfInterpreters Interpreters;
  typedef std::vector<
    vtkClientServerInterpreterInitializer::InterpreterInitializationCallback>
    VectorOfCallbacks;
  VectorOfCallbacks Callbacks;
};

//----------------------------------------------------------------------------
// Can't use vtkStandardNewMacro since it adds the instantiator function which
// does not compile since vtkClientServerInterpreterInitializer::New() is
// protected.
vtkClientServerInterpreterInitializer* vtkClientServerInterpreterInitializer::New()
{
  vtkObject* ret =
    vtkObjectFactory::CreateInstance("vtkClientServerInterpreterInitializer");
  if (ret)
    {
    return static_cast<vtkClientServerInterpreterInitializer*>(ret);
    }
  return new vtkClientServerInterpreterInitializer;
}

//----------------------------------------------------------------------------
vtkClientServerInterpreterInitializer::vtkClientServerInterpreterInitializer()
{
  this->Internals = new vtkInternals();
}

//----------------------------------------------------------------------------
vtkClientServerInterpreterInitializer::~vtkClientServerInterpreterInitializer()
{
  delete this->Internals;
}

//----------------------------------------------------------------------------
vtkClientServerInterpreterInitializer*
vtkClientServerInterpreterInitializer::GetInitializer()
{
  static vtkSmartPointer<vtkClientServerInterpreterInitializer> Singleton;
  if (!Singleton)
    {
    Singleton.TakeReference(vtkClientServerInterpreterInitializer::New());
    }
  return Singleton;
}

//----------------------------------------------------------------------------
vtkClientServerInterpreter*
vtkClientServerInterpreterInitializer::GetGlobalInterpreter()
{
  static vtkSmartPointer<vtkClientServerInterpreter> Singleton;
  if (!Singleton)
    {
    vtkClientServerInterpreterInitializer* initializer =
      vtkClientServerInterpreterInitializer::GetInitializer();
    Singleton.TakeReference(initializer->NewInterpreter());
    }
  return Singleton;

}

//----------------------------------------------------------------------------
vtkClientServerInterpreter*
vtkClientServerInterpreterInitializer::NewInterpreter()
{
  vtkClientServerInterpreter* interp = vtkClientServerInterpreter::New();
  // THIS DOES NOT AFFECT REF-COUNT.
  this->RegisterInterpreter(interp);
  return interp;
}

//----------------------------------------------------------------------------
void vtkClientServerInterpreterInitializer::RegisterInterpreter(
  vtkClientServerInterpreter* interp)
{
  // THIS DOES NOT AFFECT REF-COUNT.
  this->Internals->Interpreters.push_back(interp);

  // Initialize using existing callbacks.
  vtkInternals::VectorOfCallbacks::iterator iter;
  for (iter = this->Internals->Callbacks.begin();
    iter != this->Internals->Callbacks.end(); ++iter)
    {
    (*(*iter))(interp);
    }
}

//----------------------------------------------------------------------------
void vtkClientServerInterpreterInitializer::RegisterCallback(
  vtkClientServerInterpreterInitializer::InterpreterInitializationCallback
  callback)
{
  this->Internals->Callbacks.push_back(callback);

  vtkInternals::VectorOfInterpreters::iterator iter;
  for (iter = this->Internals->Interpreters.begin();
    iter != this->Internals->Interpreters.end(); ++iter)
    {
    if (iter->GetPointer() != NULL)
      {
      (*callback)(iter->GetPointer());
      }
    }
}

//----------------------------------------------------------------------------
void vtkClientServerInterpreterInitializer::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);
}