File indexing completed on 2024-09-22 04:53:10

 /*
  * SPDX-FileCopyrightText: 2008 Trevor Pounds
  * SPDX-License-Identifier: MIT
  */
 
 #ifndef __MOCKITOPP_DYNAMIC_OBJECT_HPP__
 #define __MOCKITOPP_DYNAMIC_OBJECT_HPP__
 
 #include <mockitopp/exceptions.hpp>
 #include <mockitopp/detail/stubbing/dynamic_vfunction.hpp>
 #include <mockitopp/detail/stubbing/proxy_vfunction.hpp>
 #include <mockitopp/detail/util/remove_member_function_pointer_cv.hpp>
 
 namespace mockitopp
 {
    namespace detail
    {
       /**
        * helper class to find the vtable offset given a member function pointer
        */
       struct vtable_offset_helper
       {
          template <typename T>
          static int get(T ptr2member)
          {
             vtable_offset_helper f;
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
             return (f.*reinterpret_cast<int (vtable_offset_helper::*)()>(ptr2member))();
 #pragma GCC diagnostic pop
          }
 
          virtual int offset0() { return 0; }
          virtual int offset1() { return 1; }
          virtual int offset2() { return 2; }
          virtual int offset3() { return 3; }
          virtual int offset4() { return 4; }
          virtual int offset5() { return 5; }
          virtual int offset6() { return 6; }
          virtual int offset7() { return 7; }
          virtual int offset8() { return 8; }
          virtual int offset9() { return 9; }
          virtual int offset10() { return 10; }
          virtual int offset11() { return 11; }
          virtual int offset12() { return 12; }
          virtual int offset13() { return 13; }
          virtual int offset14() { return 14; }
          virtual int offset15() { return 15; }
          virtual int offset16() { return 16; }
          virtual int offset17() { return 17; }
          virtual int offset18() { return 18; }
          virtual int offset19() { return 19; }
          virtual int offset20() { return 20; }
          virtual int offset21() { return 21; }
          virtual int offset22() { return 22; }
          virtual int offset23() { return 23; }
          virtual int offset24() { return 24; }
          virtual int offset25() { return 25; }
          virtual int offset26() { return 26; }
          virtual int offset27() { return 27; }
          virtual int offset28() { return 28; }
          virtual int offset29() { return 29; }
          virtual int offset30() { return 30; }
          virtual int offset31() { return 31; }
          virtual int offset32() { return 32; }
          virtual int offset33() { return 33; }
          virtual int offset34() { return 34; }
          virtual int offset35() { return 35; }
          virtual int offset36() { return 36; }
          virtual int offset37() { return 37; }
          virtual int offset38() { return 38; }
          virtual int offset39() { return 39; }
          virtual int offset40() { return 40; }
          virtual int offset41() { return 41; }
          virtual int offset42() { return 42; }
          virtual int offset43() { return 43; }
          virtual int offset44() { return 44; }
          virtual int offset45() { return 45; }
          virtual int offset46() { return 46; }
          virtual int offset47() { return 47; }
          virtual int offset48() { return 48; }
          virtual int offset49() { return 49; }
 
          virtual ~vtable_offset_helper() {}
       };
 
       /**
        * implementation class for pseduo-dynamically defining an interface
        */
       struct dynamic_object
       {
          struct vtable {
             void* vbase_offset;
             void* vcall_offset;
             void* offset_to_top;
             void* type_info;
             void* functions[50];
          };
 
          void*   vtable_object_ptr;
          void*   vtable_mocks[50];
          vtable* vtable_actual_ptr;
 
          dynamic_object()
             : vtable_actual_ptr(new vtable)
          {
             vtable_actual_ptr->vbase_offset  = 0;
             vtable_actual_ptr->vcall_offset  = 0;
             vtable_actual_ptr->offset_to_top = 0;
             vtable_actual_ptr->type_info     = 0;
             for(int i = 0; i < 50; i++)
             {
                vtable_actual_ptr->functions[i] = horrible_cast<void*>(&dynamic_object::missing_vfunction);
                vtable_mocks[i] = 0;
             }
             vtable_object_ptr = vtable_actual_ptr->functions;
          }
 
          ~dynamic_object()
          {
             for(int i = 0; i < 50; i++)
             {
                if(vtable_mocks[i] != 0)
                   { delete reinterpret_cast<dynamic_vfunction_base*>(vtable_mocks[i]); }
             }
             delete vtable_actual_ptr;
          }
 
          template <typename M>
          dynamic_vfunction<typename remove_member_function_pointer_cv<M>::type>& define_function(M ptr2member)
          {
             int offset = vtable_offset_helper::get(ptr2member);
             if(vtable_mocks[offset] == 0)
             {
                vtable_actual_ptr->functions[offset] = proxy_vfunction_factory<M>::get(ptr2member);
                vtable_mocks[offset] = new dynamic_vfunction<typename remove_member_function_pointer_cv<M>::type>();
             }
             return *reinterpret_cast<dynamic_vfunction<typename remove_member_function_pointer_cv<M>::type>*>(vtable_mocks[offset]);
          }
 
          void missing_vfunction()
             { throw missing_implementation_exception(); }
 
       private:
          dynamic_object(const dynamic_object &);
          dynamic_object &operator=(const dynamic_object &);
       };
    } // namespace detail
 } // namespace mockitopp
 
 #endif //__MOCKITOPP_DYNAMIC_OBJECT_HPP__