Can I use dynamic_cast conversion with proxy?

[xuruilong100]

Can I use dynamic_cast conversion with proxy? How can I convert a proxy<Base> object to a Derived ptr?

[mingxwa]

@xuruilong100 Thanks for asking. dynamic_cast is not directly supported by proxy. Although it might be useful in debugging, using it in production code is usually considered a bad practice (see some interesting discussions here). Therefore, we decided not to prioritize this feature over performance by default.

However, it can be implemented with custom reflection if you really need. For example:

#include <iostream>
#include <typeinfo>

#include "proxy.h"

class RttiReflector {
 public:
  template <class T>
  constexpr explicit RttiReflector(std::in_place_type_t<T>) : type_(typeid(T)) {}

  template <class F, class R>
  struct accessor {
    const std::type_info& GetType() const noexcept {
      const RttiReflector& self = pro::proxy_reflect<R>(pro::access_proxy<F>(*this));
      return self.type_;
    }
  };

 private:
  const std::type_info& type_;
};

struct Castable : pro::facade_builder
    ::add_convention<pro::operator_dispatch<"&">, void*() noexcept>
    ::add_reflection<RttiReflector>
    ::build {};

template <class T, class F>
T* proxy_cast(pro::proxy<F>& p) {
  return p->GetType() == typeid(T) ? static_cast<T*>(&*p) : nullptr;
}

struct Stringable : pro::facade_builder
    ::add_facade<Castable>
    ::add_convention<pro::operator_dispatch<"<<", true>, std::ostream&(std::ostream&) const>
    ::build {};

int main() {
  int v = 123;
  pro::proxy<Stringable> p = &v;
  std::cout << *p << "\n";  // prints: "123"
  double* pd = proxy_cast<double>(p);
  std::cout << std::boolalpha << (pd != nullptr) << "\n";  // prints: "false"
  int* pi = proxy_cast<int>(p);
  std::cout << (pi != nullptr) << "\n";  // prints: "true"
  v = 456;
  std::cout << *pi << "\n";  // prints: "456"
}

Note that the code above uses some accessibility features in the upcoming 3.1 release. To compile it, you need to download the latest proxy.h from main branch. It is also feasible to write equivalent code with the current proxy 3.0 but less concise. Please let me know if you have any further questions.

[xuruilong100]

Thank you.

In fact I'm trying to use proxy to replace std::shared_ptr in my legacy codes, but I use dynamic_pointer_cast somewhere. So, I think dynamic_cast should be a necessary part of proxy, if proxy want to be a rival of std::shared_ptr.

[mingxwa]

@xuruilong100 Thank you for the clarification. I think your scenario is a valid one, since this may become a blocker for people who want to port their existing dynamic_cast code to proxy-style. I tried to explore this area and implemented proxy_cast and proxy_typeid on my dev branch (not fully tested yet). With this feature, it should become easier to opt-in RTTI for whatever reason.

You can simply grab the "proxy.h" file from my branch, and use it like:

#include <iostream>

#include "proxy.h"

struct RttiAware : pro::facade_builder
    ::add_convention<pro::proxy_cast_dispatch, void(pro::proxy_cast_context)>  // For proxy_cast()
    ::add_reflection<pro::proxy_typeid_reflector>  // For proxy_typeid()
    ::build {};

int main() {
  int a = 123;
  pro::proxy<RttiAware> p = &a;
  std::cout << proxy_cast<int>(*p) << "\n";  // Prints: "123"
  proxy_cast<int&>(*p) = 456;
  std::cout << a << "\n";  // Prints: "456"

  std::cout << proxy_typeid(*p).name() << "\n";  // Prints: "i" (assuming GCC)
  p.reset();
  std::cout << proxy_typeid(*p).name() << "\n";  // Prints: "v" (assuming GCC)
}

Your feedback is much appreciated! Please feel free to share any thoughts you may have on this. 😄

[xuruilong100]

Hi, I start a new project about proxy.

But compiler tells me that there is bug in

auto turkeyAdapter = pro::make_proxy<Duck, TurkeyAdapter>(turkey);
// error : no matching constructor for initialization of 'proxy<Duck>'

Can you help me?

[mingxwa]

@xuruilong100 Looks like Duck requires copyability, but TurkeyAdapter's copy constructor is deleted. I can compile the code by changing the delete to default.

[xuruilong100]

Thank you, it works!

I'm coding Bridge pattern now, the original code:

std::vector<RemoteControl*> remotes;

std::shared_ptr<SonyControl> sonyControl(new SonyControl("XBR in living room"));
remotes.push_back(sonyControl.get());

So, we can put a Derived ptr into a container of Base ptr. Can we do the same thing by proxy?

BTW, are there docs about the difference and similarity between proxy and smart ptr?