processor.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_CONCEPT_PROCESSOR_H
#define BALL_CONCEPT_PROCESSOR_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_CONCEPT_BASEFUNCTOR_H
# include <BALL/CONCEPT/baseFunctor.h>
#endif

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

namespace BALL 
{


  class BALL_EXPORT Processor
  {
    public:
    typedef int Result;

    enum
    {
      ABORT    = 0,
      BREAK    = 1,
      CONTINUE = 2
    };
  };
 

  template <typename T>
  class UnaryProcessor
    : public UnaryFunctor<T, Processor::Result>
  {
    public:

    BALL_CREATE(UnaryProcessor)
    UnaryProcessor()
    {
    }

    UnaryProcessor
      (const UnaryProcessor& /* processor */)
    {
    }

    virtual ~UnaryProcessor()
    {
    }

    virtual bool start()
    {
      return true;
    }

    virtual bool finish()
    {
      return true;
    }

    virtual Processor::Result operator () (T &)
    {
      return Processor::CONTINUE;
    }
  };

  template<typename T>
  class ConstUnaryProcessor : public UnaryFunctor<T, Processor::Result>
  {
    public:
      BALL_CREATE(ConstUnaryProcessor)

      virtual ~ConstUnaryProcessor()
      {
      }

      virtual bool start()
      {
        return true;
      }

      virtual bool finish()
      {
        return true;
      }

      virtual Processor::Result operator()(const T&)
      {
        return Processor::CONTINUE;
      }
  };

  template <typename T1, typename T2>
  class BinaryProcessor
    : public BinaryFunctor<T1, T2, Processor::Result>
  {
    public:

    BALL_CREATE(BinaryProcessor)

    
    BinaryProcessor() 
    {
    }

    BinaryProcessor 
      (const BinaryProcessor& /* processor */)
    {
    }

    virtual ~BinaryProcessor()
    {
    }

    
    virtual bool start()
    {
      return true;
    }

    virtual bool finish()
    {
      return true;
    }

    virtual Processor::Result operator () (T1&, T2&)
    {
      return Processor::CONTINUE;
    }
  };

  template <typename T1, typename T2>
  class ConstBinaryProcessor
    : public BinaryFunctor<T1, T2, Processor::Result>
  {
    public:

    BALL_CREATE(ConstBinaryProcessor)

    
    virtual ~ConstBinaryProcessor()
    {
    }


    virtual bool start()
    {
      return true;
    }

    virtual bool finish()
    {
      return true;
    }

    virtual Processor::Result operator () (const T1&, const T2&)
    {
      return Processor::CONTINUE;
    }
  };

// required for visual studio
#ifdef BALL_COMPILER_MSVC
class Atom;
template class BALL_EXPORT UnaryProcessor<Atom>;
#endif

} // namespace BALL

#endif // BALL_CONCEPT_PROCESSOR_H