Generator.h

Go to the documentation of this file.

//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt 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.
//=========================================================================
 
#ifndef smtk_common_Generator_h
#define smtk_common_Generator_h
 
#include "smtk/common/CompilerInformation.h"
 
#include <algorithm>
#include <cassert>
#include <memory>
#include <set>
 
#define DEBUG_GENERATOR 0
 
#if !defined(NDEBUG) && DEBUG_GENERATOR
#include <iostream>
#endif
 
namespace smtk
{
namespace common
{
 
 
namespace detail
{
struct NullGeneratorBase
{
};
} // namespace detail
 
template<class Input, class Output, class Base = detail::NullGeneratorBase>
class GeneratorBase : public Base
{
public:
  template<typename... T>
  GeneratorBase(T&&... all)
    : Base(std::forward<T>(all)...)
  {
  }
 
  virtual ~GeneratorBase() = default;
 
  virtual bool valid(const Input&) const = 0;
 
  virtual Output operator()(const Input&) = 0;
};
 
template<class Input, class Output, class Base = detail::NullGeneratorBase>
class Generator : public GeneratorBase<Input, Output, Base>
{
  template<class U, class V, class W, class X>
  friend class GeneratorType;
 
public:
  template<typename... T>
  Generator(T&&... all)
    : GeneratorBase<Input, Output, Base>(std::forward<T>(all)...)
  {
  }
 
  bool valid(const Input&) const override;
 
  Output operator()(const Input&) override;
 
protected:
  static std::weak_ptr<std::set<GeneratorBase<Input, Output, Base>*>> generators();
};
 
template<class Input, class Output, class Base>
std::weak_ptr<std::set<GeneratorBase<Input, Output, Base>*>>
Generator<Input, Output, Base>::generators()
{
  static std::shared_ptr<std::set<GeneratorBase<Input, Output, Base>*>> generators =
    std::make_shared<std::set<GeneratorBase<Input, Output, Base>*>>(
      std::set<GeneratorBase<Input, Output, Base>*>());
  return generators;
}
 
template<class Input, class Output, class Base>
bool Generator<Input, Output, Base>::valid(const Input& input) const
{
  auto gens = Generator<Input, Output, Base>::generators().lock();
  if (gens == nullptr)
  {
    return false;
  }
  return std::any_of(
    gens->begin(), gens->end(), [&input](const GeneratorBase<Input, Output, Base>* gen) {
      return gen->valid(input);
    });
}
 
template<class Input, class Output, class Base>
Output Generator<Input, Output, Base>::operator()(const Input& input)
{
  Output output;
  auto gens = Generator<Input, Output, Base>::generators().lock();
  if (gens == nullptr)
  {
    return output;
  }
  for (auto gen : *gens)
  {
    if (!gen->valid(input))
    {
      continue;
    }
 
    try
    {
      output = (*gen)(input);
      break;
    }
    catch (std::exception& e)
    {
#if !defined(NDEBUG) && DEBUG_GENERATOR
      std::cerr << "Exception caught: " << e.what() << std::endl;
#else
      (void)e;
#endif
    }
  }
  return output;
}
 
template<class Input, class Output, class Self, class Base = detail::NullGeneratorBase>
class GeneratorType : public GeneratorBase<Input, Output, Base>
{
  class Registry
  {
    friend GeneratorType;
 
    Registry(std::weak_ptr<std::set<GeneratorBase<Input, Output, Base>*>> generators)
      : m_generators(generators)
      , m_self(new Self())
    {
      if (auto gens = m_generators.lock())
      {
        gens->insert(m_self);
      }
    }
    ~Registry()
    {
      if (auto gens = m_generators.lock())
      {
        gens->erase(m_self);
      }
      delete m_self;
    }
    std::weak_ptr<std::set<GeneratorBase<Input, Output, Base>*>> m_generators;
    Self* m_self;
  };
 
  friend Self;
 
public:
  static bool registerClass();
 
protected:
  template<typename... T>
  GeneratorType(T&&... all)
    : GeneratorBase<Input, Output, Base>(std::forward<T>(all)...)
  {
  }
 
private:
  static bool s_registered;
};
 
template<class Input, class Output, class Self, class Base>
bool GeneratorType<Input, Output, Self, Base>::registerClass()
{
  static bool registered = false;
  if (!registered)
  {
    static Registry registry(Generator<Input, Output, Base>::generators());
    registered = true;
  }
  return registered;
}
 
template<class Input, class Output, class Self, class Base>
bool GeneratorType<Input, Output, Self, Base>::s_registered =
  GeneratorType<Input, Output, Self, Base>::registerClass();
} // namespace common
} // namespace smtk
 
#endif