/* This is for emacs: -*-Mode: C++;-*- */
/* Copyright 2002, Andreas Rottmann */
/* This is a generated file, do not edit.  Generated from template.macros.m4 */

#ifndef SIGC_BIND3_H
#define SIGC_BIND3_H

#include <sigc++/bind.h>

namespace SigCX
{

using namespace SigC;

template <class C1,class C2,class C3>
struct AdaptorBindData3_
  {
    typedef AdaptorBindData3_ Self;
    AdaptorBindSlotNode adaptor;
    C1 c1_;
        C2 c2_;
        C3 c3_;
    AdaptorBindData3_(FuncPtr p, const Node& s ,FuncPtr d,
      C1 c1,C2 c2,C3 c3)
    : adaptor(p, s, d), c1_(c1),c2_(c2),c3_(c3)
      {}

    static void dtor(void* data)
      {
        Self& node = *reinterpret_cast<Self*>(data);
        node.c1_.~C1();
        node.c2_.~C2();
        node.c3_.~C3();
      }
  }; 



template <class R,class C1,class C2,class C3>
struct AdaptorBindSlot0_3_
  {
    typedef typename Trait<R>::type RType;
    typedef typename SigC::Slot3<R,C1,C2,C3>::Proxy Proxy;
    static RType proxy(void *data) 
      { 
        typedef AdaptorBindData3_<C1,C2,C3> Data;
        Data& node=*reinterpret_cast<Data*>(data);
        SlotNode* slot=static_cast<SlotNode*>(node.adaptor.slot_.impl());
        return ((Proxy)(slot->proxy_))
          (node.c1_,node.c2_,node.c3_,slot);
      }

  };

/// @ingroup bind
template <class A1,class A2,class A3,class R,class C1,class C2,class C3>
SigC::Slot0<R>
  bind(const SigC::Slot3<R,C1,C2,C3>& s,
       A1 a1,A2 a2,A3 a3)
  { 
    typedef AdaptorBindData3_<C1,C2,C3> Data;
    typedef AdaptorBindSlot0_3_<R,C1,C2,C3> Adaptor;
    return reinterpret_cast<SlotNode*>(
       new Data((FuncPtr)(&Adaptor::proxy),s,
                (FuncPtr)(&Data::dtor),a1,a2,a3));
  }


template <class R,class P1,class C1,class C2,class C3>
struct AdaptorBindSlot1_3_
  {
    typedef typename Trait<R>::type RType;
    typedef typename SigC::Slot4<R,P1,C1,C2,C3>::Proxy Proxy;
    static RType proxy(typename SigC::Trait<P1>::ref p1,void *data) 
      { 
        typedef AdaptorBindData3_<C1,C2,C3> Data;
        Data& node=*reinterpret_cast<Data*>(data);
        SlotNode* slot=static_cast<SlotNode*>(node.adaptor.slot_.impl());
        return ((Proxy)(slot->proxy_))
          (p1,node.c1_,node.c2_,node.c3_,slot);
      }

  };

/// @ingroup bind
template <class A1,class A2,class A3,class R,class P1,class C1,class C2,class C3>
SigC::Slot1<R,P1>
  bind(const SigC::Slot4<R,P1,C1,C2,C3>& s,
       A1 a1,A2 a2,A3 a3)
  { 
    typedef AdaptorBindData3_<C1,C2,C3> Data;
    typedef AdaptorBindSlot1_3_<R,P1,C1,C2,C3> Adaptor;
    return reinterpret_cast<SlotNode*>(
       new Data((FuncPtr)(&Adaptor::proxy),s,
                (FuncPtr)(&Data::dtor),a1,a2,a3));
  }


template <class R,class P1,class P2,class C1,class C2,class C3>
struct AdaptorBindSlot2_3_
  {
    typedef typename Trait<R>::type RType;
    typedef typename SigC::Slot5<R,P1,P2,C1,C2,C3>::Proxy Proxy;
    static RType proxy(typename SigC::Trait<P1>::ref p1,typename SigC::Trait<P2>::ref p2,void *data) 
      { 
        typedef AdaptorBindData3_<C1,C2,C3> Data;
        Data& node=*reinterpret_cast<Data*>(data);
        SlotNode* slot=static_cast<SlotNode*>(node.adaptor.slot_.impl());
        return ((Proxy)(slot->proxy_))
          (p1,p2,node.c1_,node.c2_,node.c3_,slot);
      }

  };

/// @ingroup bind
template <class A1,class A2,class A3,class R,class P1,class P2,class C1,class C2,class C3>
SigC::Slot2<R,P1,P2>
  bind(const SigC::Slot5<R,P1,P2,C1,C2,C3>& s,
       A1 a1,A2 a2,A3 a3)
  { 
    typedef AdaptorBindData3_<C1,C2,C3> Data;
    typedef AdaptorBindSlot2_3_<R,P1,P2,C1,C2,C3> Adaptor;
    return reinterpret_cast<SlotNode*>(
       new Data((FuncPtr)(&Adaptor::proxy),s,
                (FuncPtr)(&Data::dtor),a1,a2,a3));
  }


template <class R,class P1,class P2,class P3,class C1,class C2,class C3>
struct AdaptorBindSlot3_3_
  {
    typedef typename Trait<R>::type RType;
    typedef typename SigC::Slot6<R,P1,P2,P3,C1,C2,C3>::Proxy Proxy;
    static RType proxy(typename SigC::Trait<P1>::ref p1,typename SigC::Trait<P2>::ref p2,typename SigC::Trait<P3>::ref p3,void *data) 
      { 
        typedef AdaptorBindData3_<C1,C2,C3> Data;
        Data& node=*reinterpret_cast<Data*>(data);
        SlotNode* slot=static_cast<SlotNode*>(node.adaptor.slot_.impl());
        return ((Proxy)(slot->proxy_))
          (p1,p2,p3,node.c1_,node.c2_,node.c3_,slot);
      }

  };

/// @ingroup bind
template <class A1,class A2,class A3,class R,class P1,class P2,class P3,class C1,class C2,class C3>
SigC::Slot3<R,P1,P2,P3>
  bind(const SigC::Slot6<R,P1,P2,P3,C1,C2,C3>& s,
       A1 a1,A2 a2,A3 a3)
  { 
    typedef AdaptorBindData3_<C1,C2,C3> Data;
    typedef AdaptorBindSlot3_3_<R,P1,P2,P3,C1,C2,C3> Adaptor;
    return reinterpret_cast<SlotNode*>(
       new Data((FuncPtr)(&Adaptor::proxy),s,
                (FuncPtr)(&Data::dtor),a1,a2,a3));
  }



} // namespace SigCX
 
#endif