Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. // -*- c++ -*-
  2. /* This is a generated file, do not edit.  Generated from ../sigc++/macros/rettype.h.m4 */
  3.  
  4. #ifndef SIGCXX_RETTYPE_H
  5. #define SIGCXX_RETTYPE_H
  6.  
  7. /*
  8.   SigC::rettype
  9.   -------------
  10.   rettype() alters a Slot by changing the return type.
  11.  
  12.   Only allowed conversions or conversions to void can properly
  13.   be implemented.  The type must always be specified as a
  14.   template parameter.
  15.  
  16.   Simple Sample usage:
  17.  
  18.     int f(int);
  19.  
  20.     Slot1<void,int>   s1=rettype<void>(slot(&f));
  21.     Slot1<float,int>  s2=rettype<float>(slot(&f));
  22.  
  23. */
  24.  
  25. #include <sigc++/adaptor.h>
  26.  
  27. #ifdef SIGC_CXX_NAMESPACES
  28. namespace SigC
  29. {
  30. #endif
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42. /****************************************************************
  43. ***** Adaptor Rettype Slot 0
  44. ****************************************************************/
  45. template <class R1,
  46.    class R2>
  47. struct AdaptorRettypeSlot0_
  48.   : public AdaptorSlot_
  49.   {
  50. #ifdef SIGC_CXX_PARTIAL_SPEC
  51.    typedef R1 RType;
  52. #else
  53.    typedef typename Trait<R1>::type RType;
  54. #endif
  55.    typedef Slot0<R1> SlotType;
  56.    typedef Slot0<R2> InSlotType;
  57.    typedef AdaptorNode Node;
  58.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  59.  
  60.    static RType callback(void* d)
  61.      {
  62.       CallData* data=(CallData*)d;
  63.       Node* node=data->obj;
  64.       return RType(((typename InSlotType::Callback&)(node->data_))());
  65.      }
  66.    static SlotData* create(SlotData *s)
  67.      {
  68.       SlotData* tmp=(SlotData*)s;
  69.       Node *node=new Node();
  70.       copy_callback(tmp,node);
  71.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  72.       data.callback=&callback;
  73.       data.obj=node;
  74.       return tmp;
  75.      }
  76.   };
  77.  
  78.  
  79. #ifndef SIGC_CXX_VOID_RETURN
  80. #ifdef SIGC_CXX_PARTIAL_SPEC
  81. template <
  82.    class R2>
  83. struct AdaptorRettypeSlot0_
  84. <void,
  85.    R2>
  86.   : public AdaptorSlot_
  87.   {
  88.    typedef void RType;
  89.    typedef Slot0<void> SlotType;
  90.    typedef Slot0<R2> InSlotType;
  91.    typedef AdaptorNode Node;
  92.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  93.  
  94.    static RType callback(void* d)
  95.      {
  96.       CallData* data=(CallData*)d;
  97.       Node* node=data->obj;
  98.       ((typename InSlotType::Callback&)(node->data_))();
  99.      }
  100.    static SlotData* create(SlotData *s)
  101.      {
  102.       SlotData* tmp=(SlotData*)s;
  103.       Node *node=new Node();
  104.       copy_callback(tmp,node);
  105.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  106.       data.callback=&callback;
  107.       data.obj=node;
  108.       return tmp;
  109.      }
  110.   };
  111.  
  112. #endif
  113. #endif
  114.  
  115.  
  116. template <class R1,class R2>
  117. Slot0<R1>
  118.   rettype(const Slot0<R2> &s)
  119.   {return AdaptorRettypeSlot0_<R1,R2>::create(s.obj());
  120.   }
  121.  
  122. /****************************************************************
  123. ***** Adaptor Rettype Slot 1
  124. ****************************************************************/
  125. template <class R1,
  126.    class P1,
  127.    class R2>
  128. struct AdaptorRettypeSlot1_
  129.   : public AdaptorSlot_
  130.   {
  131. #ifdef SIGC_CXX_PARTIAL_SPEC
  132.    typedef R1 RType;
  133. #else
  134.    typedef typename Trait<R1>::type RType;
  135. #endif
  136.    typedef Slot1<R1,P1> SlotType;
  137.    typedef Slot1<R2,P1> InSlotType;
  138.    typedef AdaptorNode Node;
  139.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  140.  
  141.    static RType callback(void* d,P1 p1)
  142.      {
  143.       CallData* data=(CallData*)d;
  144.       Node* node=data->obj;
  145.       return RType(((typename InSlotType::Callback&)(node->data_))(p1));
  146.      }
  147.    static SlotData* create(SlotData *s)
  148.      {
  149.       SlotData* tmp=(SlotData*)s;
  150.       Node *node=new Node();
  151.       copy_callback(tmp,node);
  152.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  153.       data.callback=&callback;
  154.       data.obj=node;
  155.       return tmp;
  156.      }
  157.   };
  158.  
  159.  
  160. #ifndef SIGC_CXX_VOID_RETURN
  161. #ifdef SIGC_CXX_PARTIAL_SPEC
  162. template <
  163.    class P1,
  164.    class R2>
  165. struct AdaptorRettypeSlot1_
  166. <void,
  167.    P1,
  168.    R2>
  169.   : public AdaptorSlot_
  170.   {
  171.    typedef void RType;
  172.    typedef Slot1<void,P1> SlotType;
  173.    typedef Slot1<R2,P1> InSlotType;
  174.    typedef AdaptorNode Node;
  175.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  176.  
  177.    static RType callback(void* d,P1 p1)
  178.      {
  179.       CallData* data=(CallData*)d;
  180.       Node* node=data->obj;
  181.       ((typename InSlotType::Callback&)(node->data_))(p1);
  182.      }
  183.    static SlotData* create(SlotData *s)
  184.      {
  185.       SlotData* tmp=(SlotData*)s;
  186.       Node *node=new Node();
  187.       copy_callback(tmp,node);
  188.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  189.       data.callback=&callback;
  190.       data.obj=node;
  191.       return tmp;
  192.      }
  193.   };
  194.  
  195. #endif
  196. #endif
  197.  
  198.  
  199. template <class R1,class R2,class P1>
  200. Slot1<R1,P1>
  201.   rettype(const Slot1<R2,P1> &s)
  202.   {return AdaptorRettypeSlot1_<R1,
  203.            P1,R2>::create(s.obj());
  204.   }
  205.  
  206. /****************************************************************
  207. ***** Adaptor Rettype Slot 2
  208. ****************************************************************/
  209. template <class R1,
  210.    class P1,class P2,
  211.    class R2>
  212. struct AdaptorRettypeSlot2_
  213.   : public AdaptorSlot_
  214.   {
  215. #ifdef SIGC_CXX_PARTIAL_SPEC
  216.    typedef R1 RType;
  217. #else
  218.    typedef typename Trait<R1>::type RType;
  219. #endif
  220.    typedef Slot2<R1,P1,P2> SlotType;
  221.    typedef Slot2<R2,P1,P2> InSlotType;
  222.    typedef AdaptorNode Node;
  223.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  224.  
  225.    static RType callback(void* d,P1 p1,P2 p2)
  226.      {
  227.       CallData* data=(CallData*)d;
  228.       Node* node=data->obj;
  229.       return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2));
  230.      }
  231.    static SlotData* create(SlotData *s)
  232.      {
  233.       SlotData* tmp=(SlotData*)s;
  234.       Node *node=new Node();
  235.       copy_callback(tmp,node);
  236.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  237.       data.callback=&callback;
  238.       data.obj=node;
  239.       return tmp;
  240.      }
  241.   };
  242.  
  243.  
  244. #ifndef SIGC_CXX_VOID_RETURN
  245. #ifdef SIGC_CXX_PARTIAL_SPEC
  246. template <
  247.    class P1,class P2,
  248.    class R2>
  249. struct AdaptorRettypeSlot2_
  250. <void,
  251.    P1,P2,
  252.    R2>
  253.   : public AdaptorSlot_
  254.   {
  255.    typedef void RType;
  256.    typedef Slot2<void,P1,P2> SlotType;
  257.    typedef Slot2<R2,P1,P2> InSlotType;
  258.    typedef AdaptorNode Node;
  259.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  260.  
  261.    static RType callback(void* d,P1 p1,P2 p2)
  262.      {
  263.       CallData* data=(CallData*)d;
  264.       Node* node=data->obj;
  265.       ((typename InSlotType::Callback&)(node->data_))(p1,p2);
  266.      }
  267.    static SlotData* create(SlotData *s)
  268.      {
  269.       SlotData* tmp=(SlotData*)s;
  270.       Node *node=new Node();
  271.       copy_callback(tmp,node);
  272.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  273.       data.callback=&callback;
  274.       data.obj=node;
  275.       return tmp;
  276.      }
  277.   };
  278.  
  279. #endif
  280. #endif
  281.  
  282.  
  283. template <class R1,class R2,class P1,class P2>
  284. Slot2<R1,P1,P2>
  285.   rettype(const Slot2<R2,P1,P2> &s)
  286.   {return AdaptorRettypeSlot2_<R1,
  287.            P1,P2,R2>::create(s.obj());
  288.   }
  289.  
  290. /****************************************************************
  291. ***** Adaptor Rettype Slot 3
  292. ****************************************************************/
  293. template <class R1,
  294.    class P1,class P2,class P3,
  295.    class R2>
  296. struct AdaptorRettypeSlot3_
  297.   : public AdaptorSlot_
  298.   {
  299. #ifdef SIGC_CXX_PARTIAL_SPEC
  300.    typedef R1 RType;
  301. #else
  302.    typedef typename Trait<R1>::type RType;
  303. #endif
  304.    typedef Slot3<R1,P1,P2,P3> SlotType;
  305.    typedef Slot3<R2,P1,P2,P3> InSlotType;
  306.    typedef AdaptorNode Node;
  307.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  308.  
  309.    static RType callback(void* d,P1 p1,P2 p2,P3 p3)
  310.      {
  311.       CallData* data=(CallData*)d;
  312.       Node* node=data->obj;
  313.       return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3));
  314.      }
  315.    static SlotData* create(SlotData *s)
  316.      {
  317.       SlotData* tmp=(SlotData*)s;
  318.       Node *node=new Node();
  319.       copy_callback(tmp,node);
  320.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  321.       data.callback=&callback;
  322.       data.obj=node;
  323.       return tmp;
  324.      }
  325.   };
  326.  
  327.  
  328. #ifndef SIGC_CXX_VOID_RETURN
  329. #ifdef SIGC_CXX_PARTIAL_SPEC
  330. template <
  331.    class P1,class P2,class P3,
  332.    class R2>
  333. struct AdaptorRettypeSlot3_
  334. <void,
  335.    P1,P2,P3,
  336.    R2>
  337.   : public AdaptorSlot_
  338.   {
  339.    typedef void RType;
  340.    typedef Slot3<void,P1,P2,P3> SlotType;
  341.    typedef Slot3<R2,P1,P2,P3> InSlotType;
  342.    typedef AdaptorNode Node;
  343.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  344.  
  345.    static RType callback(void* d,P1 p1,P2 p2,P3 p3)
  346.      {
  347.       CallData* data=(CallData*)d;
  348.       Node* node=data->obj;
  349.       ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3);
  350.      }
  351.    static SlotData* create(SlotData *s)
  352.      {
  353.       SlotData* tmp=(SlotData*)s;
  354.       Node *node=new Node();
  355.       copy_callback(tmp,node);
  356.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  357.       data.callback=&callback;
  358.       data.obj=node;
  359.       return tmp;
  360.      }
  361.   };
  362.  
  363. #endif
  364. #endif
  365.  
  366.  
  367. template <class R1,class R2,class P1,class P2,class P3>
  368. Slot3<R1,P1,P2,P3>
  369.   rettype(const Slot3<R2,P1,P2,P3> &s)
  370.   {return AdaptorRettypeSlot3_<R1,
  371.            P1,P2,P3,R2>::create(s.obj());
  372.   }
  373.  
  374. /****************************************************************
  375. ***** Adaptor Rettype Slot 4
  376. ****************************************************************/
  377. template <class R1,
  378.    class P1,class P2,class P3,class P4,
  379.    class R2>
  380. struct AdaptorRettypeSlot4_
  381.   : public AdaptorSlot_
  382.   {
  383. #ifdef SIGC_CXX_PARTIAL_SPEC
  384.    typedef R1 RType;
  385. #else
  386.    typedef typename Trait<R1>::type RType;
  387. #endif
  388.    typedef Slot4<R1,P1,P2,P3,P4> SlotType;
  389.    typedef Slot4<R2,P1,P2,P3,P4> InSlotType;
  390.    typedef AdaptorNode Node;
  391.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  392.  
  393.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  394.      {
  395.       CallData* data=(CallData*)d;
  396.       Node* node=data->obj;
  397.       return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4));
  398.      }
  399.    static SlotData* create(SlotData *s)
  400.      {
  401.       SlotData* tmp=(SlotData*)s;
  402.       Node *node=new Node();
  403.       copy_callback(tmp,node);
  404.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  405.       data.callback=&callback;
  406.       data.obj=node;
  407.       return tmp;
  408.      }
  409.   };
  410.  
  411.  
  412. #ifndef SIGC_CXX_VOID_RETURN
  413. #ifdef SIGC_CXX_PARTIAL_SPEC
  414. template <
  415.    class P1,class P2,class P3,class P4,
  416.    class R2>
  417. struct AdaptorRettypeSlot4_
  418. <void,
  419.    P1,P2,P3,P4,
  420.    R2>
  421.   : public AdaptorSlot_
  422.   {
  423.    typedef void RType;
  424.    typedef Slot4<void,P1,P2,P3,P4> SlotType;
  425.    typedef Slot4<R2,P1,P2,P3,P4> InSlotType;
  426.    typedef AdaptorNode Node;
  427.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  428.  
  429.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  430.      {
  431.       CallData* data=(CallData*)d;
  432.       Node* node=data->obj;
  433.       ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4);
  434.      }
  435.    static SlotData* create(SlotData *s)
  436.      {
  437.       SlotData* tmp=(SlotData*)s;
  438.       Node *node=new Node();
  439.       copy_callback(tmp,node);
  440.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  441.       data.callback=&callback;
  442.       data.obj=node;
  443.       return tmp;
  444.      }
  445.   };
  446.  
  447. #endif
  448. #endif
  449.  
  450.  
  451. template <class R1,class R2,class P1,class P2,class P3,class P4>
  452. Slot4<R1,P1,P2,P3,P4>
  453.   rettype(const Slot4<R2,P1,P2,P3,P4> &s)
  454.   {return AdaptorRettypeSlot4_<R1,
  455.            P1,P2,P3,P4,R2>::create(s.obj());
  456.   }
  457.  
  458. /****************************************************************
  459. ***** Adaptor Rettype Slot 5
  460. ****************************************************************/
  461. template <class R1,
  462.    class P1,class P2,class P3,class P4,class P5,
  463.    class R2>
  464. struct AdaptorRettypeSlot5_
  465.   : public AdaptorSlot_
  466.   {
  467. #ifdef SIGC_CXX_PARTIAL_SPEC
  468.    typedef R1 RType;
  469. #else
  470.    typedef typename Trait<R1>::type RType;
  471. #endif
  472.    typedef Slot5<R1,P1,P2,P3,P4,P5> SlotType;
  473.    typedef Slot5<R2,P1,P2,P3,P4,P5> InSlotType;
  474.    typedef AdaptorNode Node;
  475.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  476.  
  477.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  478.      {
  479.       CallData* data=(CallData*)d;
  480.       Node* node=data->obj;
  481.       return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5));
  482.      }
  483.    static SlotData* create(SlotData *s)
  484.      {
  485.       SlotData* tmp=(SlotData*)s;
  486.       Node *node=new Node();
  487.       copy_callback(tmp,node);
  488.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  489.       data.callback=&callback;
  490.       data.obj=node;
  491.       return tmp;
  492.      }
  493.   };
  494.  
  495.  
  496. #ifndef SIGC_CXX_VOID_RETURN
  497. #ifdef SIGC_CXX_PARTIAL_SPEC
  498. template <
  499.    class P1,class P2,class P3,class P4,class P5,
  500.    class R2>
  501. struct AdaptorRettypeSlot5_
  502. <void,
  503.    P1,P2,P3,P4,P5,
  504.    R2>
  505.   : public AdaptorSlot_
  506.   {
  507.    typedef void RType;
  508.    typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
  509.    typedef Slot5<R2,P1,P2,P3,P4,P5> InSlotType;
  510.    typedef AdaptorNode Node;
  511.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  512.  
  513.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  514.      {
  515.       CallData* data=(CallData*)d;
  516.       Node* node=data->obj;
  517.       ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5);
  518.      }
  519.    static SlotData* create(SlotData *s)
  520.      {
  521.       SlotData* tmp=(SlotData*)s;
  522.       Node *node=new Node();
  523.       copy_callback(tmp,node);
  524.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  525.       data.callback=&callback;
  526.       data.obj=node;
  527.       return tmp;
  528.      }
  529.   };
  530.  
  531. #endif
  532. #endif
  533.  
  534.  
  535. template <class R1,class R2,class P1,class P2,class P3,class P4,class P5>
  536. Slot5<R1,P1,P2,P3,P4,P5>
  537.   rettype(const Slot5<R2,P1,P2,P3,P4,P5> &s)
  538.   {return AdaptorRettypeSlot5_<R1,
  539.            P1,P2,P3,P4,P5,R2>::create(s.obj());
  540.   }
  541.  
  542. /****************************************************************
  543. ***** Adaptor Rettype Slot 6
  544. ****************************************************************/
  545. template <class R1,
  546.    class P1,class P2,class P3,class P4,class P5,class P6,
  547.    class R2>
  548. struct AdaptorRettypeSlot6_
  549.   : public AdaptorSlot_
  550.   {
  551. #ifdef SIGC_CXX_PARTIAL_SPEC
  552.    typedef R1 RType;
  553. #else
  554.    typedef typename Trait<R1>::type RType;
  555. #endif
  556.    typedef Slot6<R1,P1,P2,P3,P4,P5,P6> SlotType;
  557.    typedef Slot6<R2,P1,P2,P3,P4,P5,P6> InSlotType;
  558.    typedef AdaptorNode Node;
  559.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  560.  
  561.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  562.      {
  563.       CallData* data=(CallData*)d;
  564.       Node* node=data->obj;
  565.       return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6));
  566.      }
  567.    static SlotData* create(SlotData *s)
  568.      {
  569.       SlotData* tmp=(SlotData*)s;
  570.       Node *node=new Node();
  571.       copy_callback(tmp,node);
  572.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  573.       data.callback=&callback;
  574.       data.obj=node;
  575.       return tmp;
  576.      }
  577.   };
  578.  
  579.  
  580. #ifndef SIGC_CXX_VOID_RETURN
  581. #ifdef SIGC_CXX_PARTIAL_SPEC
  582. template <
  583.    class P1,class P2,class P3,class P4,class P5,class P6,
  584.    class R2>
  585. struct AdaptorRettypeSlot6_
  586. <void,
  587.    P1,P2,P3,P4,P5,P6,
  588.    R2>
  589.   : public AdaptorSlot_
  590.   {
  591.    typedef void RType;
  592.    typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
  593.    typedef Slot6<R2,P1,P2,P3,P4,P5,P6> InSlotType;
  594.    typedef AdaptorNode Node;
  595.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  596.  
  597.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  598.      {
  599.       CallData* data=(CallData*)d;
  600.       Node* node=data->obj;
  601.       ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6);
  602.      }
  603.    static SlotData* create(SlotData *s)
  604.      {
  605.       SlotData* tmp=(SlotData*)s;
  606.       Node *node=new Node();
  607.       copy_callback(tmp,node);
  608.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  609.       data.callback=&callback;
  610.       data.obj=node;
  611.       return tmp;
  612.      }
  613.   };
  614.  
  615. #endif
  616. #endif
  617.  
  618.  
  619. template <class R1,class R2,class P1,class P2,class P3,class P4,class P5,class P6>
  620. Slot6<R1,P1,P2,P3,P4,P5,P6>
  621.   rettype(const Slot6<R2,P1,P2,P3,P4,P5,P6> &s)
  622.   {return AdaptorRettypeSlot6_<R1,
  623.            P1,P2,P3,P4,P5,P6,R2>::create(s.obj());
  624.   }
  625.  
  626. /****************************************************************
  627. ***** Adaptor Rettype Slot 7
  628. ****************************************************************/
  629. template <class R1,
  630.    class P1,class P2,class P3,class P4,class P5,class P6,class P7,
  631.    class R2>
  632. struct AdaptorRettypeSlot7_
  633.   : public AdaptorSlot_
  634.   {
  635. #ifdef SIGC_CXX_PARTIAL_SPEC
  636.    typedef R1 RType;
  637. #else
  638.    typedef typename Trait<R1>::type RType;
  639. #endif
  640.    typedef Slot7<R1,P1,P2,P3,P4,P5,P6,P7> SlotType;
  641.    typedef Slot7<R2,P1,P2,P3,P4,P5,P6,P7> InSlotType;
  642.    typedef AdaptorNode Node;
  643.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  644.  
  645.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
  646.      {
  647.       CallData* data=(CallData*)d;
  648.       Node* node=data->obj;
  649.       return RType(((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7));
  650.      }
  651.    static SlotData* create(SlotData *s)
  652.      {
  653.       SlotData* tmp=(SlotData*)s;
  654.       Node *node=new Node();
  655.       copy_callback(tmp,node);
  656.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  657.       data.callback=&callback;
  658.       data.obj=node;
  659.       return tmp;
  660.      }
  661.   };
  662.  
  663.  
  664. #ifndef SIGC_CXX_VOID_RETURN
  665. #ifdef SIGC_CXX_PARTIAL_SPEC
  666. template <
  667.    class P1,class P2,class P3,class P4,class P5,class P6,class P7,
  668.    class R2>
  669. struct AdaptorRettypeSlot7_
  670. <void,
  671.    P1,P2,P3,P4,P5,P6,P7,
  672.    R2>
  673.   : public AdaptorSlot_
  674.   {
  675.    typedef void RType;
  676.    typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> SlotType;
  677.    typedef Slot7<R2,P1,P2,P3,P4,P5,P6,P7> InSlotType;
  678.    typedef AdaptorNode Node;
  679.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  680.  
  681.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
  682.      {
  683.       CallData* data=(CallData*)d;
  684.       Node* node=data->obj;
  685.       ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,p7);
  686.      }
  687.    static SlotData* create(SlotData *s)
  688.      {
  689.       SlotData* tmp=(SlotData*)s;
  690.       Node *node=new Node();
  691.       copy_callback(tmp,node);
  692.       CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  693.       data.callback=&callback;
  694.       data.obj=node;
  695.       return tmp;
  696.      }
  697.   };
  698.  
  699. #endif
  700. #endif
  701.  
  702.  
  703. template <class R1,class R2,class P1,class P2,class P3,class P4,class P5,class P6,class P7>
  704. Slot7<R1,P1,P2,P3,P4,P5,P6,P7>
  705.   rettype(const Slot7<R2,P1,P2,P3,P4,P5,P6,P7> &s)
  706.   {return AdaptorRettypeSlot7_<R1,
  707.            P1,P2,P3,P4,P5,P6,P7,R2>::create(s.obj());
  708.   }
  709.  
  710.  
  711. #ifdef SIGC_CXX_NAMESPACES
  712. } // namespace
  713. #endif
  714.  
  715. #endif
  716.