MSLang.h

Go to the documentation of this file.

#ifndef MSLANG_H
#define MSLANG_H
 
#include "Utilities/MSLang/AffineTransformation.h"
#include "Utilities/MSLang/BoundingBox2D.h"
 
#include <fstream>
#include <iostream>
#include <list>
#include <memory>
#include <string>
 
namespace mslang {
    typedef std::string::iterator iterator;
 
    inline double euclidean_norm2D(Vector_t<double, 3> 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<double, 3>& 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);
}  // namespace mslang
 
#endif