// Procedural.h -- Procedural binder and adapter template classes

// (c) Copyright Schlumberger Technology Corp., unpublished work, created
// 1999. This computer program includes Confidential, Proprietary
// Information and is a Trade Secret of Schlumberger Technology Corp. All
// use, disclosure, and/or reproduction is prohibited unless authorized
// in writing.  All Rights Reserved.

#if !defined(SLBCSP_PROCEDURAL_H)
#define SLBCSP_PROCEDURAL_H

#include <functional>

// Template classes that support composition of procedure objects
// (proctors).  Proctors are like functors (function objects) but
// don't return a value (void).  The template classes defined here
// follow C++ member function binders and adapters.

///////////////////////////    BINDERS    /////////////////////////////////

template<class Arg>
struct UnaryProcedure
    : public std::unary_function<Arg, void>
{};

template<class Arg1, class Arg2>
struct BinaryProcedure
    : public std::binary_function<Arg1, Arg2, void>
{};

template<class BinaryProc>
class ProcedureBinder2nd
    : public UnaryProcedure<BinaryProc::first_argument_type>
{
public:
    ProcedureBinder2nd(BinaryProc const &rproc,
                       BinaryProc::second_argument_type const &rarg)
        : m_proc(rproc),
          m_arg2(rarg)
    {}

    void
    operator()(argument_type const &arg1) const
    {
        m_proc(arg1, m_arg2);
    }

protected:
    BinaryProc m_proc;
    BinaryProc::second_argument_type m_arg2;
};

template<class BinaryProc, class T>
ProcedureBinder2nd<BinaryProc>
ProcedureBind2nd(BinaryProc const &rProc, T const &rv)
{
    return ProcedureBinder2nd<BinaryProc>(rProc, BinaryProc::second_argument_type(rv));
};

////////////////////  MEMBER PROCEDURE ADAPTERS //////////////////////////

template<class T>
class MemberProcedureType
    : public UnaryProcedure<T *>
{
public:
                                                  // Types
                                                  // C'tors/D'tors
    explicit
    MemberProcedureType(void (T::* p)())
        : m_pmp(p)
    {}

                                                  // Operators
    void
    operator()(T *p) const
    {
        (p->*m_pmp)();
    }


                                                  // Operations
                                                  // Access
                                                  // Predicates

protected:
                                                  // Types
                                                  // C'tors/D'tors
                                                  // Operators
                                                  // Operations
                                                  // Access
                                                  // Predicates
                                                  // Variables

private:
                                                  // Types
                                                  // C'tors/D'tors
                                                  // Operators
                                                  // Operations
                                                  // Access
                                                  // Predicates
                                                  // Variables
    void (T::* m_pmp)();

};

template<class T>
MemberProcedureType<T>
MemberProcedure(void (T::* p)())
{
    return MemberProcedureType<T>(p);
};

////////////////////  POINTER TO PROCEDURE ADAPTERS ///////////////////////

template<class T1, class T2>
class PointerToBinaryProcedure
    : public BinaryProcedure<T1, T2>
{
public:
                                                  // Types
                                                  // C'tors/D'tors
    explicit
    PointerToBinaryProcedure(void (*p)(T1, T2))
        : m_p(p)
    {}

                                                  // Operators
    void
    operator()(T1 arg1,
               T2 arg2) const
    {
        m_p(arg1, arg2);
    }


                                                  // Operations
                                                  // Access
                                                  // Predicates

protected:
                                                  // Types
                                                  // C'tors/D'tors
                                                  // Operators
                                                  // Operations
                                                  // Access
                                                  // Predicates
                                                  // Variables
    void (*m_p)(T1, T2);

private:
                                                  // Types
                                                  // C'tors/D'tors
                                                  // Operators
                                                  // Operations
                                                  // Access
                                                  // Predicates
                                                  // Variables
};

template<class T1, class T2>
PointerToBinaryProcedure<T1, T2>
PointerProcedure(void (*p)(T1, T2))
{
    return PointerToBinaryProcedure<T1, T2>(p);
};


template<class T>
class PointerToUnaryProcedure
    : public UnaryProcedure<T>
{
public:
                                                  // Types
                                                  // C'tors/D'tors
    explicit
    PointerToUnaryProcedure(void (*p)(T))
        : m_p(p)
    {}

                                                  // Operators
    void
    operator()(T arg) const
    {
        m_p(arg);
    }


                                                  // Operations
                                                  // Access
                                                  // Predicates

protected:
                                                  // Types
                                                  // C'tors/D'tors
                                                  // Operators
                                                  // Operations
                                                  // Access
                                                  // Predicates
                                                  // Variables
    void (*m_p)(T);

private:
                                                  // Types
                                                  // C'tors/D'tors
                                                  // Operators
                                                  // Operations
                                                  // Access
                                                  // Predicates
                                                  // Variables
};

template<class T>
PointerToUnaryProcedure<T>
PointerProcedure(void (*p)(T))
{
    return PointerToUnaryProcedure<T>(p);
}

#endif // SLBCSP_PROCEDURAL_H