visitor

In this question it is said I can use visitor pattern instead of a bunch of instanceof s. Jmg said "If you are not free to change A, B, and C, you could apply the visitor pattern to achieve the same." As far as I understand I still have to make A, B and C support visitor (have an accept() method, for example). My problem is I have absolutely no possibility to change A, B and C. I just get the Car object from the foreign library and have to call wash() method specific for trucks, race cars and buses. I think I still need an if-else-if construction with instanceof s. Am I right? Yes, to

I am able to access an existing session outside of Magento perfectly fine using the popular method below. require 'app/Mage.php'; $mageRunCode = isset ( $_SERVER ['MAGE_RUN_CODE'] ) ? $_SERVER ['MAGE_RUN_CODE'] : ''; $mageRunType = isset ( $_SERVER ['MAGE_RUN_TYPE'] ) ? $_SERVER ['MAGE_RUN_TYPE'] : 'store'; $app = Mage::app ( $mageRunCode, $mageRunType ); Mage::getSingleton ( 'core/session', array ('name' => 'frontend' ) ); This works great, but how do I actually create a Magento session outside of Magento that would populate the log_url, log_visitor, etc. tables as well as assigning the

can anyone show example code before and after to avoid down casting for visitor pattern code ? Thanks. A bare, minimalistic example. Before class Base {}; class Derived1 : public Base {}; class Derived2 : public Base {}; // Some arbitrary function that handles Base. void Handle(Base& obj) { if (...type is Derived1...) { Derived1& d1 = static_cast<Derived1&>(base); std::printf("Handling Derived1\n"); } else if (...type is Derived2...) { Derived2& d2 = static_cast<Derived2&>(base); std::printf("Handling Derived2\n"); } } This means Base must have some type tag field, or you will be using dynamic

I've been trying to reduce the amount of boilerplate in my code, by using C++ Templates to implement the visitor pattern. So far I've come up with this: class BaseVisitor { public: virtual ~BaseVisitor() {} }; template<typename T> class Visitor : public BaseVisitor { public: virtual void visit(T& /* visitable */) = 0; }; template<typename Derived> class Visitable { public: void accept(Visitor<Derived>& visitor) { visitor.visit(static_cast<Derived&>(*this)); } }; And each subclass of Visitable looks like this: class Mesh : public Object, public Visitable<Mesh> {}; class Text : public Object,

I want to inline visitation of variant types with lambdas. At the moment i have the following code: struct Foo { boost::variant< boost::blank , int , string , vector< int > > var; template <typename T, typename IL , typename SL , typename VL> void ApplyOptionals( T& ref, IL&& intOption , SL&& stringOption , VL&& vectorOption ) { if (var.which() == 1) { intOption( ref , boost::get< int >(var) ); } else if (var.which() ==2) { stringOption( ref , boost::get< string>(var) ); } else if (var.which() == 3) { vectorOption( ref , boost::get< vector< int > >(var) ); } }; }; // ... myFooV.ApplyOptionals(

There is a lot of talk on decoupling the algorithms from the classes. But, one thing stays aside not explained. They use visitor like this abstract class Expr { public <T> T accept(Visitor<T> visitor) {visitor.visit(this);} } class ExprVisitor extends Visitor{ public Integer visit(Num num) { return num.value; } public Integer visit(Sum sum) { return sum.getLeft().accept(this) + sum.getRight().accept(this); } public Integer visit(Prod prod) { return prod.getLeft().accept(this) * prod.getRight().accept(this); } Instead of calling visit(element) directly, Visitor asks the element to call its