extutil.h

//-*-C++-*-
 
/***************************************************************************
 *
 *   Copyright (C) 2008 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/genutil/extutil.h
 
#ifndef __Pulsar_get_extension_h
#define __Pulsar_get_extension_h
 
#include "Functor.h"
#include <algorithm>

template<class T, class Container>
T* get_ext (Container* container, const char* method, bool verbose)
{
  T* extension = 0;
 
  const unsigned next = container->get_nextension();
  for (unsigned iext=0; iext<next; iext++)
  {
    auto ext = container->get_extension (iext);
 
    if (verbose)
      std::cerr << method << " name="
                << ext->get_extension_name() << std::endl;
      
    extension = dynamic_cast<T*>( ext );
      
    if (extension)
      return extension;
  }
 
  if (verbose)
    std::cerr << method << " failed to find extension type="
              << typeid(extension).name() << std::endl;
 
  return extension;
}
 
template<class T> 
void clean_dangling (std::vector<T>& data)
{
  auto iterator = std::remove(data.begin(), data.end(), false);
  data.erase(iterator, data.end());
}

template<typename E, typename C, typename B>
void foreach (C* container, void (B::*method)())
{
  const unsigned next = container->get_nextension ();
 
  for (unsigned iext=0; iext < next; iext++)
  {
    E* ext = dynamic_cast<E*> (container->get_extension (iext));
    if (ext)
      (ext->*method) ();
  }
}

template<typename E, typename C, typename M, typename A>
void foreach (C* container, M method, A argument)
{
  const unsigned next = container->get_nextension ();
 
  for (unsigned iext=0; iext < next; iext++)
  {
    E* ext = dynamic_cast<E*> (container->get_extension (iext));
    if (ext)
      (ext->*method) (argument);
  }
}

template<typename E, typename C>
void foreach (C* container, Functor< void(E*) >& functor)
{
  const unsigned next = container->get_nextension ();
 
  for (unsigned iext=0; iext < next; iext++)
  {
    E* ext = dynamic_cast<E*> (container->get_extension (iext));
    if (ext)
      functor (ext);
  }
}

template<typename E, typename C>
void foreach (const C* container, Functor< void(const E*) >& functor)
{
  const unsigned next = container->get_nextension ();
 
  for (unsigned iext=0; iext < next; iext++)
  {
    const E* ext = dynamic_cast<const E*> (container->get_extension (iext));
    if (ext)
      functor (ext);
  }
}
 
 
#endif