---

general-functions.hh

/*
*  Name:      general-functions.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   General functions
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1999-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_UTIL_GENERAL_FUNCTIONS__
#define _MPCL_UTIL_GENERAL_FUNCTIONS__

#include <cstdlib>
#include <functional>


namespace mpcl
{

  namespace util
  {

    //
    //  E X P O R T E D   F U N C T I O N S
    //

    template <typename TTargetItem, typename TSourceItem>
    struct MAppend : public std::unary_function<TTargetItem, void>
    {

      public:

        const TSourceItem&   rktSourceItem;


      public:

        MAppend (const TSourceItem& rktSOURCE_ITEM) :
          rktSourceItem (rktSOURCE_ITEM)            {}

        void operator () (TTargetItem& rtTARGET_ITEM) const
        {
          operator << (*rtTARGET_ITEM, rktSourceItem);
        }

    };  // struct MAppend

    template < typename TItem      ,
               typename TSizeType  ,
               typename MOperation ,
               typename MFunction  >
    struct MCompare : public std::unary_function<TItem, void>
    {

      public:

        MFunction   mFunction;

        MOperation   mOperation;

        TSizeType   zComputedValue;


      public:

        MCompare ( const TSizeType&  rkzVALUE     ,
                   const MOperation& rkmOPERATION ,
                   const MFunction&  rkmFUNCTION  ) :
          mFunction      (rkmFUNCTION)              ,
          mOperation     (rkmOPERATION)             ,
          zComputedValue (rkzVALUE)                 {}

        MCompare (const TSizeType& rkzVALUE, const MFunction& rkmFUNCTION) :
          mFunction      (rkmFUNCTION)                                     ,
          mOperation     ()                                                ,
          zComputedValue (rkzVALUE)                                        {}

        void operator () (const TItem& rktITEM)
        {
          TSizeType   zItemResult (mFunction (rktITEM));

          if ( mOperation (zComputedValue, zItemResult) )
          {
            zComputedValue = zItemResult;
          }
        }

        operator TSizeType (void) const
        {
          return zComputedValue;
        }

    };  // struct MCompare

    template < typename TItem      ,
               typename TSizeType  ,
               typename MOperation ,
               typename MFunction  >
    struct MComparePointer : public std::unary_function<TItem, void>
    {

      public:

        MFunction   mFunction;

        MOperation   mOperation;

        TSizeType   zComputedValue;


      public:

        MComparePointer ( const TSizeType&  rkzVALUE     ,
                          const MOperation& rkmOPERATION ,
                          const MFunction&  rkmFUNCTION  ) :
          mFunction      (rkmFUNCTION)                     ,
          mOperation     (rkmOPERATION)                    ,
          zComputedValue (rkzVALUE)                        {}

        MComparePointer (const TSizeType& rkzVALUE, const MFunction& rkmFUNCTION) :
          mFunction      (rkmFUNCTION)                                            ,
          mOperation     ()                                                       ,
          zComputedValue (rkzVALUE)                                               {}

        void operator () (const TItem& rktITEM)
        {
          TSizeType   zItemResult (mFunction (*rktITEM));

          if ( mOperation (zComputedValue, zItemResult) )
          {
            zComputedValue = zItemResult;
          }
        }

        void operator () (TItem& rtITEM)
        {
          TSizeType   zItemResult (mFunction (*rtITEM));

          if ( mOperation (zComputedValue, zItemResult) )
          {
            zComputedValue = zItemResult;
          }
        }

        operator TSizeType (void) const
        {
          return zComputedValue;
        }

    };  // struct MComparePointer

    template < typename TItem      ,
               typename TSizeType  ,
               typename MFunction  >
    struct MSum : public std::unary_function<TItem, void>
    {

      private:

        MFunction   mFunction;

        TSizeType   zSum;


      public:

        MSum (const MFunction& rkmFUNCTION) :
          mFunction (rkmFUNCTION)           ,
          zSum      (0)                     {}

        void operator () (const TItem& rktITEM)
        {
          zSum += mFunction (rktITEM);
        }

        operator TSizeType (void) const
        {
          return zSum;
        }

    };  // struct MSum

    template < typename TItem      ,
               typename TSizeType  ,
               typename MFunction  >
    struct MSumPointer : public std::unary_function<TItem, void>
    {

      private:

        MFunction   mFunction;

        TSizeType   zSum;


      public:

        MSumPointer (const MFunction& rkmFUNCTION) :
          mFunction (rkmFUNCTION)                  ,
          zSum      (0)                            {}

        void operator () (const TItem& rktITEM)
        {
          zSum += mFunction (*rktITEM);
        }

        operator TSizeType (void) const
        {
          return zSum;
        }

    };  // struct MSumPointer

    template <typename TItem>
    struct MDelete : public std::unary_function<TItem, void>
    {

        void operator () (const TItem& rktITEM) const
        {
          delete rktITEM;
        }

    };  // struct MDelete

    template <typename TItem>
    struct MRandomNumberGenerator
    {

        TItem operator () (const size_t kzMAX) const
        {
          return TItem (((kzMAX + 1.0) / (RAND_MAX + 1.0)) * std::rand());
        }

    };  // struct MRandomNumberGenerator

  }  // namespace util

}  // namespace mpcl


#endif  // not _MPCL_UTIL_GENERAL_FUNCTIONS__

---