// -*- c++ -*- dnl bind.h.m4 - adaptor to fix arguments to a value dnl // Copyright 2000, Karl Einar Nelson dnl dnl This library is free software; you can redistribute it and/or dnl modify it under the terms of the GNU Lesser General Public dnl License as published by the Free Software Foundation; either dnl version 2 of the License, or (at your option) any later version. dnl dnl This library is distributed in the hope that it will be useful, dnl but WITHOUT ANY WARRANTY; without even the implied warranty of dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU dnl Lesser General Public License for more details. dnl dnl You should have received a copy of the GNU Lesser General Public dnl License along with this library; if not, write to the Free Software dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA dnl dnl dnl Implementation notes: dnl In order to avoid creating type records and vtables for dnl the various bind type slots, I have factored out the dtor dnl of the data items. It creates a data node containing dnl both the adaptor and the extra data which needs to be added. dnl Then when the adaptor is destroyed it, it calls the dtor dnl procedure which takes out the extra data. dnl dnl It is possible this technique is non-portable though given dnl the necessary interactions with C code it seems unlikely dnl to break all but the most exotic of C++ compilers. dnl (watch Karl eat hat) dnl include(template.macros.m4) #ifndef __header__ #define __header__ #include /** @defgroup bind * * SigC::bind() alters a SigC::Slot by fixing arguments to certain values. * * Argument fixing starts from the last argument. * Up to two arguments can be bound at a time. * * Simple sample usage: * @code * void f(int, int); * SigC:Slot2 s1 = SigC::slot(f); * * SigC::Slot1 s2 = SigC::bind(s1,1); * s2(2); // call f with arguments 2,1 * @endcode * * Multibinding usage: * * @code * void f(int,int); * SigC::Slot2 s1 = SigC::slot(f); * * SigC::Slot0 s2 = SigC::bind(s1, 1, 2); * s2(); // call f with arguments 1, 2 * @endcode * * Type specified usage: * * @code * class A {}; * class B : public A {}; * B* b; * SigC::Slot0 s1; * * SigC::Slot0 s2 = SIgC::bind(s1, b); // B* converted to A* * @endcode * * * SigC::bind_return() alters a Slot by fixing the return value to certain values * * Return value fixing ignores any slot return value. The slot is * destroyed in the process and a new one is created, so references * to the slot will no longer be valid. * * Typecasting may be necessary to match arguments between the * slot and the bound return value. Types must be an exact match. * To ensure the proper type, the type can be explicitly specified * on template instantation. * * Simple sample usage: * @code * void f(int, int); * SigC::Slot1 s1 = SigC::bind_return(slot(&f), 1); * std::cout << "s2: " << s1(2, 1) << std::endl; * @endcode * * Type specified usage: * @code * class A {}; * class B : public A {}; * B* b; * SigC::Slot1 s1; * * SigC::Slot0 s2 = SigC::bind_return(s1, b); // B* must be told to match A* * @endcode * */ #ifdef SIGC_CXX_NAMESPACES namespace SigC { #endif define([FORMAT_ARG_CBINIT],[LOWER([$1])_(LOWER([$1]))])dnl define([FORMAT_ARG_CBNAME],[node.LOWER([$1])_])dnl define([FORMAT_ARG_CBDTOR],[node.LOWER([$1])_.~[$1]();])dnl define([FORMAT_ARG_CBBIND],[[$1] LOWER([$1])_;])dnl dnl define([ARG_CBINIT],[PROT(ARG_LOOP([FORMAT_ARG_CBINIT],[[,]],$*))])dnl define([ARG_CBNAME],[PROT(ARG_LOOP([FORMAT_ARG_CBNAME],[[,]],$*))])dnl define([ARG_CBDTOR],[PROT(ARG_LOOP([FORMAT_ARG_CBDTOR],[[ ]],$*))])dnl define([ARG_CBBIND],[PROT(ARG_LOOP([FORMAT_ARG_CBBIND],[[ ]],$*))])dnl dnl /**************************************************************/ // These are internal classes used to represent function varients of slots // (internal) struct LIBSIGC_API AdaptorBindSlotNode : public AdaptorSlotNode { FuncPtr dtor_; AdaptorBindSlotNode(FuncPtr proxy, const Node& s, FuncPtr dtor); virtual ~AdaptorBindSlotNode(); }; dnl dnl ADAPTOR_BIND_DATA([C0..CM]) dnl define([ADAPTOR_BIND_DATA],[dnl template struct [AdaptorBindData]NUM($1)_ { typedef [AdaptorBindData]NUM($1)_ Self; AdaptorBindSlotNode adaptor; ARG_CBBIND($1) AdaptorBindData[]NUM($1)_(FuncPtr p, const Node& s ,FuncPtr d, ARG_BOTH($1)) : adaptor(p, s, d), ARG_CBINIT($1) {} static void dtor(void* data) { Self& node = *reinterpret_cast(data); ARG_CBDTOR($1) } }; ]) dnl dnl ADAPTOR_BIND_SLOT([P1..PN],[C0..CM],[A0..AM]) dnl define([ADAPTOR_BIND_SLOT],[dnl template struct [AdaptorBindSlot]NUM($1)[_]NUM($2)_ { typedef typename Trait::type RType; typedef typename __SLOT__(R,$1,$2)::Proxy Proxy; static RType proxy(LIST(ARG_REF($1),void *data)) { typedef [AdaptorBindData]NUM($2)_ Data; Data& node=*reinterpret_cast(data); SlotNode* slot=static_cast(node.adaptor.slot_.impl()); return ((Proxy)(slot->proxy_)) (LIST(ARG_NAME($1),ARG_CBNAME($2)),slot); } }; /// @ingroup bind template __SLOT__(R,$1) bind(const __SLOT__(R,$1,$2)& s, ARG_BOTH($3)) { typedef [AdaptorBindData]NUM($2)[_] Data; typedef [AdaptorBindSlot]NUM($1)[_]NUM($2)_ Adaptor; return reinterpret_cast( new Data((FuncPtr)(&Adaptor::proxy),s, (FuncPtr)(&Data::dtor),ARG_NAME($3))); } ]) ADAPTOR_BIND_DATA(ARGS(C,1)) ADAPTOR_BIND_DATA(ARGS(C,2)) ADAPTOR_BIND_SLOT(ARGS(P,0),ARGS(C,1),ARGS(A,1)) ADAPTOR_BIND_SLOT(ARGS(P,1),ARGS(C,1),ARGS(A,1)) ADAPTOR_BIND_SLOT(ARGS(P,2),ARGS(C,1),ARGS(A,1)) ADAPTOR_BIND_SLOT(ARGS(P,3),ARGS(C,1),ARGS(A,1)) ADAPTOR_BIND_SLOT(ARGS(P,4),ARGS(C,1),ARGS(A,1)) ADAPTOR_BIND_SLOT(ARGS(P,0),ARGS(C,2),ARGS(A,2)) ADAPTOR_BIND_SLOT(ARGS(P,1),ARGS(C,2),ARGS(A,2)) ADAPTOR_BIND_SLOT(ARGS(P,2),ARGS(C,2),ARGS(A,2)) ADAPTOR_BIND_SLOT(ARGS(P,3),ARGS(C,2),ARGS(A,2)) #ifdef SIGC_CXX_NAMESPACES } // namespace #endif #endif // __header__