// shapeList.h

// Definition of classes ShapePtr and ShapePtrList

// inhomogeneous list for Shape-Objects 



#ifndef SHAPELIST_H

#define SHAPELIST_H



#include <iostream>

using std::cerr;

using std::left;



#include <cstdlib>  // exit()

#include <list>     // class-Template list< T >

                    // T is type of list elements

#include "shape.h"



class ShapePtr

{

private:

   Shape* ptr;

public:

   ShapePtr( Shape* p = NULL ) : ptr( p ) { }  // constructors

   ShapePtr( const ShapePtr& sp ) { ptr = sp->clone(); }



   ~ShapePtr() { delete ptr; }  // destructor



   ShapePtr& operator=( Shape* p )  // assignments

   {

      delete ptr;

      ptr = p->clone();

      return *this;

   }



   ShapePtr& operator=( ShapePtr& a )

   {

      delete ptr;

      ptr = a->clone();

      return *this;

   }



   Shape& operator*() const  // dereferencing

   {

      if( !ptr ) { 

         cerr << "ShapePtr::operator* : Kein Objekt!" << endl;

         exit( 100 );

      }

      return *ptr;

   }



   Shape* operator->() const  // member selection via pointer

   {

      if( !ptr ) { 

         cerr << "ShapePtr::operator-> : Kein Objekt!" << endl;

         exit( 101 );

      }

      return ptr;

   }



   operator Shape*() const { return ptr; }  // cast

};



class ShapePtrList : public std::list< ShapePtr >

{

public:

   void scale( double scalingFactor )

   {

      ShapePtrList::iterator pos;

      for( pos = begin(); pos != end(); ++pos )

         ( *pos )->scale( scalingFactor );

   }



   string toString() const

   {

      stringstream sstream;

      if( empty() )

         sstream << "Die Liste ist leer!"; 

      else {

         ShapePtrList::const_iterator pos;

         for( pos = begin(); pos != end(); ++pos ) {

            sstream.width( 20 );

            sstream << left << typeid( **pos ).name();

            sstream << ( *pos )->toString() << endl;

         }

      }

      return sstream.str();

   }

};



#endif