visitor pattern

Comment

0

10. Visitor Pattern:
The Visitor pattern represents an operation to be performed on elements of an object structure. It lets you define a new operation without changing the classes of the elements on which it operates.

Example in React:
Suppose you have a list of elements in your React app, and you want to apply different visitors to them.

import React, { useState } from 'react';

// Visitors
const squareVisitor = (element) => {
  return element * element;
};

const doubleVisitor = (element) => {
  return element * 2;
};

// Component
const VisitorPatternExample = () => {
  const [elements, setElements] = useState([1, 2, 3, 4, 5]);
  const [result, setResult] = useState([]);

  const applyVisitor = (visitor) => {
    const visitedElements = elements.map((element) => visitor(element));
    setResult(visitedElements);
  };

  return (
    <div>
      <p>Original Elements: {elements.join(', ')}</p>
      <button onClick={() => applyVisitor(squareVisitor)}>Square</button>
      <button onClick={() => applyVisitor(doubleVisitor)}>Double</button>
      <p>Result: {result.join(', ')}</p>
    </div>
  );
};

export default VisitorPatternExample;

Popularity 9/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: javascript visitor-pattern

Share

Link to this answer
Share Copy Link

Contributed on Sep 21 2023

Amjad Saeed

0 Answers Avg Quality 2/10

visitor pattern

Comment

1

namespace Wikipedia;

public class ExpressionPrintingVisitor
{
    public void PrintLiteral(Literal literal)
    {
        Console.WriteLine(literal.Value);
    }
    
    public void PrintAddition(Addition addition)
    {
        double leftValue = addition.Left.GetValue();
        double rightValue = addition.Right.GetValue();
        var sum = addition.GetValue();
        Console.WriteLine("{0} + {1} = {2}", leftValue, rightValue, sum);
    }
}

public abstract class Expression
{    
    public abstract void Accept(ExpressionPrintingVisitor v);
    
    public abstract double GetValue();
}

public class Literal : Expression
{
    public double Value { get; set; }

    public Literal(double value)
    {
        this.Value = value;
    }
    
    public override void Accept(ExpressionPrintingVisitor v)
    {
        v.PrintLiteral(this);
    }
    
    public override double GetValue()
    {
        return Value;
    }
}

public class Addition : Expression
{
    public Expression Left { get; set; }
    public Expression Right { get; set; }

    public Addition(Expression left, Expression right)
    {
        Left = left;
        Right = right;
    }
    
    public override void Accept(ExpressionPrintingVisitor v)
    {
        Left.Accept(v);
        Right.Accept(v);
        v.PrintAddition(this);
    }
    
    public override double GetValue()
    {
        return Left.GetValue() + Right.GetValue();    
    }
}

public static class Program
{
    public static void Main(string[] args)
    {
        // Emulate 1 + 2 + 3
        var e = new Addition(
            new Addition(
                new Literal(1),
                new Literal(2)
            ),
            new Literal(3)
        );
        
        var printingVisitor = new ExpressionPrintingVisitor();
        e.Accept(printingVisitor);
    }
}

Popularity 10/10 Helpfulness 2/10 Language csharp

Source: en.wikipedia.org

Tags: c# c

Share

Link to this answer
Share Copy Link

Contributed on Jun 12 2022

Pamela Soucre

0 Answers Avg Quality 2/10

visitor pattern

Comment

0

/**
 * The client code.
 */
public class VisitorDemo {
    public static void main(String[] args) {
        Element elementA = new ConcreteElementA(10);
        Element elementB = new ConcreteElementB(20);
        SumVisitor visitor = new SumVisitor();
        elementA.accept(visitor);
        elementB.accept(visitor);
        int total = visitor.getTotal();
        System.out.println("Total: " + total);  // Outputs "Total: 30"
    }
}

/**
 * The base element interface.
 */
public interface Element {
    /**
     * Accepts a visitor.
     * @param visitor the visitor to accept
     */
    void accept(Visitor visitor);
    
    /**
     * Returns the element's value.
     * @return the element's value
     */
    int getValue();
}

/**
 * The base visitor interface.
 */
public interface Visitor {
    /**
     * Visits a concrete element.
     * @param element the element to visit
     */
    void visit(ConcreteElementA element);
    
    /**
     * Visits another concrete element.
     * @param element the element to visit
     */
    void visit(ConcreteElementB element);
}

package com.patterns.visitor;

/**
 * A concrete element implementation.
 */
public class ConcreteElementA implements Element {
    private int value;
    
    public ConcreteElementA(int value) {
        this.value = value;
    }
    
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    
    @Override
    public int getValue() {
        return value;
    }
}

/**
 * Another concrete element implementation.
 */
public class ConcreteElementB implements Element {
    private int value;
    
    public ConcreteElementB(int value) {
        this.value = value;
    }
    
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    
    @Override
    public int getValue() {
        return value;
    }
}

/**
 * A concrete visitor implementation that adds the element's value to a running total.
 */
public class SumVisitor implements Visitor {
    private int total;
    
    @Override
    public void visit(ConcreteElementA element) {
        total += element.getValue();
    }
    
    @Override
    public void visit(ConcreteElementB element) {
        total += element.getValue();
    }
    
    public int getTotal() {
        return total;
    }
}

Popularity 10/10 Helpfulness 1/10 Language java

Source: chat.openai.com

Tags: java

Share

Link to this answer
Share Copy Link

Contributed on Dec 23 2022

Gary Larson

0 Answers Avg Quality 2/10

visitor pattern

Contents

More Related Answers

visitor pattern

Closely Related Answers

visitor pattern

visitor pattern

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.