visitor

Let's imagine I have a collection of nodes that I use for my Renderer class later on. Then I have a Visitor class that can visit node or whole collection. It's simple because my collection of nodes it's simply a wrapper to the std::list with few extra methods. The problem is I'd like to have a tree like structure for nodes(instead of simple list) so a node can have a parent and n children. That would be handy as I'd like to be able to pass to my Renderer a node and render everything "below" that node. The answer probably is Composite. How can I use together Visitor and Composite? I've read

In a typical implementation of the Visitor pattern, the class must account for all variations (descendants) of the base class. There are many instances where the same method content in the visitor is applied to the different methods. A templated virtual method would be ideal in this case, but for now, this is not allowed. So, can templated methods be used to resolve virtual methods of the parent class? Given (the foundation): struct Visitor_Base; // Forward declaration. struct Base { virtual accept_visitor(Visitor_Base& visitor) = 0; }; // More forward declarations struct Base_Int; struct Base

In a previous job, my manager suggested use of a Translator pattern for converting data from a DataTable to objects. Basically, the Translator class had only static (i.e. class) methods so it was an aggregation of function calls. My initial approach was to implement constructors for each object that could take a DataTable row as an argument and create an instance that corresponded to the data. He said that the Translator class had been suggested by Microsoft, and provided better modularity of code. I can see this point, but at the same time it seems like a very non-OO approach (although the

Ok before marking this as a duplicate let me clarify myself. I'm reading about the visitor pattern and its applicable uses. I've stumbled upon this post: When should I use the Visitor Design Pattern? and the user who wrote the first answer says as follow : Now we want to add a new operation to the hierarchy, namely we want each animal to make its sound. As far as the hierarchy is this simple, you can do it with straight polymorphism: ... But proceeding in this way, each time you want to add an operation you must modify the interface to every single class of the hierarchy. Now, I mostly see why

here is a simplified implementation of the visitor pattern in C++. Ist it possible to implement something like this in Python? I need it, because I will pass Objects from C++ code to a function in Python. My idea was to implement a visitor in Python to find out the type of the Object. My C++ code: #include <iostream> #include <string> class t_element_base { public: virtual void accept( class t_visitor &v ) = 0; }; class t_element_deriv_one: public t_element_base { public: void accept( t_visitor &v ); std::string t_element_deriv_one_text() { return "t_element_deriv_one"; } }; class t_element