MSLang.h

Go to the documentation of this file.

#ifndef MSLANG_H
#define MSLANG_H

#include "Utilities/MSLang/BoundingBox2D.h"
#include "Utilities/MSLang/AffineTransformation.h"
#include "Algorithms/Vektor.h"

#include <string>
#include <iostream>
#include <fstream>
#include <list>
#include <memory>

namespace mslang {
    typedef std::string::iterator iterator;

    inline
    double euclidean_norm2D(Vector_t v) {
        v[2] = 0.0;
        return euclidean_norm(v);
    }

    struct Base;

    struct Function {
        virtual ~Function() {};

        virtual void print(int indent) = 0;
        virtual void apply(std::vector<std::shared_ptr<Base>> &bfuncs) = 0;

        static bool parse(iterator &it, const iterator &end, Function* &fun);

        static const std::string UDouble;
        static const std::string Double;
        static const std::string UInt;
        static const std::string FCall;
    };

    struct Base: public Function {
        AffineTransformation trafo_m;
        BoundingBox2D bb_m;
        std::vector<std::shared_ptr<Base> > divisor_m;

        Base():
            trafo_m()
        { }

        Base(const Base &right):
            trafo_m(right.trafo_m),
            bb_m(right.bb_m)
        { }

        virtual ~Base() {
            // for (auto item: divisor_m) {
            //     item.reset();
            // }
            divisor_m.clear();
        }

        virtual std::shared_ptr<Base> clone() const = 0;
        virtual void writeGnuplot(std::ofstream &out) const = 0;
        virtual void computeBoundingBox() = 0;
        virtual bool isInside(const Vector_t &R) const = 0;
        virtual void divideBy(std::vector<std::shared_ptr<Base> > &divisors) {
            for (auto item: divisors) {
                if (bb_m.doesIntersect(item->bb_m)) {
                    divisor_m.emplace_back(item->clone());
                }
            }
        }
    };

    bool parse(std::string str, Function* &fun);
}

#endif