#factorypattern

JavaScript Factory Pattern: Concepts, Benefits, and Implementation

JavaScript Factory Pattern: Concepts, Benefits, and Implementation

Learn about the JavaScript Factory Pattern, a design pattern used to create objects without specifying their exact class. Discover how this pattern promotes code flexibility, reuse, and modularity, and explore practical examples to enhance your JavaScript applications.

Introduction

Design Patterns represent solutions to problems what arise when developing software within a particular context.

Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.

Basically, there are three categories:

Creational Patterns: deal with initializing and configuring classes and objects

Structural Patterns: deal with decoupling the interface and implementation of classes and objects

Behavioral Patterns: deal with dynamic interactions among societies of classes and objects

Intent

creates objects without exposing the instantiation logic to the client.

refers to the newly created object through a common interface

Implementation

The implementation is really simple

The client needs a product, but instead of creating it directly using the new operator, it asks the factory object for a new product, providing the information about the type of object it needs.

The factory instantiates a new concrete product and then returns to the client the newly created product(casted to abstract product class).

The client uses the products as abstract products without being aware about their concrete implementation.

Applicability & Examples

Probably the factory pattern is one of the most used patterns.

For example a graphical application works with shapes. In our implementation the drawing framework is the client and the shapes are the products. All the shapes are derived from an abstract shape class (or interface). The Shape class defines the draw and move operations which must be implemented by the concrete shapes. Let's assume a command is selected from the menu to create a new Circle. The framework receives the shape type as a string parameter, it asks the factory to create a new shape sending the parameter received from menu. The factory creates a new circle and returns it to the framework, casted to an abstract shape. Then the framework uses the object as casted to the abstract class without being aware of the concrete object type.

 The advantage is obvious: New shapes can be added without changing a single line of code in the framework(the client code that uses the shapes from the factory). As it is shown in the next sections, there are certain factory implementations that allow adding new products without even modifying the factory class.

Look at the following example in C++:

Abstract Interface Class:

struct IAutoMobile  {    virtual bool Register(const std::string& RegistrationNumber) = 0;        virtual VehicleType GetType() = 0;    virtual VehicleColor GetColor() = 0;  };

Specific Implementation Class(es)

class CCar:public IAutoMobile  {  public:    CCar(const VehicleSpecification& VSpecs);        virtual bool Register(const std::string& RegistrationNumber);    virtual VehicleType GetType(){ return m_VehicleType;}    virtual VehicleColor GetColor(){return m_VehicleColor;}      virtual ~CCar();      private:    VehicleType m_VehicleType;    VehicleColor m_VehicleColor;    bool m_fRegistered;    std::string m_RegistrationNumber;  };

CCar::CCar(const VehicleSpecification& VSpecs)  {    m_VehicleType = VehicleType::CAR;    m_VehicleColor = VSpecs.Color;    m_fRegistered = false;  }  bool CCar::Register(const std::string& RegistrationNumber)  {    m_RegistrationNumber = RegistrationNumber;    m_fRegistered = true;    return true;  }

Factory Class Declaration

class CVehicleFactory  {  public:    static IAutoMobile* GetVehicle(const VehicleSpecification& VSpecs);  private:    //Lock-Down un-wanted stuff/Don't let this class to be initiated    CVehicleFactory();    CVehicleFactory(CVehicleFactory& CloneObj);    CVehicleFactory& operator=(CVehicleFactory& CloneObj);  };

IAutoMobile* CVehicleFactory::GetVehicle(const VehicleSpecification& VSpecs)  {         IAutoMobile *pAutoMobile = nullptr;

         if(VSpecs.Type == VehicleType::CAR ){

                  pAutoMobile = new CCar(VSpecs);

          }

          return pAutoMobile;

Why?

ArcObjects: Beating the dead IHorseFactory

It probably isn't necessary to go out and start ripping on ArcObjects. Every indication is that AO is on its way out the door - a new .NET native client was previewed at the Devsummit that isn't supposed to replace ArcObjects but really does. Even if that didn't exist, the use cases for ArcObjects have been progressively chipped away at by an expanding Python site package (arcpy) and an increasing emphasis on doing all communication via HTTP.

But it doesn't matter. ArcObjects exists, it's pretty irritating, and I'm hoping to find it cathartic to whine about it.

What's a constructor?

Want an FeatureClass object? Of course you do. It's like the thing you basically always want. Well there are a few ways to get one, and all of them are terrible. You might be under the impression you could just do something like this:

FeatureClass fc = new FeatureClass(aPathName);

Think again. There are almost no actual constructors in ArcObjects. Everything is pulled as a reference to the current application or through some Factory methods. Speaking of which...

IFactoryFactory factory = (IFactoryFactory)AnotherFactory.Create()

Little more needs to be said about this that wasn't said here. That FeatureClass you wanted? Here's how to get it.

ESRI.ArcGIS.Geodatabase.IWorkspaceFactory workspaceFactory = new ESRI.ArcGIS.DataSourcesFile.ArcInfoWorkspaceFactoryClass(); ESRI.ArcGIS.Geodatabase.IWorkspace workspace = workspaceFactory.OpenFromFile(databaseOrDirectory, 0); ESRI.ArcGIS.Geodatabase.IFeatureWorkspace featureWorkspace = (ESRI.ArcGIS.Geodatabase.IFeatureWorkspace)workspace; ESRI.ArcGIS.Geodatabase.IFeatureDataset featureDataset = featureWorkspace.OpenFeatureDataset(featureClassName); ESRI.ArcGIS.Geodatabase.IFeatureClass fc = (IFeatureClass)featureDataset;

Unless you wanted to go through an attached application. Then you have more options. Which brings me to my next point.

All the options in the world, none of them good.

You can get a FeatureClass object using the above, or by grabbing selected objects out of ArcMap itself, or via the table of context or by the ffffffffuuuuuuuuu

Maybe it is the Python guy in me, but if you have one relatively good way of doing things, a convention if you will, it helps maintenance, readability, and guides new programmers to proper practices. And the GIS/spatial dev field is awash in new programmers - many who are just new to spatial stuff and a whole lot that are new to software development in general.

The FeatureClass thing might be forgivable if it wasn't part of a pattern. Do you want to look up the features in a feature class with IEnumFeature OR IFeatureCursor? Wait, why are we writing up iterators like this?

Oh, .NET has a standard library? Full of data structures?

List, HashSet, Dictionary. These things work, people like them, and they are build in. Cool stuff like LINQ extends them and builds in all sorts of powerful features. People shouldn't have to find themselves doing this:

public static IEnumerable Features(IFeatureCursor featureEnum) { IFeature f = featureEnum.NextFeature(); while (f != null) { yield return f; f = featureEnum.NextFeature(); } }

Or variants on that theme. Making a commercial application SDK easier to use and integrate it with the platform you've chosen is really your job.