WrapperArray.hpp

#pragma once
#include <samchon/protocol/SharedEntityArray.hpp>
#include <samchon/examples/packer/Wrapper.hpp>

#include <samchon/library/FactorialGenerator.hpp>

#include <iostream>

namespace samchon
{
namespace examples
{
namespace packer
{
    using namespace std;

    using namespace library;
    using namespace protocol;

    class WrapperArray
        : public SharedEntityArray<Wrapper>
    {
    private:
        typedef SharedEntityArray<Wrapper> super;

    protected:
        shared_ptr<ProductArray> reserved;

        shared_ptr<Wrapper> sample;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        WrapperArray()
            : super()
        {
            this->reserved = make_shared<ProductArray>();
            this->sample = make_shared<Wrapper>();
        };

        WrapperArray(const string &name, int price, int volume, int weight)
            : super()
        {
            this->reserved = make_shared<ProductArray>();
            this->sample = make_shared<Wrapper>(name, price, volume, weight);
        };


        WrapperArray(const WrapperArray &wrapperArray)
            : super()
        {
            this->reserved = make_shared<ProductArray>();
            this->sample = wrapperArray.sample;
        };

        virtual ~WrapperArray() = default;

        virtual void construct(shared_ptr<XML> xml) override
        {
            super::construct(xml);

            sample->construct(xml);
        };

    protected:
        virtual auto createChild(shared_ptr<XML>) -> Wrapper* override
        {
            return new Wrapper();
        };

    public:
        auto tryInsert(shared_ptr<Product> product) -> bool
        {
            if (product->getVolume() > sample->getVolume() ||
                product->getWeight() > sample->getWeight())
            {
                return false;
            }

            reserved->push_back(product);
            return true;
        };

        /* ---------------------------------------------------------
            OPERATORS
        --------------------------------------------------------- */
        void optimize()
        {
            if(reserved->empty() == true)
                return;

            FactorialGenerator factorial(reserved->size());
            shared_ptr<WrapperArray> minWrapperArray = nullptr;

            for (size_t i = 0; i < factorial.size(); i++)
            {
                shared_ptr<WrapperArray> wrapperArray(new WrapperArray(*this));
                vector<size_t> &row = factorial[i];

                for (size_t j = 0; j < row.size(); j++)
                {
                    shared_ptr<Product> &product = this->reserved->at(row[j]);

                    if (wrapperArray->empty() == true ||
                        wrapperArray->at(wrapperArray->size() - 1)->tryInsert(product) == false)
                    {
                        Wrapper *wrapper = new Wrapper(*this->sample);
                        wrapper->tryInsert(product);

                        wrapperArray->emplace_back(wrapper);
                    }
                }

                //unique_lock<mutex> uk(mtx);
                if (minWrapperArray == nullptr ||
                    wrapperArray->size() < minWrapperArray->size())
                {
                    minWrapperArray = wrapperArray;
                }
            }

            assign(minWrapperArray->begin(), minWrapperArray->end());
        };

        auto calcPrice() const -> int
        {
            return sample->getPrice() * (int)size();
        };

        /* ---------------------------------------------------------
            EXPORT
        --------------------------------------------------------- */
        virtual auto TAG() const -> string override
        {
            return "wrapperArray";
        }
        virtual auto CHILD_TAG() const -> string override
        {
            return "wrapper";
        };

        virtual auto toXML() const -> shared_ptr<XML> override
        {
            shared_ptr<XML> &xml = super::toXML();
            xml->insertAllProperties(sample->toXML());

            return xml;
        };

        auto toString() const -> string
        {
            string str = "Category - " + sample->get_name() + "\n";
            for (size_t i = 0; i < size(); i++)
                str += at(i)->toString() + "\n";

            return str;
        };
    };          
};
};
};