I think using a function is fine. The more interesting question is how do you determine which registrar to load? One option is to have an abstract base Registrar class which concrete implementations subclass, then iterate over its __subclasses__() calling an is_registrar_for() class method: class Registrar(object): def __init__(self, domain): self.domain = domain class RegistrarA(Registrar): @classmethod … Read more
You could implement the Visitor pattern. Detailed Answer The idea is to use polymorphism to perform the type-checking. Each subclass overrides the accept(Visitor) method, which should be declared in the superclass. When we have a situation like: void add(Vehicle vehicle) { //what type is vehicle?? } We can pass an object into a method declared … Read more
That may happen if your webapp’s runtime classpath is polluted with multiple JSF impls/versions. The org.apache.myfaces entries in the stack trace tells that you’re using MyFaces. This problem thus suggests that you’ve another JSF implementation like Mojarra in the webapp’s runtime classpath which is conflicting with it. It’s recognizable by jsf-api.jar, or jsf-impl.jar, or javax.faces.jar. … Read more
With the Factory pattern, you produce instances of implementations (Apple, Banana, Cherry, etc.) of a particular interface — say, IFruit. With the Abstract Factory pattern, you provide a way for anyone to provide their own factory. This allows your warehouse to be either an IFruitFactory or an IJuiceFactory, without requiring your warehouse to know anything … Read more
Here’s a little trick I’m using lately and brings good results. I would like to share with those who have to fight often with VBA. 1.- Implement a public initiation subroutine in each of your custom classes. I call it InitiateProperties throughout all my classes. This method has to accept the arguments you would like … Read more
I don’t think using __new__() to do what you want is improper. In other words, I disagree with the accepted answer to this question which claims factory functions are always the “best way to do it”. If you really want to avoid using it, then the only options are metaclasses or a separate factory function/method … Read more
I like thinking about design pattens in terms of my classes being ‘people,’ and the patterns are the ways that the people talk to each other. So, to me the factory pattern is like a hiring agency. You’ve got someone that will need a variable number of workers. This person may know some info they … Read more
All three Factory types do the same thing: They are a “smart constructor”. Let’s say you want to be able to create two kinds of Fruit: Apple and Orange. Factory Factory is “fixed”, in that you have just one implementation with no subclassing. In this case, you will have a class like this: class FruitFactory … Read more
Okay, here’s a list of things to look into: 1) If you’re not running a webserver of any kind and just testing with file://index.html, then you’re probably running into same-origin policy issues. See: https://code.google.com/archive/p/browsersec/wikis/Part2.wiki#Same-origin_policy Many browsers don’t allow locally hosted files to access other locally hosted files. Firefox does allow it, but only if the … Read more
Nope, there is none, unless you do the mapping yourself. C++ has no mechanism to create objects whose types are determined at runtime. You can use a map to do that mapping yourself, though: template<typename T> Base * createInstance() { return new T; } typedef std::map<std::string, Base*(*)()> map_type; map_type map; map[“DerivedA”] = &createInstance<DerivedA>; map[“DerivedB”] = … Read more