Changeset 20356

Show
Ignore:
Timestamp:
06/27/07 10:59:28 (1 year ago)
Author:
patrick
Message:

I have determined that it is not necessary for subclasses of
gadget::Input to override operator delete or use the destroy() template
method in order for driver object deletion to work correctly on Windows.
I am not sure that this was ever necessary given the way that driver
instances are allocated, but I have only tested it on this branch.

Bumped the Gadgeteer version to 1.3.11.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • juggler/trunk/modules/gadgeteer/ChangeLog

    r20351 r20356  
    11DATE        AUTHOR      CHANGE 
    22----------- ----------- ------------------------------------------------------- 
     3Jun-27-2007 patrick     Removed the need for overriding operator delete in 
     4                        subclasses of gadget::Input. 
     5                        NEW VERSION: 1.3.11 
    36Jun-26-2007 patrick     Changed the preprocessor identification of debug versus 
    47                        optimized to look for GADGET_DEBUG or JUGGLER_DEBUG 

  • juggler/trunk/modules/gadgeteer/VERSION

    r20351 r20356  
     11.3.11-0 @06/27/2007 16:00:00 UTC@ 
    121.3.10-0 @06/26/2007 23:10:00 UTC@ 
    231.3.9-0 @06/26/2007 02:20:00 UTC@ 

  • juggler/trunk/modules/gadgeteer/drivers/3Dconnexion/SpaceBall/puck_device.h

    r20307 r20356  
    855855    //@} 
    856856 
    857    /** 
    858     * Invokes the global scope delete operator.  This is required for proper 
    859     * releasing of memory in DLLs on Win32. 
    860     */ 
    861    void operator delete(void* p) 
    862    { 
    863       ::operator delete(p); 
    864    } 
    865  
    866857  protected: 
    867    /** 
    868     * Deletes this object.  This is an implementation of the pure virtual 
    869     * gadget::Input::destroy() method. 
    870     */ 
    871    virtual void destroy() 
    872    { 
    873       delete this; 
    874    } 
    875  
    876858    /** Debugging helper functions. 
    877859     */ 

  • juggler/trunk/modules/gadgeteer/drivers/5DT/DataGlove/DataGlove.h

    r20307 r20356  
    6868   virtual void updateData (); 
    6969 
    70    /** 
    71     * Invokes the global scope delete operator.  This is required for proper 
    72     * releasing of memory in DLLs on Win32. 
    73     */ 
    74    void operator delete(void* p) 
    75    { 
    76       ::operator delete(p); 
    77    } 
    78  
    7970protected: 
    80    /** 
    81     * Deletes this object.  This is an implementation of the pure virtual 
    82     * gadget::Input::destroy() method. 
    83     */ 
    84    virtual void destroy() 
    85    { 
    86       delete this; 
    87    } 
    88  
    8971   /** The main control loop for the object. */ 
    9072   void controlLoop(); 

  • juggler/trunk/modules/gadgeteer/drivers/ART/DTrack/DTrack.h

    r20307 r20356  
    6969        virtual void updateData(); 
    7070 
    71         /** 
    72          * Invokes the global scope delete operator.  This is required for proper 
    73          * releasing of memory in DLLs on Win32. 
    74          */ 
    75         void operator delete(void* p) 
    76         { 
    77                 ::operator delete(p); 
    78         } 
    79  
    80  
    81 protected: 
    82         /** 
    83          * Deletes this object.  This is an implementation of the pure virtual 
    84          * gadget::Input::destroy() method. 
    85          */ 
    86         virtual void destroy() 
    87         { 
    88                 delete this; 
    89         } 
    90  
    91  
    9271private: 
    9372        vpr::Thread*  thrThread; 

  • juggler/trunk/modules/gadgeteer/drivers/Ascension/Flock/Flock.h

    r20307 r20356  
    105105   } 
    106106 
    107    /** 
    108     * Invokes the global scope delete operator.  This is required for proper 
    109     * releasing of memory in DLLs on Win32. 
    110     */ 
    111    void operator delete(void* p) 
    112    { 
    113       ::operator delete(p); 
    114    } 
    115  
    116107protected: 
    117    /** 
    118     * Deletes this object.  This is an implementation of the pure virtual 
    119     * gadget::Input::destroy() method. 
    120     */ 
    121    virtual void destroy() 
    122    { 
    123       delete this; 
    124    } 
    125  
    126108   void controlLoop(); 
    127109 

  • juggler/trunk/modules/gadgeteer/drivers/Ascension/MotionStar/MotionStar.h

    r20307 r20356  
    455455   void controlLoop(); 
    456456 
    457    /** 
    458     * Invokes the global scope delete operator.  This is required for proper 
    459     * releasing of memory in DLLs on Win32. 
    460     */ 
    461    void operator delete(void* p) 
    462    { 
    463       ::operator delete(p); 
    464    } 
    465  
    466 protected: 
    467    /** 
    468     * Deletes this object.  This is an implementation of the pure virtual 
    469     * gadget::Input::destroy() method. 
    470     */ 
    471    virtual void destroy() 
    472    { 
    473       delete this; 
    474    } 
    475  
    476457private: 
    477458   /** 

  • juggler/trunk/modules/gadgeteer/drivers/Ascension/Wanda/Wanda.h

    r20307 r20356  
    104104   virtual void updateData(); 
    105105 
    106    /** 
    107     * Invokes the global scope delete operator.  This is required for proper 
    108     * releasing of memory in DLLs on Win32. 
    109     */ 
    110    void operator delete(void* p) 
    111    { 
    112       ::operator delete(p); 
    113    } 
    114  
    115 protected: 
    116    /** 
    117     * Deletes this object.  This is an implementation of the pure virtual 
    118     * gadget::Input::destroy() method. 
    119     */ 
    120    virtual void destroy() 
    121    { 
    122       delete this; 
    123    } 
    124  
    125106private: 
    126107   /** The function called by the spawned thread. */ 

  • juggler/trunk/modules/gadgeteer/drivers/Elexol/Ether24/Ether24.h

    r20307 r20356  
    8080   static std::string getElementType(); 
    8181 
    82    /** 
    83     * Invokes the global scope delete operator.  This is required for proper 
    84     * releasing of memory in DLLs on Win32. 
    85     */ 
    86    void operator delete(void* p) 
    87    { 
    88       ::operator delete(p); 
    89    } 
    90  
    91 protected: 
    92    /** 
    93     * Deletes this object.  This is an implementation of the pure virtual 
    94     * gadget::Input::destroy() method. 
    95     */ 
    96    virtual void destroy() 
    97    { 
    98       delete this; 
    99    } 
    100  
    10182private: 
    10283   jccl::ConfigElementPtr   mConfigElement; 

  • juggler/trunk/modules/gadgeteer/drivers/Fakespace/PinchGlove/PinchGlove.h

    r20307 r20356  
    100100   virtual void updateData (); 
    101101 
    102    /** 
    103     * Invokes the global scope delete operator.  This is required for proper 
    104     * releasing of memory in DLLs on Win32. 
    105     */ 
    106    void operator delete(void* p) 
    107    { 
    108       ::operator delete(p); 
    109    } 
    110  
    111102protected: 
    112    /** 
    113     * Deletes this object.  This is an implementation of the pure virtual 
    114     * gadget::Input::destroy() method. 
    115     */ 
    116    virtual void destroy() 
    117    { 
    118       delete this; 
    119    } 
    120  
    121103   /** 
    122104    * The main control loop for this device. 

  • juggler/trunk/modules/gadgeteer/drivers/Immersion/IBox/IBox.h

    r20307 r20356  
    7171   void controlLoop(); 
    7272 
    73    /** 
    74     * Invokes the global scope delete operator.  This is required for proper 
    75     * releasing of memory in DLLs on Win32. 
    76     */ 
    77    void operator delete(void* p) 
    78    { 
    79       ::operator delete(p); 
    80    } 
    81  
    82 protected: 
    83    /** 
    84     * Deletes this object.  This is an implementation of the pure virtual 
    85     * gadget::Input::destroy() method. 
    86     */ 
    87    virtual void destroy() 
    88    { 
    89       delete this; 
    90    } 
    91  
    9273private: 
    9374   IBoxStandalone* mIBox; 

  • juggler/trunk/modules/gadgeteer/drivers/Logitech/ThreeDMouse/logiclass.h

    r20307 r20356  
    149149   //@} 
    150150 
    151    /** 
    152     * Invokes the global scope delete operator.  This is required for proper 
    153     * releasing of memory in DLLs on Win32. 
    154     */ 
    155    void operator delete(void* p) 
    156    { 
    157       ::operator delete(p); 
    158    } 
    159  
    160 protected: 
    161    /** 
    162     * Deletes this object.  This is an implementation of the pure virtual 
    163     * gadget::Input::destroy() method. 
    164     */ 
    165    virtual void destroy() 
    166    { 
    167       delete this; 
    168    } 
    169  
    170151private: 
    171152   int mouseFD; 

  • juggler/trunk/modules/gadgeteer/drivers/Microsoft/DirectXJoystick/DirectXJoystick.h

    r20307 r20356  
    124124   } 
    125125 
    126    /** 
    127     * Invokes the global scope delete operator.  This is required for proper 
    128     * releasing of memory in DLLs on Win32. 
    129     */ 
    130    void operator delete(void* p) 
    131    { 
    132       ::operator delete(p); 
    133    } 
    134  
    135 protected: 
    136    /** 
    137     * Deletes this object.  This is an implementation of the pure virtual 
    138     * gadget::Input::destroy() method. 
    139     */ 
    140    virtual void destroy() 
    141    { 
    142       delete this; 
    143    } 
    144  
    145126private: 
    146127   std::vector<unsigned> mAxisButtonIndices; /**< Indices of the axis buttons */ 

  • juggler/trunk/modules/gadgeteer/drivers/Microsoft/SpeechRecognition/MSFTSpeechRecogDigital.h

    r20307 r20356  
    8787   { 
    8888      return mIsActive; 
    89    }; 
    90  
    91    /** 
    92     * Invokes the global scope delete operator.  This is required for proper 
    93     * releasing of memory in DLLs on Win32. 
    94     */ 
    95    void operator delete(void* p) 
    96    { 
    97       ::operator delete(p); 
    98    } 
    99  
    100 protected: 
    101    /** 
    102     * Deletes this object.  This is an implementation of the pure virtual 
    103     * gadget::Input::destroy() method. 
    104     */ 
    105    virtual void destroy() 
    106    { 
    107       delete this; 
    10889   } 
    10990 

  • juggler/trunk/modules/gadgeteer/drivers/Microsoft/SpeechRecognition/MSFTSpeechRecogString.h

    r20307 r20356  
    9393   } 
    9494 
    95    /** 
    96     * Invokes the global scope delete operator.  This is required for proper 
    97     * releasing of memory in DLLs on Win32. 
    98     */ 
    99    void operator delete(void* p) 
    100    { 
    101       ::operator delete(p); 
    102    } 
    103  
    104 protected: 
    105    /** 
    106     * Deletes this object.  This is an implementation of the pure virtual 
    107     * gadget::Input::destroy() method. 
    108     */ 
    109    virtual void destroy() 
    110    { 
    111       delete this; 
    112    } 
    113  
    11495private: 
    11596   std::string mGrammarFileName; 

  • juggler/trunk/modules/gadgeteer/drivers/Open/DTK/DTK.h

    r20307 r20356  
    122122   } 
    123123 
    124    /** 
    125     * Invokes the global scope delete operator.  This is required for proper 
    126     * releasing of memory in DLLs on Win32. 
    127     */ 
    128    void operator delete(void* p) 
    129    { 
    130       ::operator delete(p); 
    131    } 
    132  
    133 protected: 
    134    /** 
    135     * Deletes this object.  This is an implementation of the pure virtual 
    136     * gadget::Input::destroy() method. 
    137     */ 
    138    virtual void destroy() 
    139    { 
    140       delete this; 
    141    } 
    142  
    143124private: 
    144125   int getStationIndex(int stationNum, int bufferIndex); 

  • juggler/trunk/modules/gadgeteer/drivers/Open/LinuxJoydev/LinuxJoydev.h

    r20307 r20356  
    117117   } 
    118118 
    119    /** 
    120     * Invokes the global scope delete operator.  This is required for proper 
    121     * releasing of memory in DLLs on Win32. 
    122     */ 
    123    void operator delete(void* p) 
    124    { 
    125       ::operator delete(p); 
    126    } 
    127  
    128 protected: 
    129    /** 
    130     * Deletes this object.  This is an implementation of the pure virtual 
    131     * gadget::Input::destroy() method. 
    132     */ 
    133    virtual void destroy() 
    134    { 
    135       delete this; 
    136    } 
    137  
    138119private: 
    139120   std::string                   mPortName;        /**< Name of the port to connect to */ 

  • juggler/trunk/modules/gadgeteer/drivers/Open/Trackd/TrackdController.h

    r20307 r20356  
    139139   } 
    140140 
    141    /** 
    142     * Invokes the global scope delete operator.  This is required for proper 
    143     * releasing of memory in DLLs on Win32. 
    144     */ 
    145    void operator delete(void* p) 
    146    { 
    147       ::operator delete(p); 
    148    } 
    149  
    150 protected: 
    151    /** 
    152     * Deletes this object.  This is an implementation of the pure virtual 
    153     * gadget::Input::destroy() method. 
    154     */ 
    155    virtual void destroy() 
    156    { 
    157       delete this; 
    158    } 
    159  
    160141private: 
    161142   TrackdControllerStandalone* mTrackdController;  /**< The controller we are dealing with. */ 

  • juggler/trunk/modules/gadgeteer/drivers/Open/Trackd/TrackdSensor.h

    r20307 r20356  
    102102   static std::string getElementType(); 
    103103 
    104    /** 
    105     * Invokes the global scope delete operator.  This is required for proper 
    106     * releasing of memory in DLLs on Win32. 
    107     */ 
    108    void operator delete(void* p) 
    109    { 
    110       ::operator delete(p); 
    111    } 
    112  
    113 protected: 
    114    /** 
    115     * Deletes this object.  This is an implementation of the pure virtual 
    116     * gadget::Input::destroy() method. 
    117     */ 
    118    virtual void destroy() 
    119    { 
    120       delete this; 
    121    } 
    122  
    123104private: 
    124105    TrackdSensorStandalone* mTrackdSensors; /**< The sensors that we are dealing with. */ 

  • juggler/trunk/modules/gadgeteer/drivers/Open/VRPN/Vrpn.h

    r20307 r20356  
    131131   /** Returns what element type is associated with this class. */ 
    132132   static std::string getElementType(); 
    133  
    134    /** 
    135     * Invokes the global scope delete operator.  This is required for proper 
    136     * releasing of memory in DLLs on Win32. 
    137     */ 
    138    void operator delete(void* p) 
    139    { 
    140       ::operator delete(p); 
    141    } 
    142  
    143 protected: 
    144    /** 
    145     * Deletes this object.  This is an implementation of the pure virtual 
    146     * gadget::Input::destroy() method. 
    147     */ 
    148    virtual void destroy() 
    149    { 
    150       delete this; 
    151    } 
    152133 
    153134private: 

  • juggler/trunk/modules/gadgeteer/drivers/Polhemus/Fastrak/Fastrak.h

    r20307 r20356  
    8787   } 
    8888 
    89 public: 
    90    /** 
    91     * Invokes the global scope delete operator.  This is required for proper 
    92     * releasing of memory in DLLs on Win32. 
    93     */ 
    94    void operator delete(void* p) 
    95    { 
    96       ::operator delete(p); 
    97    } 
    98  
    99 protected: 
    100    /** 
    101     * Deletes this object.  This is an implementation of the pure virtual 
    102     * gadget::Input::destroy() method. 
    103     */ 
    104    virtual void destroy() 
    105    { 
    106       delete this; 
    107    } 
    108  
    10989private: 
    11090   void controlLoop(); 

  • juggler/trunk/modules/gadgeteer/drivers/USDigital/SerialEncoder/SerialEncoder.h

    r20307 r20356  
    6969   void threadedSampleFunction(); 
    7070 
    71    void operator delete(void* p) 
    72    { 
    73       ::operator delete(p); 
    74    } 
    75  
    76 protected: 
    77    virtual void destroy() 
    78    { 
    79       delete this; 
    80    } 
    81  
    8271private: 
    8372   vpr::Thread* mSampleThread; 

  • juggler/trunk/modules/gadgeteer/drivers/VRCO/TrackdAPI/TrackdAPIController.h

    r20307 r20356  
    137137   } 
    138138 
    139    /** 
    140     * Invokes the global scope delete operator.  This is required for proper 
    141     * releasing of memory in DLLs on Win32. 
    142     */ 
    143    void operator delete(void* p) 
    144    { 
    145       ::operator delete(p); 
    146    } 
    147  
    148 protected: 
    149    /** 
    150     * Deletes this object.  This is an implementation of the pure virtual 
    151     * gadget::Input::destroy() method. 
    152     */ 
    153    virtual void destroy() 
    154    { 
    155       delete this; 
    156    } 
    157  
    158139private: 
    159140   ControllerReader*            mControllerReader;    /**< The controller reader to use */ 

  • juggler/trunk/modules/gadgeteer/drivers/VRCO/TrackdAPI/TrackdAPISensor.h

    r20307 r20356  
    106106   static std::string getElementType(); 
    107107 
    108    /** 
    109     * Invokes the global scope delete operator.  This is required for proper 
    110     * releasing of memory in DLLs on Win32. 
    111     */ 
    112    void operator delete(void* p) 
    113    { 
    114       ::operator delete(p); 
    115    } 
    116  
    117 protected: 
    118    /** 
    119     * Deletes this object.  This is an implementation of the pure virtual 
    120     * gadget::Input::destroy() method. 
    121     */ 
    122    virtual void destroy() 
    123    { 
    124       delete this; 
    125    } 
    126  
    127108private: 
    128109   TrackerReader* mTrackerReader;   /**< The tracker sensor to read data from */ 

  • juggler/trunk/modules/gadgeteer/drivers/VirtualTechnologies/CyberGlove/CyberGlove.h

    r19729 r20356  
    5858   virtual void updateData (); 
    5959 
    60    /** 
    61     * Invokes the global scope delete operator.  This is required for proper 
    62     * releasing of memory in DLLs on Win32. 
    63     */ 
    64    void operator delete(void* p) 
    65    { 
    66       ::operator delete(p); 
    67    } 
    68  
    69 protected: 
    70    /** 
    71     * Deletes this object.  This is an implementation of the pure virtual 
    72     * gadget::Input::destroy() method. 
    73     */ 
    74    virtual void destroy() 
    75    { 
    76       delete this; 
    77    } 
    78  
     60private: 
    7961   /** The main control loop for the object. */ 
    8062   void controlLoop(); 
    …… 
    8264   void copyDataFromGlove(); 
    8365 
    84 protected: 
    8566   CyberGloveBasic*  mGlove;              /**< The actual glove */ 
    8667   char*             mCalDir;             /**< Calibration file directory */ 

  • juggler/trunk/modules/gadgeteer/drivers/configure.ac

    r20308 r20356  
    173173 
    174174VPR_PATH([1.1.42], , [AC_MSG_ERROR([*** VPR required for Device Drivers ***])]) 
    175 GADGETEER_PATH([1.3.8], , 
     175GADGETEER_PATH([1.3.11], , 
    176176               [AC_MSG_ERROR(*** Gadgeteer required for Device Drivers ***)]) 
    177177JCCL_PATH_CXX([1.1.5], , 

  • juggler/trunk/modules/gadgeteer/drivers/noDNA/X-IST/X-IST.h

    r19966 r20356  
    6161   virtual void updateData(); 
    6262 
    63    /** 
    64     * Invokes the global scope delete operator.  This is required for proper 
    65     * releasing of memory in DLLs on Win32. 
    66     */ 
    67    void operator delete(void* p) 
    68    { 
    69       ::operator delete(p); 
    70    } 
    71  
    72 protected: 
    73    /** 
    74     * Deletes this object.  This is an implementation of the pure virtual 
    75     * gadget::Input::destroy() method. 
    76     */ 
    77    virtual void destroy() 
    78    { 
    79       delete this; 
    80    } 
    81  
     63private: 
    8264   /** The main control loop for the object. */ 
    8365   void controlLoop(); 
    8466   void copyDataFromGlove(); 
    8567 
    86 protected: 
    8768   X_ISTStandalone* mGlove;           /**< The actual glove */ 
    8869 

  • juggler/trunk/modules/gadgeteer/gadget/Devices/KeyboardMouseDevice/InputWindowCocoa.h

    r19852 r20356  
    9797   void setWindowOpen(const bool isOpen); 
    9898 
    99    /** 
    100     * Invokes the global scope delete operator.  This is required for proper 
    101     * releasing of memory in DLLs on Win32. 
    102     */ 
    103    void operator delete(void* p) 
    104    { 
    105       ::operator delete(p); 
    106    } 
    107  
    108 protected: 
    109    /** 
    110     * Deletes this object.  This is an implementation of the pure virtual 
    111     * gadget::Input::destroy() method. 
    112     */ 
    113    void destroy() 
    114    { 
    115       delete this; 
    116    } 
    117  
    11899private: 
    119100   /** 

  • juggler/trunk/modules/gadgeteer/gadget/Devices/KeyboardMouseDevice/InputWindowWin32.h

    r19729 r20356  
    9393   static std::string getElementType(); 
    9494 
    95    /** 
    96     * Invokes the global scope delete operator.  This is required for proper 
    97     * releasing of memory in DLLs on Win32. 
    98     */ 
    99    void operator delete(void* p) 
    100    { 
    101       ::operator delete(p); 
    102    } 
    103  
    10495protected: 
    105    /** 
    106     * Deletes this object.  This is an implementation of the pure virtual 
    107     * gadget::Input::destroy() method. 
    108     */ 
    109    void destroy() 
    110    { 
    111       delete this; 
    112    } 
    113  
    11496   virtual void processEvent(UINT, UINT, LONG) 
    11597   { 

  • juggler/trunk/modules/gadgeteer/gadget/Devices/KeyboardMouseDevice/InputWindowXWin.h

    r19729 r20356  
    122122   static std::string getElementType(); 
    123123 
    124    /** 
    125     * Invokes the global scope delete operator.  This is required for proper 
    126     * releasing of memory in DLLs on Win32. 
    127     */ 
    128    void operator delete(void* p) 
    129    { 
    130       ::operator delete(p); 
    131    } 
    132  
    133124protected: 
    134    /** 
    135     * Deletes this object.  This is an implementation of the pure virtual 
    136     * gadget::Input::destroy() method. 
    137     */ 
    138    void destroy() 
    139    { 
    140       delete this; 
    141    } 
    142  
    143125   /** Do any extra event processing needed. */ 
    144126   virtual void processEvent(XEvent) 

  • juggler/trunk/modules/gadgeteer/gadget/Devices/KeyboardMouseDevice/KeyboardMouseDevice.h

    r19729 r20356  
    130130   static std::string getElementType(); 
    131131 
    132    /** 
    133     * Invokes the global scope delete operator.  This is required for proper 
    134     * releasing of memory in DLLs on Win32. 
    135     */ 
    136    void operator delete(void* p) 
    137    { 
    138       ::operator delete(p); 
    139    } 
    140  
    141 protected: 
    142    /** 
    143     * Deletes this object.  This is an implementation of the pure virtual 
    144     * gadget::Input::destroy() method. 
    145     */ 
    146    void destroy() 
    147    { 
    148       delete this; 
    149    } 
    150132private: 
    151133   float        mMouseSensitivity; 

  • juggler/trunk/modules/gadgeteer/gadget/Devices/Sim/SimAnalog.h

    r19729 r20356  
    9898   } 
    9999 
    100    /** 
    101     * Invokes the global scope delete operator.  This is required for proper 
    102     * releasing of memory in DLLs on Win32. 
    103     */ 
    104    void operator delete(void* p) 
    105    { 
    106       ::operator delete(p); 
    107    } 
    108  
    109 protected: 
    110    /** 
    111     * Deletes this object.  This is an implementation of the pure virtual 
    112     * gadget::Input::destroy() method. 
    113     */ 
    114    virtual void destroy() 
    115    { 
    116       delete this; 
    117    } 
    118  
    119100private: 
    120101   std::vector<AnalogData>    mAnaData;      /**< The analog data that we have */