KVector += and -= operators

App/src/TestDiffuseScattering.cpp

@@ -61,16 +61,17 @@ void TestDiffuseScattering::execute()
 
     mySample.print();
 
-    std::cout << "--- Attempt to clone MultiLayer" << std::endl;
-
-    MultiLayer *newSample = mySample.clone();
-    newSample->print();
-
-    MultiLayer *newSample2 = newSample->clone();
-
-    delete newSample;
-
-    newSample2->print();
+//    std::cout << "--- Attempt to clone MultiLayer" << std::endl;
+//    MultiLayer *newSample = mySample.clone();
+//    newSample->print();
+//    MultiLayer *newSample2 = newSample->clone();
+//    delete newSample;
+//    newSample2->print();
+
+    kvector_t k1(0.1,0.2,0.3);
+    kvector_t k2(0.1,0.2,0.8);
+    kvector_t k3 = k2 - k1;
+    std::cout << k3 << std::endl;
 
 }
 

Core/Core.pro

@@ -27,6 +27,7 @@ SOURCES += \
     src/MaterialManager.cpp \
     src/StochasticGaussian.cpp \
     src/MathFunctions.cpp \
+    src/Types.cpp
 
 HEADERS += \
     inc/ISample.h \

Core/inc/ISample.h

@@ -10,6 +10,9 @@ public:
     virtual ~ISample() {}
 
     virtual void add(ISample* p_child);
+
+    virtual ISample *clone() const =0;
+
 //    virtual void remove(ISample* p_child);
 //    virtual ISample* getChild(size_t index);
 };

Core/inc/Layer.h

@@ -32,6 +32,9 @@ public:
     Layer &operator=(const Layer &other);
     virtual ~Layer();
 
+    //! make layer's clone
+    virtual Layer *clone() const;
+
     /// set layer thickness in _angstrom_
     virtual void setThickness(double thickness);
 

Core/inc/MultiLayer.h

@@ -67,7 +67,7 @@ public:
     void clear();
 
     /// return clone of multilayer with clones of all layers and recreated interfaces between layers
-    MultiLayer *clone();
+    virtual MultiLayer *clone() const;
 
     /// print structure of multilayer
     void print();

Core/inc/Types.h

@@ -9,6 +9,11 @@
 typedef std::complex<double > complex_t;
 
 
+// we need forward declaration here to be able to redefine ostream as friend
+template<typename T> class KVector;
+template<typename T> std::ostream& operator<< (std::ostream& o, const KVector<T>& );
+
+
 template<typename T>
 class KVector {
 public:
@@ -35,12 +40,21 @@ public:
     inline T z() const { return m_z; }
     inline T mag() const { return std::sqrt(m_mag2); }
     inline T mag2() const { return m_mag2; }
+
+    KVector<T> &operator=(const KVector<T> &other);
+    KVector<T> &operator+=(const KVector<T> &other);
+    KVector<T> &operator-=(const KVector<T> &other);
+    friend std::ostream &operator<< <T> (std::ostream &ostr, KVector<T> const &k);
 private:
     T m_x;
     T m_y;
     T m_z;
     T m_mag2;
 };
+
+template<typename T> KVector<T> operator+(const KVector<T> &a, const KVector<T> &b);
+template<typename T> KVector<T> operator-(const KVector<T> &a, const KVector<T> &b);
+
 typedef KVector<double >  kvector_t;
 
 

Core/src/Layer.cpp

@@ -32,6 +32,12 @@ Layer::~Layer()
 }
 
 
+/* ************************************************************************* */
+Layer *Layer::clone() const {
+    return new Layer(*this);
+}
+
+
 /* ************************************************************************* */
 void Layer::setThickness(double thickness)
 {

Core/src/MaterialManager.cpp

@@ -27,9 +27,9 @@ MaterialManager::~MaterialManager()
 /* ************************************************************************* */
 MaterialManager &MaterialManager::instance()
 {
-    // check if not exists, then initialise
+    // check if exists, if not, then initialise
     if( !pInstance) {
-        // check for dead reference
+        // check for dead reference (i.e. object has been initialised but then somebody managed to delete it)
         if( m_destroyed ) {
             onDeadReference();
         } else {

Core/src/MultiLayer.cpp

@@ -37,7 +37,7 @@ void MultiLayer::clear()
 /* ************************************************************************* */
 // clone MultiLayer contents including interfaces
 /* ************************************************************************* */
-MultiLayer *MultiLayer::clone()
+MultiLayer *MultiLayer::clone() const
 {
     MultiLayer *newMultiLayer = new MultiLayer();
 

Core/src/Types.cpp

+#include "Types.h"
+
+
+
+template<typename T>
+KVector<T> &KVector<T>::operator=(const KVector<T> &other)
+{
+    m_x=other.m_x; m_y = other.m_y; m_z = other.m_z;
+    return *this;
+}
+
+template<typename T> KVector<T> &KVector<T>::operator+=(const KVector<T> &b)
+{
+    m_x += b.m_x; m_y += b.m_y; m_z += b.m_z;
+    return *this;
+}
+
+template<typename T> KVector<T> &KVector<T>::operator-=(const KVector<T> &b)
+{
+    m_x -= b.m_x; m_y -= b.m_y; m_z -= b.m_z;
+    return *this;
+}
+
+template<typename T> KVector<T> operator+(const KVector<T> &a, const KVector<T> &b)
+{
+    KVector<T> target = a;
+    target += b;
+    return target;
+}
+
+template<typename T> KVector<T> operator-(const KVector<T> &a, const KVector<T> &b)
+{
+    KVector<T> target = a;
+    target -= b;
+    return target;
+}
+
+template<typename T>
+std::ostream &operator<<(std::ostream &o, const KVector<T>  &a)
+{
+    o << a.m_x << " " << a.m_y << " " << a.m_z;
+    return o;
+}
+
+
+
+// to force compiler to generate necessary code in shared library
+template class KVector<double>;
+//template KVector<double> operator=    <double> (const KVector<double> &a);
+//template KVector<double> operator+=    <double> (const KVector<double> &a);
+//template KVector<double> operator-=    <double> (const KVector<double> &a);
+template KVector<double> operator+    <double> (const KVector<double> &a, const KVector<double> &b);
+template KVector<double> operator-    <double> (const KVector<double> &a, const KVector<double> &b);
+template std::ostream &operator<<    <double> (std::ostream &o, const KVector<double> &b);
+
+