samchon::example::packer Namespace Reference

A packer with number of wrapper type and products. More...

Classes
class	Instance
	A physical instance. More...
class	Packer
	A packer planning the best packaging. More...
class	Product
	A product, merchandise. More...
class	ProductArray
	An array of Product objects. More...
class	Wrapper
	A wrapper can contain products. More...
class	WrapperArray
	An array of wrapper with same category (name). More...

Detailed Description

A packer with number of wrapper type and products.

Module packer retrieves the solution of packaging by combination permuation and factorial case.

The packer module is built for providing guidance of using entity and case generator module.

Example Sources

Packer.hpp

#pragma once
#include <samchon/protocol/SharedEntityArray.hpp>
#include <samchon/example/packer/WrapperArray.hpp>

#include <samchon/library/CombinedPermutationGenerator.hpp>

#include <iostream>

namespace samchon
{
namespace example
{
namespace packer
{
    using namespace std;

    using namespace library;
    using namespace protocol;

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

    protected:
        shared_ptr<ProductArray> productArray;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        Packer()
            : super()
        {
            this->productArray = make_shared<ProductArray>();
        };

        Packer(shared_ptr<ProductArray> productArray)
            : super()
        {
            this->productArray = productArray;
        };

        Packer(const Packer &packer)
            : Packer(packer.productArray)
        {
            this->reserve(packer.size());

            for (size_t i = 0; i < packer.size(); i++)
                this->emplace_back(new WrapperArray(*packer[i]));
        };

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

            productArray->construct(xml->get(productArray->TAG())->at(0));
        };

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

    public:
        /* ---------------------------------------------------------
            GETTERS
        --------------------------------------------------------- */
        auto productSize() const -> size_t
        {
            return productArray->size();
        };

        auto calcPrice() const -> int
        {
            int price = 0;
            for (size_t i = 0; i < size(); i++)
                price += at(i)->calcPrice();

            return price;
        };

        /* ---------------------------------------------------------
            OPERATORS
        --------------------------------------------------------- */
        void optimize(size_t start = 0, size_t size = -1)
        {
            if(empty() == true || productArray->empty() == true)
                return;

            CombinedPermutationGenerator caseGenerator(this->size(), productArray->size());
            shared_ptr<Packer> minPacker = nullptr;

            if (size == -1 || start + size > caseGenerator.size())
                size = caseGenerator.size() - start;

            for (size_t i = start; i < start + size; i++)
            {
                vector<size_t> &row = caseGenerator[i];
                shared_ptr<Packer> packer(new Packer(*this));

                bool validity = true;

                for (size_t j = 0; j < row.size(); j++)
                {
                    shared_ptr<Product> &product = productArray->at(j);
                    shared_ptr<WrapperArray> &wrapperArray = packer->at( row[j] );

                    if (wrapperArray->tryInsert(product) == false)
                    {
                        validity = false;
                        break;
                    }
                }

                if(validity == false)
                    continue;

                //OPTIMIZE ALL WRAPPERS IN A PACKER
                for (size_t j = 0; j < packer->size(); j++)
                    packer->at(j)->optimize();

                if (minPacker == nullptr ||
                    packer->calcPrice() < minPacker->calcPrice())
                {
                    minPacker = packer;
                }
            }

            //COPY
            assign(minPacker->begin(), minPacker->end());
        };

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

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

            return xml;
        };

        auto toString() const -> string
        {
            string str = "$" + to_string(calcPrice()) + "\n";
            for (size_t i = 0; i < size(); i++)
                str += at(i)->toString() + "\n";

            return str;
        };

        /* ---------------------------------------------------------
            MAIN
        --------------------------------------------------------- */
        static void main()
        {
            // CONSTRUCT PRODUCTS
            shared_ptr<ProductArray> productArray(new ProductArray());
            productArray->emplace_back(new Product("Eraser", 500, 10, 70));
            productArray->emplace_back(new Product("Pencil", 400, 30, 35));
            /*productArray->emplace_back(new Product("Pencil", 400, 30, 35));
            productArray->emplace_back(new Product("Pencil", 400, 30, 35));
            productArray->emplace_back(new Product("Book", 8000, 150, 300));*/
            productArray->emplace_back(new Product("Book", 8000, 150, 300));
            productArray->emplace_back(new Product("Drink", 1000, 75, 250));
            productArray->emplace_back(new Product("Umbrella", 4000, 200, 1000));
            productArray->emplace_back(new Product("Notebook-PC", 800000, 150, 850));
            productArray->emplace_back(new Product("Tablet-PC", 600000, 120, 450));

            // CONSTRUCT PACKER
            Packer packer(productArray);
            packer.emplace_back(new WrapperArray("Large", 100, 200, 1000));
            packer.emplace_back(new WrapperArray("Medium", 70, 150, 500));
            packer.emplace_back(new WrapperArray("Small", 50, 100, 250));

            // OPTIMIZE
            packer.optimize();

            // PRINT
            cout << packer.toString();
        };
    };          
};
};
};

WrapperArray.hpp

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

#include <samchon/library/FactorialGenerator.hpp>

#include <iostream>

namespace samchon
{
namespace example
{
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->addAllProperty(sample->toXML());

            return xml;
        };

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

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

Wrapper.hpp

#pragma once
#include <samchon/example/packer/ProductArray.hpp>
#include <samchon/example/packer/Instance.hpp>

namespace samchon
{
namespace example
{
namespace packer
{
    using namespace std;

    using namespace library;
    using namespace protocol;

    class Wrapper
        : public ProductArray,
        public Instance
    {
    private:
        typedef ProductArray super;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        Wrapper()
            : super(),
            Instance()
        {
        };

        Wrapper(const string &name, int price, int volume, int weight)
            : super(),
            Instance(name, price, volume, weight)
        {
        };

        Wrapper(const Wrapper &wrapper)
            : super(),
            Instance(wrapper)
        {
        };

        virtual ~Wrapper() = default;

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

    public:
        auto tryInsert(shared_ptr<Product> product) -> bool
        {
            int volume = 0;
            int weight = 0;

            for (size_t i = 0; i < size(); i++)
            {
                volume += at(i)->getVolume();
                weight += at(i)->getWeight();
            }

            if (product->getVolume() + volume > this->volume || 
                product->getWeight() + weight > this->weight)
            {
                return false;
            }

            push_back(product);
            return true;
        };

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

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

            return xml;
        };

        virtual auto toString() const -> string override
        {
            string str = "\tWrapper " + Instance::toString() + "\n";
            for (size_t i = 0; i < size(); i++)
                str += "\t\t" + at(i)->toString() 
                + ((i == size() - 1) ? "" : "\n");

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

Product.hpp

#pragma once
#include <samchon/example/packer/Instance.hpp>

namespace samchon
{
namespace example
{
namespace packer
{
    using namespace std;

    using namespace library;
    using namespace protocol;

    class Product
        : public Instance
    {
    private:
        typedef Instance super;

    public:
        /* ---------------------------------------------------------
        CONSTRUCTOR
        --------------------------------------------------------- */
        Product()
            : super()
        {
        };

        Product(const string &name, int price, int volume, int weight)
            : super(name, price, volume, weight)
        {
        };

        virtual ~Product() = default;

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

        virtual auto toString() const -> string override
        {
            return "Product " + super::toString();
        };
    };          
};
};
};

Instance.hpp

#pragma once
#include <samchon/protocol/Entity.hpp>

#include <samchon/library/StringUtil.hpp>
#include <samchon/library/XML.hpp>

namespace samchon
{
namespace example
{
namespace packer
{
    using namespace std;

    using namespace library;
    using namespace protocol;

    class Instance
        : public virtual Entity
    {
    private:
        typedef Entity super;

    protected:
        string name;

        int price;

        int volume;

        int weight;

    public:
        /* ---------------------------------------------------------
            CONSTRUCTORS
        --------------------------------------------------------- */
        Instance()
            : super()
        {
        };

        Instance(const string &name, int price, int volume, int weight)
            : super()
        {
            this->name = name;
            this->price = price;
            this->volume = volume;
            this->weight = weight;
        };

        virtual ~Instance() = default;

        virtual void construct(shared_ptr<XML> xml) override
        {
            this->name = xml->getProperty("name");
            this->price = xml->getProperty<int>("price");
            this->volume = xml->getProperty<int>("volume");
            this->weight = xml->getProperty<int>("weight");
        };

        /* ---------------------------------------------------------
            GETTERS
        --------------------------------------------------------- */
        auto getName() const -> string
        {
            return name;
        };

        auto getPrice() const -> int
        {
            return price;
        };

        auto getVolume() const -> int
        {
            return volume;
        };

        auto getWeight() const -> int
        {
            return weight;
        };

        /* ---------------------------------------------------------
            EXPORT
        --------------------------------------------------------- */
        virtual auto toXML() const -> shared_ptr<XML> override
        {
            shared_ptr<XML> &xml = super::toXML();
            xml->setProperty("name", name);
            xml->setProperty("price", price);
            xml->setProperty("volume", volume);
            xml->setProperty("weight", weight);

            return xml;
        };

        virtual auto toString() const -> string
        {
            return StringUtil::substitute
                (
                    "{1}: ${2}, {3}cm^3, {4}g",
                    name, price, volume, weight
                    );
        };
    };          
};
};
};

Result of the example

See also

protocol::Entity

library::CaseGenerator

Author

Jeongho Nam http://samchon.org