main.cpp

[詳解]

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   main.cpp                                           :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: kamitsui <kamitsui@student.42tokyo.jp>     +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2025/05/29 23:19:21 by kamitsui          #+#    #+#             */
/*   Updated: 2025/06/06 12:27:51 by kamitsui         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */
 
#include "AMateria.hpp"
#include "Character.hpp"
#include "Cure.hpp"
#include "DroppedMateriaManager.hpp"
#include "ICharacter.hpp"
#include "IMateriaSource.hpp"
#include "Ice.hpp"
#include "Logger.hpp"
#include "MateriaSource.hpp"
#include "ScopedPointer.hpp"
#include <cstdlib> // For EXIT_FAILURE
 
// Forward declarations for helper functions
#ifdef DEBUG_MODE
static int testBasicRaii(void);
static int testCharacterInventoryLimits(DroppedMateriaManager *droppedManager);
static int testMateriaSourceLimits();
static void testCharacterDeepCopy(DroppedMateriaManager *droppedManager);
static void testCharacterDeepCopyAssignment(DroppedMateriaManager *droppedManager);
#endif
 
int main() {
    IMateriaSource *src = new MateriaSource();
    src->learnMateria(new Ice());
    src->learnMateria(new Cure());
 
    ICharacter *me = new Character("me");
 
    AMateria *tmp;
    tmp = src->createMateria("ice");
    me->equip(tmp);
    tmp = src->createMateria("cure");
    me->equip(tmp);
 
    ICharacter *bob = new Character("bob");
 
    me->use(0, *bob);
    me->use(1, *bob);
 
    delete bob;
    delete me;
    delete src;
 
#ifdef DEBUG_MODE
 
    // Create instance DroppedMateriaManager
    // This is the specific substance of the "system for managing dropped Materia.
    DroppedMateriaManager droppedManager;
 
    std::cout << "\n--- More Tests ---" << std::endl;
    testBasicRaii();
    testCharacterInventoryLimits(&droppedManager);
    testMateriaSourceLimits();
    testCharacterDeepCopy(&droppedManager);
    testCharacterDeepCopyAssignment(&droppedManager);
 
    droppedManager.displayDroppedMaterias(); // display current Dropped Mateias.
    // don't have to call delete ( Because the destructor automatically calls clearAll().)
#endif // DEBUG_MODE
 
    return 0;
}
 
// --- Helper Function Implementations ---
 
#ifdef DEBUG_MODE
static int testBasicRaii(void) {
    LOG_INFO("--- Test Basic with ScopedPointer ---");
 
    // ScopedPointer is placed on the stack and is automatically released when exiting scope.
    ScopedPointer<IMateriaSource> src;
    ScopedPointer<ICharacter> me;
    ScopedPointer<ICharacter> bob;
 
    try {
        // Create Instance of IMateriaSource
        src.reset(new MateriaSource()); // If new fails, throw bad_alloc
 
        // Learn Materia : Materia *m->clone() and delete m are performed.
        src->learnMateria(new Ice());
        src->learnMateria(new Cure());
 
        // I think better code support Owner Ship.
        //  It is desirable that the implementation of ‘new Icd()’ passed as an argument be owned by the caller.
        // The code example is as follows.
        //  (however, this approach is not required for the assignment, so it will not be used).
        // ******* example code ***********
        // ScopedPointer<AMateria> ice_to_learn(new Ice());   // If new Ice() failed throw bad_alloc
        // ScopedPointer<AMateria> cure_to_learn(new Cure()); // If new Cure() failed throw bad_alloc
        // if (src.get()) {
        //    src->learnMateria(ice_to_learn.get()); // learnMateria does not take ownership
        //    src->learnMateria(cure_to_learn.get());
        //}
        // *******  code end    ***********
        // ice_to_learn and cure_to_learn are automatically released when exiting the scope.
        // If learnMateria takes ownership (does not delete internally), it must be passed in release().
        // current design: learnMateria clones, so passed materia is caller's responsibility.
 
        // Create Instance ICharacter.(me's interface)
        me.reset(new Character("me")); // If new Character() fails, throw bad_alloc.
 
        // Creating and equipping Materia
        if (src.get() && me.get()) {
            AMateria *tmp = 0;
 
            tmp = src->createMateria("ice");
            if (tmp)
                me->equip(tmp);
 
            tmp = src->createMateria("cure");
            if (tmp)
                me->equip(tmp);
        }
 
        // Creating another ICharacter.(bob's interface)
        bob.reset(new Character("bob"));
 
        // Using Materia
        if (me.get() && bob.get()) {
            me->use(0, *bob);
            me->use(1, *bob);
        }
 
        // No explicit delete required.
        // delete bob;
        // delete me;
        // delete src;
 
    } catch (const std::bad_alloc &e) {
        LOG_ERROR("Memory allocation failed! " + std::string(e.what()));
        // The destructor of the ScopedPointer is automatically called to ensure
        // that the memory already allocated is freed.
        return EXIT_FAILURE;
    } catch (const std::exception &e) {
        LOG_ERROR("An unexpected standard error occurred: " + std::string(e.what()));
        return EXIT_FAILURE;
    } catch (...) {
        LOG_ERROR("An unknown error occurred.");
        return EXIT_FAILURE;
    }
 
    // When the main function exits, the ScopedPointer objects of src, me, and bob exit scope.
    // At that time, the respective destructor is called and the internal heap memory is released.
    LOG_INFO("--- Program finished with ScopedPointer ---");
    return 0;
}
 
static int testCharacterInventoryLimits(DroppedMateriaManager *droppedManager) {
    LOG_INFO("\n--- Testing Character Inventory Limits ---");
 
    // Automatically manage resources using ScopedPointer
    // Even if new fails, the destructor of ScopedPointer is called
    // Error handling when allocation fails can also be captured with Try-Catch
    ScopedPointer<ICharacter> alice;
    ScopedPointer<IMateriaSource> src;
    ScopedPointer<ICharacter> bob;
 
    try {
        alice.reset(new Character("alice"));
        src.reset(new MateriaSource());
 
        if (src.get()) {
            src->learnMateria(new Ice());
            src->learnMateria(new Cure());
        }
 
        // --- fill the inventory ---
        if (alice.get() && src.get()) {
            AMateria *tmp = 0;
 
            tmp = src->createMateria("ice");
            if (tmp)
                alice->equip(tmp);
 
            tmp = src->createMateria("cure");
            if (tmp)
                alice->equip(tmp);
 
            tmp = src->createMateria("ice");
            if (tmp)
                alice->equip(tmp);
 
            tmp = src->createMateria("cure");
            if (tmp)
                alice->equip(tmp);
        }
 
        // --- Attempt to equip a full inventory ---
        if (alice.get()) {
            // The materia created with new Ice() here is deleted within equip
            // (assumed implementation of Character::equip).
            alice->equip(new Ice());
        }
 
        // --- Use of Tests ---
        bob.reset(new Character("bob"));
 
        if (alice.get() && bob.get()) {
            alice->use(0, *bob);
            alice->use(1, *bob);
            alice->use(2, *bob);
            alice->use(3, *bob);
            alice->use(4, *bob); // Invalid index
        }
 
        // --- Removing and dropping Materia ---
        // getMateriaAtSlot does not transfer ownership, so
        // the return value AMateria* unequipped_raw_ptr must be managed separately.
        AMateria *unequipped_raw_ptr = 0;
        if (alice.get()) {
            unequipped_raw_ptr = alice->getMateriaAtSlot(1); // get pointer
            alice->unequip(1);                               // remove from inventory
        }
 
        // Add discarded materia to the dropped manager.
        // droppedManager->addMateria takes ownership (or deletes if it cannot be managed).
        if (droppedManager && unequipped_raw_ptr) {
            droppedManager->addMateria(unequipped_raw_ptr);
        } else if (unequipped_raw_ptr) {
            // If there is no drop manager, release it yourself (exceptional but safe).
            LOG_WARNING("No droppedManager or null materia. Deleting unequipped materia directly.");
            delete unequipped_raw_ptr;
        }
 
    } catch (const std::bad_alloc &e) {
        LOG_ERROR("Memory allocation failed in testCharacterInventoryLimits! " + std::string(e.what()));
        return EXIT_FAILURE;
    } catch (const std::exception &e) {
        LOG_ERROR("An unexpected standard error occurred in testCharacterInventoryLimits: " + std::string(e.what()));
        return EXIT_FAILURE;
    } catch (...) {
        LOG_ERROR("An unknown error occurred in testCharacterInventoryLimits.");
        return EXIT_FAILURE;
    }
    return 0;
}
 
static int testMateriaSourceLimits() {
    LOG_INFO("\n--- Testing MateriaSource Learning Limits ---");
 
    // IMateriaSource と ICharacter は ScopedPointer で管理
    ScopedPointer<IMateriaSource> src;
    ScopedPointer<ICharacter> me;
 
    try {
        src.reset(new MateriaSource());
 
        // Teach Materia to MateriaSource
        // ScopedPointer is not necessary, because learnMateria internally deletes the argument materia.
        if (src.get()) {
            src->learnMateria(new Ice());
            src->learnMateria(new Cure());
            src->learnMateria(new Ice());
            src->learnMateria(new Cure());
        }
        std::cout << ">> MateriaSource should now be full <<" << std::endl;
 
        // Attempting to learn more with a full MateriaSource
        // Here, new is also deleted within learnMateria.
        if (src.get()) {
            src->learnMateria(new Ice());
        }
 
        // Creating ICharacter
        me.reset(new Character("me"));
 
        // Creating and equipping learned Materia
        if (src.get() && me.get()) {
            AMateria *tmp = 0;
 
            tmp = src->createMateria("ice");
            if (tmp)
                me->equip(tmp);
 
            tmp = src->createMateria("cure");
            if (tmp)
                me->equip(tmp);
        }
 
        // Test creating unknown Materia (should return NULL)
        // new is not performed, so ScopedPointer is not necessary.
        if (src.get() && me.get()) {
            AMateria *tmp_unknown = 0;
 
            tmp_unknown = src->createMateria("fire");
            if (tmp_unknown == 0) {
                LOG_INFO("Successfully tried to create unknown materia 'fire', returned NULL.");
            } else {
                LOG_ERROR("Creating unknown materia 'fire' returned non-NULL. Leaking materia.");
                delete tmp_unknown;
            }
        }
 
    } catch (const std::bad_alloc &e) {
        LOG_ERROR("Memory allocation failed in testMateriaSourceLimits! " + std::string(e.what()));
        return EXIT_FAILURE;
    } catch (const std::exception &e) {
        LOG_ERROR("An unexpected standard error occurred in testMateriaSourceLimits: " + std::string(e.what()));
        return EXIT_FAILURE;
    } catch (...) {
        LOG_ERROR("An unknown error occurred in testMateriaSourceLimits.");
        return EXIT_FAILURE;
    }
 
    LOG_INFO("--- Testing MateriaSource Learning Limits finished ---");
    std::cout << std::endl;
    return 0;
}
 
static void testCharacterDeepCopy(DroppedMateriaManager *droppedManager) {
 
    // --- Copy Constructor Test ---
    std::cout << "\n--- Testing Deep Copy of Character ---" << std::endl;
    Character charlie("charlie");
    charlie.equip(new Ice());
    charlie.equip(new Cure());
 
    Character charlie_copy(charlie); // Test copy constructor
 
    // Verify initial state and that equipping in original doesn't affect copy
    std::cout << "Charlie's first materia type: " << charlie.getName() << " has "
              << (charlie.isMateriaEquipped(0) ? charlie.getMateriaAtSlot(0)->getType() : "nothing") << " at slot 0"
              << std::endl;
    std::cout << "Charlie's copy's first materia type: " << charlie_copy.getName() << " has "
              << (charlie_copy.isMateriaEquipped(0) ? charlie_copy.getMateriaAtSlot(0)->getType() : "nothing")
              << " at slot 0" << std::endl;
 
    AMateria *unequipped = charlie_copy.getMateriaAtSlot(0); // Get pointer before unequip
    charlie_copy.unequip(0);                                 // Modify the copy (unequip materia in slot 0)
    droppedManager->addMateria(unequipped);                  // Drop Materia
 
    // Original should be unchanged, demonstrating deep copy
    std::cout << "After unequipping copy, Charlie's first materia type: " << charlie.getName() << " has "
              << (charlie.isMateriaEquipped(0) ? charlie.getMateriaAtSlot(0)->getType() : "nothing") << " at slot 0"
              << std::endl;
    std::cout << "Charlie's copy's first materia type: " << charlie_copy.getName() << " has "
              << (charlie_copy.isMateriaEquipped(0) ? charlie_copy.getMateriaAtSlot(0)->getType() : "nothing")
              << " at slot 0" << std::endl;
}
 
static void testCharacterDeepCopyAssignment(DroppedMateriaManager *droppedManager) {
 
    // --- Copy Assignment Operator Test ---
    std::cout << "\n--- Testing Deep Copy Assignment of Character ---" << std::endl;
    Character david("david");
    david.equip(new Ice());
    Character david_assigned("initial"); // Has initial state
    david_assigned = david;              // Use copy assignment operator
 
    // Verify initial state after assignment
    std::cout << "David's first materia type: " << david.getName() << " has "
              << (david.isMateriaEquipped(0) ? david.getMateriaAtSlot(0)->getType() : "nothing") << " at slot 0"
              << std::endl;
    std::cout << "David's assigned's first materia type: " << david_assigned.getName() << " has "
              << (david_assigned.isMateriaEquipped(0) ? david_assigned.getMateriaAtSlot(0)->getType() : "nothing")
              << " at slot 0" << std::endl;
 
    AMateria *unequipped = david_assigned.getMateriaAtSlot(0); // Get pointer before unequip
    david_assigned.unequip(0);                                 // Modify the assigned copy
    droppedManager->addMateria(unequipped);                    // Drop Materia
    std::cout << "After unequipping assigned, David's first materia type: " << david.getName() << " has "
              << (david.isMateriaEquipped(0) ? david.getMateriaAtSlot(0)->getType() : "nothing") << " at slot 0"
              << std::endl;
    std::cout << "David's assigned's first materia type: " << david_assigned.getName() << " has "
              << (david_assigned.isMateriaEquipped(0) ? david_assigned.getMateriaAtSlot(0)->getType() : "nothing")
              << " at slot 0" << std::endl;
}
#endif // DEBUG_MODE