Null_Object.h

Go to the documentation of this file.

 
 
#pragma once
#ifndef __NULL_OBJECT_H__
#define __NULL_OBJECT_H__
 
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
#include "helpers/formatstring.h"
 
namespace DesignPatternExamples_cpp
{
 
    class MoveCommand
    {
    public:
        using shared_ptr_t = std::shared_ptr<MoveCommand>;
 
    private:
        std::string _name;
 
        std::string _command;
 
    public:
        virtual ~MoveCommand() { }
 
        std::string Name()
        {
            return _name;
        }
 
        std::string Command()
        {
            return _command;
        }
 
 
        MoveCommand(std::string command, std::string commandName)
            : _name(commandName)
            , _command(command)
        {
        }
 
 
        virtual void Show()
        {
            std::cout
                << Helpers::formatstring("    '%s' -> %s", _command.c_str(), _name.c_str())
                << std::endl;
        }
 
 
        virtual void Execute() = 0;
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class MoveCommandLeft : public MoveCommand
    {
    public:
        MoveCommandLeft(std::string command) : MoveCommand(command, "Left")
        {
        }
 
 
        void Execute() override
        {
            std::cout << "move left";
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class MoveCommandRight : public MoveCommand
    {
    public:
        MoveCommandRight(std::string command) : MoveCommand(command, "Right")
        {
        }
 
 
        void Execute() override
        {
            std::cout << "move right";
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class MoveCommandUp : public MoveCommand
    {
    public:
        MoveCommandUp(std::string command) : MoveCommand(command, "Up")
        {
        }
 
 
        void Execute() override
        {
            std::cout << "move up";
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class MoveCommandDown : public MoveCommand
    {
    public:
        MoveCommandDown(std::string command) : MoveCommand(command, "Down")
        {
        }
 
 
        void Execute() override
        {
            std::cout << "move down";
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class MoveCommandNone : public MoveCommand
    {
    public:
        MoveCommandNone(std::string command) : MoveCommand(command, "None")
        {
        }
 
 
        void Execute() override
        {
        }
    };
 
 
    //########################################################################
    //########################################################################
 
 
    class MoveProcessor
    {
    private:
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Private methods.
 
        std::vector<MoveCommand::shared_ptr_t> _ParseMoves(std::string moveList)
        {
            std::vector<MoveCommand::shared_ptr_t> commands;
            for (size_t index = 0; index < moveList.size(); index++)
            {
                char commandChar = static_cast<char>(std::toupper(moveList[index]));
                std::string command(1, commandChar);
                MoveCommand::shared_ptr_t moveCommand;
 
                switch (commandChar)
                {
                    case 'U':
                        moveCommand = std::make_shared<MoveCommandUp>(command);
                        break;
 
                    case 'D':
                        moveCommand = std::make_shared<MoveCommandDown>(command);
                        break;
 
                    case 'L':
                        moveCommand = std::make_shared<MoveCommandLeft>(command);
                        break;
 
                    case 'R':
                        moveCommand = std::make_shared<MoveCommandRight>(command);
                        break;
 
                    default:
                        // Everything else is a "do nothing" command.
                        moveCommand = std::make_shared<MoveCommandNone>(command);
                        break;
                }
                commands.push_back(moveCommand);
            }
 
            return commands;
        }
 
 
        void _ExecuteMoves(const std::vector<MoveCommand::shared_ptr_t>& commands)
        {
            for(MoveCommand::shared_ptr_t command : commands)
            {
                std::cout << "<";
                command->Execute();
                std::cout << "> ";
            }
            std::cout << std::endl;
        }
 
 
        void _ShowMoves(const std::vector<MoveCommand::shared_ptr_t>& commands)
        {
            for (MoveCommand::shared_ptr_t command : commands)
            {
                command->Show();
            }
        }
 
    public:
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Public methods.
 
        void ExecuteMoveList(std::string moveList)
        {
            std::vector<MoveCommand::shared_ptr_t> commands = _ParseMoves(moveList);
            _ExecuteMoves(commands);
        }
 
 
        void ShowMoveList(std::string moveList)
        {
            std::vector<MoveCommand::shared_ptr_t> commands = _ParseMoves(moveList);
            _ShowMoves(commands);
        }
    };
 
} // end namespace
 
#endif // __NULL_OBJECT_H__