/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <functional>

#include "itkimpl.h"

/**

 * Implementation of internal templates stuff for itk.h

 */

namespace Itk

{

    /**

     * Adapts the C++-style interface of a member function to the

     * TesterBase interface.

     */

    template<typename C>

    class MemFuncAdapter : public TesterBase

    {

    private:

        C         * ptr_;

        void (C:: * memFunc_)(TestMgr *);

    public:

        MemFuncAdapter(const char * name,

                       C          * ptr,

                       void  (C:: * memFunc)(TestMgr *))

            : TesterBase(name),

              ptr_(ptr),

              memFunc_(memFunc)

        {

            ;

        }

    protected:

        virtual void doRun(TestMgr * testMgr)

        {

            (ptr_->*memFunc_)(testMgr);

        }

    };

    template<typename C>

    void SuiteTester::add(const char * name,

                        C          * ptr,

                        void  (C:: * memFunc)(TestMgr *))

        {

            testerBases_.push_back(new MemFuncAdapter<C>(name,

                                                         ptr,

                                                         memFunc));

        }

    /**

     * Adapts the C++-style interface of a member function to the

     * TesterBase interface. The function will do (most) of its test

     * based on output produced and compared.

     */

    template<typename C>

    class MemIOFuncAdapter : public TesterBase

    {

    private:

        C         * ptr_;

        void (C:: * memFunc_)(TestMgr *);

        const std::string    defFilesBaseName_;

        const std::string    lenience_;

    public:

        MemIOFuncAdapter(const char * name,

                         C          * ptr,

                         void  (C:: * memFunc)(TestMgr *),

                         const char * defFilesBaseName,

                         const char * lenience)

            : TesterBase(name),

              ptr_(ptr),

              memFunc_(memFunc),

              defFilesBaseName_(defFilesBaseName),

              lenience_(lenience == NULL ? "" : lenience)

        {

            ;

        }

    protected:

        virtual void doRun(TestMgr * testMgr)

        {

            using namespace std;

            Itk::Impl::EvaluateIOCapture(defFilesBaseName_,

                                         testMgr,

                                         bind1st(mem_fun(memFunc_),

                                                 ptr_),

                                         lenience_);

        }

    };

    template<typename C>

    void SuiteTester::add(const char   * name,

                          C            * ptr,

                          void    (C:: * memFunc)(TestMgr *),

                          const char   * defFileBaseName,

                          const char   * lenience)

    {

        testerBases_.push_back(new MemIOFuncAdapter<C>(name,

                                                       ptr,

                                                       memFunc,

                                                       defFileBaseName,

                                                       lenience));

    }

}