Controller.h

Go to the documentation of this file.

#ifndef _CONTROLLER_BASE_H_
#define _CONTROLLER_BASE_H_

#include <iostream>
#include <list>
#include <vector>

class ControllerBase
{
        private :
                ControllerBase *fparent_controller;
                std::string name;

        public :
                ControllerBase() : fparent_controller(0), name("") {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerBase constructor" << std::endl;
#endif
                }
                ControllerBase( ControllerBase *parent, std::string cont_name ) : fparent_controller( parent ), name ( cont_name ) {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerBase constructor with parent " << parent << std::endl;
#endif
                }
                virtual ~ControllerBase() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "controller base destructor " << std::endl;
#endif
                fparent_controller = 0;
                }

                std::string GetName() const {return name;}
                // problem accessing from MainControllerIndicator
                //   - can save specific fparent_controller, but will be hardcoded dependent ??
                //   - can try virtual function, overwritten when needed, if base class enought ok
                ControllerBase * GetParentController() {return fparent_controller;}
                //virtual ControllerBase * GetParentController() {return fparent_controller;}
                // may work, force all to implement, can be in List
                //virtual ControllerBase * GetParentController() =0;

                // needed for GUIMainController, has only base class
                // a very general function to overload
                virtual void Updated( std::vector<std::string> & ) =0;

                //common function, here or in ControllerFrame ??
                //virtual void attach();
                //virtual void detach();

                // needed if object do not derive from List, or force to implement in final object ??
                // but ambiguous ! try overwrite for class without sub-controller
                // no more ambiguous, but called by all
                // try pure virtual, ok working,
                // needed if List calls DeleteList for only BaseClass derived
                // not best, but working, FORCE to overwrite in final class
                //    Coupling but normal because we want different data types in List
                //virtual void DeleteList() =0;
                /* {std::cout << "DeleteList in ControllerBase name " << GetName() << std::endl;} */

                // not logic DeleteList here and in ControllerFrame. Only because MainControllerIndicatorTHStock ??
};

// independent of controller in fact, could be ListComposite ( ListIterative )
template <class T>
class ListController
{
        protected :
                std::list<T *> list_controller;
                typedef typename std::list<T *>::iterator it_list;

                // a current controller useful here, may point to a specific one
                //ControllerBase * fcurrent_controller;

                // could have a template for the parent controller
                // strange coupling between both, or a template class ParentController<T> to derive from...
                // ControllerBase would become a ControllerView with pure virtual implemented in ParentController ??
                // still coupling, would need definition of GUIMainController when instantiating the template.
                // to test

        public :
                ListController() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "list controller constructor" << std::endl;
#endif
                }
                // proper deletion
                virtual ~ListController() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "list controller destructor " << std::endl;
#endif
                }
                void AddController( T * control ) {
                        //std::cout << "ListController::AddController name: " << control->GetName() << std::endl;
                        list_controller.push_back( control );
                }
                // could use list.remove instead
                void RemoveController( T * control ) {
#ifdef DEBUG_CONT_FRAME
                    std::cout << "Entry ListController<T>::RemoveController" << std::endl;
                    std::cout << "size Controller " << list_controller.size() << std::endl;
#endif
                    for ( it_list it = list_controller.begin(); it != list_controller.end(); it++ ) {
                        if ( (*it) == control ) {
#ifdef DEBUG_CONT_FRAME
                            std::cout << "found controller to remove " << std::endl;
#endif
                            list_controller.erase( it );
                            return;
                        }
                    }
                    std::cout << "\n\t Cannot remove from the controller \n" << std::endl;
                }
                // first test, stupid only the first one should improve, certainly not needed
                T * GetController( std::string name) { return list_controller.front(); }
                T * GetFirstController() { return list_controller.front(); }

                virtual void DeleteList( bool call_delete = true ) {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ListController<T>::DeleteList " << list_controller.size() << std::endl;
#endif
                        // delete explicitly all objects before deleting the full list
                        if ( call_delete ) {
                                it_list end = list_controller.end();

                                for ( it_list it = list_controller.begin(); it != end; ++it ) {
                                        // works, compile in test, but very dependent of controller !
                                        std::cout << "Will DeleteList in ListController " << (*it)->GetName() << std::endl;
                                        (*it)->DeleteList();
                                        delete (*it);
                                }
                        }
                        // delete the list
                        list_controller.clear();
                        std::cout << "End Controller::DeleteList " << std::endl;
                }
                //RemoveController ( name and *T ) // could be recursive functions as well
                //GetController ( name and *T ?? )

                virtual unsigned int GetSizeListController() const {return list_controller.size();}
};


template<class T> // =TypeNull, no needed, can derive from BaseController only
class ControllerFrame : public ControllerBase, public ListController<T>
{
        public :
                ControllerFrame() : ControllerBase(), ListController<T>() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerFrame constructor default" << std::endl;
#endif
                }
                ControllerFrame( ControllerBase *parent, std::string name = "") :
                        ControllerBase( parent, name ), ListController<T>() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerFrame constructor" << std::endl;
#endif
                }
                virtual ~ControllerFrame() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerFrame destructor" << std::endl;
#endif
                }

                // can overload GetParentController here ?? we do not have the controller parent...
                // if store a U parent_controller, yes ControllerFrame<parent_type_controller,child_type_controler>
                // practical MyController : public ControllerFrame<GUIMainController,IndicatorTHStockFrameController>
                // with NullType implemented. List maybe valid for a view, ListVieW<THStockFrame>, View has a parent controller by default...

                // can decide of the association with Observer-Subject for message if it limits coupling ( need of Specific controller *.h file in view  )

                // if pure virtual in base class seems necessary
                // but not
                /* virtual void DeleteList() {
                    //ListController<T>::DeleteList();
                        DeleteList();}
                */
};

class NullType
{
};

// re-copy all stuffs ?? yes but will save overloading from all final class
template<>
class ControllerFrame<NullType> : public ControllerBase
{
        public :
                ControllerFrame() : ControllerBase() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerFrame<NullType> constructor default" << std::endl;
#endif
                }
                ControllerFrame( ControllerBase *parent, std::string name = "") :
                        ControllerBase( parent, name ) {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerFrame<NullType> constructor" << std::endl;
#endif
                }
                virtual ~ControllerFrame() {
#ifdef DEBUG_CONT_FRAME
                        std::cout << "ControllerFrame<NullType> destructor" << std::endl;
#endif
                }

                // argument or not, seems working, //( bool call_delete = true )
                virtual void DeleteList( bool call_delete = true ) {
#ifdef DEBUG_CONT_FRAME
                        std::cout <<"ControllerFrame<NullType>::DeleteList" << std::endl;
#endif
                }
};

#endif