Travel.hpp

#pragma once
#include <samchon/protocol/SharedEntityArray.hpp>
#include <samchon/examples/tsp/GeometryPoint.hpp>

namespace samchon
{
namespace examples
{
namespace tsp
{
    using namespace std;

    using namespace library;
    using namespace protocol;

    class Travel
        : public SharedEntityArray<GeometryPoint>
    {
    private:
        typedef SharedEntityArray<GeometryPoint> super;

    protected:
        double distance;

    public:
        /* -----------------------------------------------------------
            CONSTRUCTORS
        ----------------------------------------------------------- */
        Travel()
            : super()
        {
            distance = INT_MIN;
        };

        Travel(const Travel &travel)
            : super(travel)
        {
            distance = INT_MIN;
        };

        Travel(Travel &&travel)
            : super(move(travel))
        {
            distance = travel.distance;
        };

        virtual ~Travel() = default;

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

            if (xml->hasProperty("distance") == true)
                distance = xml->getProperty<double>("distance");
            else
                distance = INT_MIN;
        };

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

        /* -----------------------------------------------------------
            CALCULATORS
        ----------------------------------------------------------- */
    public:
        auto calcDistance() const -> double
        {
            if(this->distance != INT_MIN)
                return this->distance;

            double distance = 0.0;
            for(size_t i = 1; i < size(); i++)
                distance += at(i-1)->calcDistance(*at(i));

            ((Travel*)this)->distance = distance;
            return distance;
        };

    public:
        auto operator<(const Travel &travel) const -> bool
        {
            return this->calcDistance() < travel.calcDistance();
        };

        /* -----------------------------------------------------------
            EXPORTER
        ----------------------------------------------------------- */
        virtual auto TAG() const -> string override
        {
            return "travel";
        };
        virtual auto CHILD_TAG() const -> string override
        {
            return "point";
        };

        virtual auto toXML() const -> shared_ptr<XML> override
        {
            shared_ptr<XML> &xml = super::toXML();
            if (distance != INT_MIN)
                xml->setProperty("distance", distance);

            return xml;
        };

        auto toString() const -> string
        {
            string str =
                "Distance: " + StringUtil::numberFormat(calcDistance()) + " km\n" + 
                "uid    longitude   latitude\n";

            for(size_t i = 0; i < size(); i++)
                str += at(i)->toString() + "\n";

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