Implementation of Visitor Pattern

Let's recall the retail shopping example discussed earlier. In a retail shopping application, there are various types of products like Food, Clothing, and Electronics. The application frequently needs to apply different discount strategies to these products, particularly during different seasons or events. For instance, there may be a clearance sale during the end of the season or a holiday discount during Christmas.

Let's look at the pseudocode of this example:

// Visitor Interface
interface DiscountVisitor {
    visitFood(Food food)
    visitClothing(Clothing clothing)
    visitElectronics(Electronics electronics)
}

// Concrete Visitors
class HolidayDiscountVisitor implements DiscountVisitor {
    visitFood(food) {
        // Apply holiday discount logic for food
    }
    visitClothing(clothing) {
        // Apply holiday discount logic for clothing
    }
    visitElectronics(electronics) {
        // Apply holiday discount logic for electronics
    }
}

class ClearanceDiscountVisitor implements DiscountVisitor {
    visitFood(food) {
        // Apply clearance discount logic for food
    }
    visitClothing(clothing) {
        // Apply clearance discount logic for clothing
    }
    visitElectronics(electronics) {
        // Apply clearance discount logic for electronics
    }
}

// Element Interface
interface Product {
    accept(DiscountVisitor visitor)
}

// Concrete Elements
class Food implements Product {
    accept(visitor) {
        visitor.visitFood(this)
    }
}

class Clothing implements Product {
    accept(visitor) {
        visitor.visitClothing(this)
    }
}

class Electronics implements Product {
    accept(visitor) {
        visitor.visitElectronics(this)
    }
}

// Usage
food = new Food()
clothing = new Clothing()
electronics = new Electronics()

holidayVisitor = new HolidayDiscountVisitor()
clearanceVisitor = new ClearanceDiscountVisitor()

// Applying different discounts
food.accept(holidayVisitor)
clothing.accept(clearanceVisitor)
electronics.accept(holidayVisitor)

1. Visitor Interface (DiscountVisitor): This defines a contract for the visitors, listing methods for each type of visitable element (in this case, different product types).
2. Concrete Visitors (HolidayDiscountVisitor, ClearanceDiscountVisitor): Implementations of the visitor interface, each encapsulating the logic for a specific type of discount (e.g., holiday, clearance). Each visitor knows how to apply its discount to different product types.
3. Element Interface (Product): Defines an interface for elements that can be visited. The key method here is accept, which takes a visitor as an argument.
4. Concrete Elements (Food, Clothing, Electronics): These are the actual objects to which we want to apply operations (discounts, in this case). Each element implements the accept method to allow a visitor to perform an operation on it.
5. Usage: To apply a discount, you create an instance of a visitor (e.g., HolidayDiscountVisitor) and pass it to the accept method of a product. The visitor then applies the appropriate logic based on the type of product.

Implementation