class Shape;

    typedef std::unique_ptr<Shape> shape_ptr;

    class Shape{

        public:
            Shape(){};
            virtual ~Shape(){};

            virtual void draw() const = 0;
            virtual float area() const = 0;

            virtual shape_ptr clone() const = 0;
            virtual shape_ptr create() const = 0;
    };

    class Rectangle:public Shape{
        public:

            Rectangle(int height=0, int width=0):m_Height(height),m_Width(width){};
            ~Rectangle(){};

            virtual void draw() const;
            virtual float area() const;

            virtual shape_ptr clone() const{ return shape_ptr(new Rectangle(*this)); };
            virtual shape_ptr create() const{ return shape_ptr(new Rectangle()); };

        private:
            int m_Height;
            int m_Width;
    };


    class Circle:public Shape{
        public:

            Circle(float radius=0):m_Radius(radius){};
            ~Circle(){};

            virtual void draw() const;
            virtual float area() const;

            virtual shape_ptr clone() const{ return shape_ptr(new Circle(*this)); };
            virtual shape_ptr create() const{ return shape_ptr(new Circle()); };

        private:
            float m_Radius;
    };

    class ShapeContainer{

        public:

            typedef std::unique_ptr<Shape> ShapePtr;
            typedef std::vector<ShapePtr> ShapePtrContainer;

            ShapeContainer(){};
            ShapeContainer( ShapeContainer && );
            ShapeContainer( const ShapeContainer & );
            ~ShapeContainer(){};

            const ShapePtr & at(int ) const;

            ShapeContainer & operator = (ShapeContainer&&);
            int size() const{ return static_cast<int>(m_vect.size()); };

            friend ShapeContainer createBasicShapes();
            friend ShapeContainer createComplexShapes();

            friend void swap(ShapeContainer& x, ShapeContainer& y) {x.m_vect.swap(y.m_vect);}

        private:

            ShapePtrContainer m_vect;
    };

    class FooObj{

        public:

            FooObj(){};
            FooObj ( FooObj && );
            FooObj( const ShapeContainer & );
            FooObj ( const FooObj & );
            ~FooObj(){};

            FooObj & operator = (FooObj && );

            void drawShapes() const;


        private:
            ShapeContainer m_container;
    };

    class FooRef{

        public:

            typedef std::unique_ptr<ShapeContainer> uptr;

            FooRef(){};
            FooRef( const ShapeContainer & );
            FooRef( const FooRef & );
            ~FooRef(){};

            FooRef & operator = (const FooRef & );

            void drawShapes() const;

        private:
            uptr m_container;

    };

    void Rectangle::draw() const{
        std::cout << "draw rectangle at address: " << this << std::endl;
    }

    float Rectangle::area() const{
        float area = static_cast<float>(m_Height*m_Width);
        std::cout << "this is the Rectangle's area: " << area << std::endl;
        return area;
    }

    void Circle::draw() const{
        std::cout << "draw circle at address: " << this << std::endl;
    }

    float Circle::area() const{
        float area = static_cast<float>(m_Radius*2*3.1415);
        std::cout << "this is the Circle's area: " << area << std::endl;
        return area;
    }

    ShapeContainer::ShapeContainer(ShapeContainer && other)
        :m_vect(std::move(other.m_vect))
    {

    }

    ShapeContainer & ShapeContainer::operator = (ShapeContainer&& other){
        m_vect = std::move(other.m_vect);
        return (*this);
    }

    ShapeContainer::ShapeContainer( const ShapeContainer & other ){
        for(int i=0; i<(int)other.m_vect.size(); i++){
            m_vect.push_back(other.m_vect[i]->clone());
        }
    }

    ShapeContainer createBasicShapes(){
        ShapeContainer cont;
        cont.m_vect.push_back(ShapeContainer::ShapePtr(new Circle()));
        cont.m_vect.push_back(ShapeContainer::ShapePtr(new Rectangle()));
        return cont;
    }

    ShapeContainer createComplexShapes(){
        ShapeContainer cont;
        cont.m_vect.push_back(ShapeContainer::ShapePtr(new Rectangle()));
        return cont;
    }

    const ShapeContainer::ShapePtr & ShapeContainer::at( int index ) const{
        return m_vect[index];
    }

    FooObj::FooObj( const ShapeContainer & cont )
        :m_container(cont)
    {

    }

    FooObj::FooObj( const FooObj & other)
        :m_container(other.m_container)
    {

    }

    FooObj & FooObj::operator = ( FooObj && other ){
        m_container = std::move(other.m_container);
        return (*this);
    }

    void FooObj::drawShapes() const{

        for(int i=0; i < m_container.size(); i++){
            m_container.at(i)->draw();
        }
    }

    FooRef::FooRef( const ShapeContainer & shapec )
        :m_container( uptr(new ShapeContainer(shapec)))
    {

    }

    void FooRef::drawShapes() const{

        for(int i=0; i < m_container->size(); i++){
            m_container->at(i)->draw();
        }
    }

    int main(int argc, char ** argv){

        ShapeContainer mycontainer = createBasicShapes();
        cout << "hi" << endl;

        FooObj myfoo(createBasicShapes());
        myfoo.drawShapes();

        FooObj myfoo2 = myfoo;
        myfoo2.drawShapes();

        return (EXIT_SUCCESS);

    }