.. _program_listing_file_include_gwmodelpp_spatialweight_SpatialWeight.h:

Program Listing for File SpatialWeight.h
========================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_gwmodelpp_spatialweight_SpatialWeight.h>` (``include/gwmodelpp/spatialweight/SpatialWeight.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef SPATIALWEIGHT_H
   #define SPATIALWEIGHT_H
   
   #include "Weight.h"
   #include "Distance.h"
   
   #include "BandwidthWeight.h"
   
   #include "CRSDistance.h"
   #include "MinkwoskiDistance.h"
   #include "DMatDistance.h"
   #include "OneDimDistance.h"
   
   namespace gwm
   {
   
   class SpatialWeight
   {
   public:
   
       SpatialWeight();
   
       SpatialWeight(Weight* weight, Distance* distance);
   
       SpatialWeight(const SpatialWeight& spatialWeight);
   
       virtual ~SpatialWeight();
   
       Weight *weight() const
       {
           return mWeight;
       }
   
       void setWeight(Weight *weight)
       {
           if (mWeight) delete mWeight;
           mWeight = weight;
       }
   
       void setWeight(Weight& weight)
       {
           if (mWeight) delete mWeight;
           mWeight = weight.clone();
       }
   
       void setWeight(Weight&& weight)
       {
           if (mWeight) delete mWeight;
           mWeight = weight.clone();
       }
   
       template<typename T>
       T* weight() const { return nullptr; }
   
       Distance *distance() const
       {
           return mDistance;
       }
   
       void setDistance(Distance *distance)
       {
           if (mDistance) delete mDistance;
           mDistance = distance;
       }
   
       void setDistance(Distance& distance)
       {
           if (mDistance) delete mDistance;
           mDistance = distance.clone();
       }
   
       void setDistance(Distance&& distance)
       {
           if (mDistance) delete mDistance;
           mDistance = distance.clone();
       }
   
       template<typename T>
       T* distance() const { return nullptr; }
   
   public:
   
       SpatialWeight& operator=(const SpatialWeight& spatialWeight);
   
       SpatialWeight& operator=(const SpatialWeight&& spatialWeight);
   
   public:
   
       virtual arma::vec weightVector(arma::uword focus)
       {
           return mWeight->weight(mDistance->distance(focus));
       }
   
       virtual bool isValid();
   
   private:
       Weight* mWeight = nullptr;      
       Distance* mDistance = nullptr;  
   };
   
   template<>
   inline BandwidthWeight* SpatialWeight::weight<BandwidthWeight>() const
   {
       return static_cast<BandwidthWeight*>(mWeight);
   }
   
   template<>
   inline CRSDistance* SpatialWeight::distance<CRSDistance>() const
   {
       return static_cast<CRSDistance*>(mDistance);
   }
   
   template<>
   inline MinkwoskiDistance* SpatialWeight::distance<MinkwoskiDistance>() const
   {
       return static_cast<MinkwoskiDistance*>(mDistance);
   }
   
   template<>
   inline DMatDistance* SpatialWeight::distance<DMatDistance>() const
   {
       return static_cast<DMatDistance*>(mDistance);
   }
   
   template<>
   inline OneDimDistance* SpatialWeight::distance<OneDimDistance>() const
   {
       return static_cast<OneDimDistance*>(mDistance);
   }
   
   }
   
   #endif // SPATIALWEIGHT_H