entityops.h

Go to the documentation of this file.

#pragma once

#include "documentoperation.h"
#include <vector>

#include <cad/base/cadentity.h>

namespace lc {
    class Document;
    DECLARE_SHORT_SHARED_PTR(Document)

    namespace operation {
        class Base;
        DECLARE_SHORT_SHARED_PTR(Base)

        class Base {
            public:
                virtual ~Base();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document>,
                    const std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack
                ) = 0;
        };

        class Loop : public Base {
            public:
                Loop(const int numTimes);

                virtual ~Loop();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const Document_SPtr document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

            private:
                int _numTimes;
        };
        DECLARE_SHORT_SHARED_PTR(Loop)

        
        class Begin : public Base {
            public:
                Begin();

                virtual ~Begin();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

                std::vector<entity::CADEntity_CSPtr> getEntities() const;

            private:
                std::vector<entity::CADEntity_CSPtr> _entities;
        };
        DECLARE_SHORT_SHARED_PTR(Begin)

        
        class Move : public Base {
            public:
                Move(const geo::Coordinate& offset);

                virtual ~Move();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

            private:
                geo::Coordinate _offset;
        };
        DECLARE_SHORT_SHARED_PTR(Move)

        
        class Copy : public Base {
            public:
                Copy(const geo::Coordinate& offset);

                virtual ~Copy();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

            private:
                geo::Coordinate
                _offset;
        };
        DECLARE_SHORT_SHARED_PTR(Copy)

        
        class Rotate : public Base {
            public:
                Rotate(const geo::Coordinate& rotation_center, const double rotation_angle);

                virtual ~Rotate();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

            private:

                geo::Coordinate _rotation_center;
                double _rotation_angle;
        };
        DECLARE_SHORT_SHARED_PTR(Rotate)

        class Scale : public Base {
            public:
                Scale(const geo::Coordinate& scale_center, const geo::Coordinate& scale_factor);

                virtual ~Scale();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

            private:
                geo::Coordinate
                _scale_center, _scale_factor;
        };
        DECLARE_SHORT_SHARED_PTR(Scale)

        
        class Push : public Base {
            public:
                Push();

                virtual ~Push();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector<entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);
        };
        DECLARE_SHORT_SHARED_PTR(Push)

        
        class SelectByLayer : public Base {
            public:
                SelectByLayer(const Layer_CSPtr layer);

                virtual ~SelectByLayer();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector <entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

            private:
                Layer_CSPtr _layer;
        };
        DECLARE_SHORT_SHARED_PTR(SelectByLayer)

        
        class Remove : public Base {
            public:
                Remove();

                virtual ~Remove();

                virtual std::vector<entity::CADEntity_CSPtr> process(
                    const std::shared_ptr<Document> document,
                    std::vector<entity::CADEntity_CSPtr> entities,
                    std::vector <entity::CADEntity_CSPtr>& workingBuffer,
                    std::vector<entity::CADEntity_CSPtr>& removals,
                    const std::vector<Base_SPtr> operationStack);

            private:
                Layer_CSPtr _layer;
        };
        DECLARE_SHORT_SHARED_PTR(Remove)
    }
}