Visitor_Element_Classes.cs

Go to the documentation of this file.

 
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace DesignPatternExamples_csharp
{
 
    public class Visitor
    {
        public virtual void VisitRestaurant(Visitor_Restaurant shop) { }
 
        public virtual void VisitButcher(Visitor_Butcher shop) { }
 
        public virtual void VisitBaker(Visitor_Baker shop) { }
 
        public virtual void VisitVegetableGrocer(Visitor_VegetableGrocer shop) { }
 
        public virtual void VisitCondimentGrocer(Visitor_CondimentGrocer shop) { }
 
        public virtual void VisitPickleGrocer(Visitor_PickleGrocer shop) { }
 
        public virtual void VisitMaker(Visitor_Maker shop) { }
 
    }
 
    public interface ISupportVisitors
    {
        void Accept(Visitor visitor);
    }
 
    public abstract class Visitor_Shop
    {
        private Dictionary<string, int> Inventory = new Dictionary<string, int>();
 
        public string Name = string.Empty;
 
        public string Address = string.Empty;
 
        public Village Village = new Village();
 
        //-------------------------------------------------------------------
 
        public Dictionary<string, string[]> IngredientsForItems = new Dictionary<string, string[]>();
 
 
        bool DoesShopSellItem(string item)
        {
            return IngredientsForItems.ContainsKey(item);
        }
 
        bool IsItemInStock(string item)
        {
            return Inventory.ContainsKey(item) && Inventory[item] > 0;
        }
 
        void AddItemToInventory(string item)
        {
            if (!Inventory.ContainsKey(item))
            {
                Inventory.Add(item, 1);
            }
            else
            {
                Inventory[item]++;
            }
        }
 
        string StringizeList(string[] items)
        {
            StringBuilder output = new StringBuilder();
 
            foreach(string item in items)
            {
                if (output.Length > 0)
                {
                    output.Append(", ");
                }
                output.Append(item);
            }
            return output.ToString();
        }
 
        bool AreListContentsTheSame(string[] left, string[] right)
        {
            bool matched = false;
 
            if (left.Length == right.Length)
            {
                matched = true;
                foreach (string item in left)
                {
                    if (!right.Contains(item))
                    {
                        matched = false;
                        break;
                    }
                }
            }
            return matched;
        }
 
        public bool PlaceOrder(string[] items)
        {
            bool orderPlaced = false;
            List<string> outOfStockItems = new List<string>();
            List<string> itemsInThisShop = new List<string>();
            
            foreach (string item in items)
            {
                if (DoesShopSellItem(item))
                {
                    if (!IsItemInStock(item))
                    {
                        outOfStockItems.Add(item);
                    }
                    itemsInThisShop.Add(item);
                }
            }
 
            if (itemsInThisShop.Count > 0)
            {
                Console.WriteLine("  {0}: Received an order for {1}.", Name, StringizeList(itemsInThisShop.ToArray()));
                orderPlaced = true;
            }
            if (outOfStockItems.Count > 0)
            {
                foreach (string itemToOrder in outOfStockItems)
                {
                    if (IngredientsForItems[itemToOrder].Length > 0)
                    {
                        Console.WriteLine("  {0}:   {1} out of stock, ordering ingredients to make more...", Name, itemToOrder);
                        OrderVisitor visitor = new OrderVisitor(IngredientsForItems[itemToOrder]);
                        Village.Accept(visitor);
                        if (AreListContentsTheSame(visitor.ItemsReceived.ToArray(), IngredientsForItems[itemToOrder]))
                        {
                            // verify the ingredients received matches the
                            // ingredients needed.  Only then add 1 to the
                            // inventory.
                            AddItemToInventory(itemToOrder);
                        }
                    }
                    else
                    {
                        // The ordered item has no ingredients so the
                        // ordered item will be magically added to inventory
                        Console.WriteLine("  {0}:   {1} out of stock, making...", Name, itemToOrder);
                        AddItemToInventory(itemToOrder);
                    }
                }
            }
            return orderPlaced;
        }
 
        public void PickupOrder(string[] items, List<string> itemsToBePickedUp)
        {
            foreach (string item in items)
            {
                // If this shop sells the item and the item is in stock then
                if (DoesShopSellItem(item))
                {
                    if (IsItemInStock(item))
                    {
                        itemsToBePickedUp.Add(item);
                    }
                    else
                    {
                        Console.WriteLine("  Error!  {0}: Item {1} is not in the inventory when it should be.", Name, item);
                    }
                }
            }
 
            if (itemsToBePickedUp.Count > 0)
            {
                // Reduce inventory for the ordered items
                StringBuilder output = new StringBuilder();
                foreach (string itemToBePickedUp in itemsToBePickedUp)
                {
                    if (DoesShopSellItem(itemToBePickedUp))
                    {
                        if (output.Length > 0)
                        {
                            output.Append(", ");
                        }
                        output.Append(itemToBePickedUp);
                        Inventory[itemToBePickedUp]--;
                    }
                }
                Console.WriteLine("  {0}: Order picked up for {1}.", Name, output.ToString());
            }
        }
 
        public abstract void Accept(Visitor visitor);
    }
 
 
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
 
 
    public class Visitor_Restaurant : Visitor_Shop
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitRestaurant(this);
        }
    }
 
 
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
 
 
    public class Visitor_Butcher : Visitor_Shop
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitButcher(this);
        }
    }
 
 
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
 
 
    public class Visitor_Baker : Visitor_Shop
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitBaker(this);
        }
    }
 
 
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
 
 
    public class Visitor_VegetableGrocer : Visitor_Shop
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitVegetableGrocer(this);
        }
    }
 
 
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
 
 
    public class Visitor_CondimentGrocer : Visitor_Shop
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitCondimentGrocer(this);
        }
    }
 
 
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
 
 
    public class Visitor_PickleGrocer : Visitor_Shop
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitPickleGrocer(this);
        }
    }
 
 
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
 
 
    public class Visitor_Maker : Visitor_Shop
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitMaker(this);
        }
    }
}