Added examples for

+ Move-menatics & R-value references
+ Lambdas

Author: Adam Horvath

src/Lambdas.cpp

@@ -35,11 +35,13 @@ void Lambdas::TestCountIf()
 		std::endl;
 }
 
+
 void Lambdas::TestCapture()
 {
 	int myMoney = 1000;
 	auto addSome = [&myMoney](int addition){ myMoney += addition; };
 	auto multiplySome = [&myMoney](int mult){ myMoney *= mult; };
+	++myMoney;
 	auto printMoney = [myMoney](){ std::cout << "My Money: " << myMoney << std::endl; };
 	// Can you see a bug above?
 

src/MemoryBlock.h

@@ -57,7 +57,7 @@ class MemoryBlock
       return *this;
    }
 
-//#define cpp11
+#define cpp11
 #ifdef cpp11
    // NEW: Move constructor
    MemoryBlock(MemoryBlock&& other) noexcept: m_pData(nullptr), m_size(0)

src/TestItAgainSam.cpp

@@ -4,6 +4,7 @@
 #include <chrono>
 #include <ctime>
 #include <thread>
+#include <utility>
 
 #include "HeaderInit.h"
 
@@ -41,11 +42,11 @@ void TestItAgainSam::Run() const
 	//TestLegacyEnums();
 	//TestEnums();
 
-	TestAsync();
+	//TestAsync();
 
 	//TestMove();
 
-	//TestLambdas();
+	TestLambdas();
 
 	// This is only to keep the command prompt alive when running inside Visual Studio
 	//std::this_thread::sleep_for(std::chrono::seconds(30));
@@ -183,7 +184,7 @@ void TestItAgainSam::TestMove() const
 
 	std::vector<MemoryBlock> vec;
 
-	vec.push_back(MemoryBlock(2000));
+	vec.emplace(vec.begin(), 2000);
 	std::cout << " === " << std::endl;
 	vec.insert(vec.begin(), MemoryBlock(1000));
 	std::cout << " === " << std::endl;

src/schematron_example/Sequence.h

@@ -0,0 +1,117 @@
+#ifndef _SEQUENCE_H_
+#define _SEQUENCE_H_
+
+#include <list>
+
+#include "Value.h"
+
+namespace MafXpathParser
+{
+
+// A class that represents a xpath Sequence.
+class Sequence
+{
+public:
+    Sequence();
+    explicit Sequence(const std::list<const Value*>& nodes);
+    explicit Sequence(const Value* expr);
+    Sequence(const Sequence& s);
+    /**
+     * no virtual destructor since there is a need
+     * for this class to be memory efficient.
+     * Also the NotOwningSequence dont want this destructor
+     * to be called.
+     */
+    ~Sequence();
+
+    std::ostream& put(std::ostream& os) const;
+    const std::string toString(const std::string& networkManagedElementId="") const;
+    bool exists(EvalContext& evalContext) const;
+    bool isTrue() const;
+
+    /**
+     * Methods to access/add values etc
+     */
+
+    /**
+     * Since the Dns class has a set of values, counting is needed.
+     * this should not be too bad since size on list has O(n)
+     * complexity according to specs.
+     */
+    size_t size() const
+    {
+        size_t result = 0;
+        for (std::list<const Value*>::const_iterator i = _values.begin();
+                i != _values.end();
+                ++i) {
+            result += (*i)->size();
+        }
+        return result;
+    }
+
+    void addValue(const Value* n);
+    void addValueFront(const Value* n);
+    const Value& firstValue() const;
+    const Value& secondValue() const;
+    std::list<const Value*>& getValues();
+    const std::list<const Value*>& getValues() const;
+    void splice(const Sequence& s)
+    {
+        _values.splice(_values.end(), const_cast<Sequence&>(s)._values);
+    }
+    struct Destroy {
+        void operator ()(const Value* v)
+        {
+            delete v;
+        }
+    };
+private:
+    Sequence& operator = (const Sequence&); // Not allowed
+    struct NotExist {
+        NotExist(EvalContext& evalContext): _evalContext(evalContext) {}
+        bool operator() (const Value* v)
+        {
+            return !v->exists(_evalContext);
+        }
+        EvalContext& _evalContext;
+    };
+    struct Copy {
+        Copy(std::list<const Value*>& values) : _values(values)
+        {
+            ;
+        }
+        void operator ()(const Value* v)
+        {
+            _values.push_back(v->clone());
+        }
+        std::list<const Value*>& _values;
+    };
+protected:
+    /**
+     * A sequence is a list of values
+     */
+    std::list<const Value*> _values;
+};
+
+// Class to make sure the destructor does not delete
+// the values in the sequence.
+class NotOwningSequence : public Sequence
+{
+public:
+    ~NotOwningSequence()
+    {
+        _values.clear();
+    }
+};
+
+inline
+std::ostream&
+operator<<(std::ostream& os, const Sequence& s)
+{
+    s.put(os);
+    return os;
+}
+
+} // namespace XpathParser
+
+#endif

src/schematron_example/Struct.cc

@@ -0,0 +1,91 @@
+#include <iostream>
+#include <algorithm>
+#include <map>
+
+#include "Sequence.h"
+#include "Struct.h"
+
+using namespace MafXpathParser;
+
+Struct::Struct(const std::string& name) : _name(name)
+{
+}
+
+Struct::Struct(const Struct& s) : _name(s._name)
+{
+	// C++03
+    Clone cloneObj(_attributes);
+    std::for_each(s._attributes.begin(), s._attributes.end(), cloneObj);
+
+    // C++14 - Here is another nifty use of lambdas
+    // This could be re-written something like below
+    // We no longer need the "class Clone" functor.
+    auto cloneFunc = [this](auto& attr){this->_attributes[attr.first] = new Sequence(*(attr.second));
+    for(const auto& attr: s._attributes) cloneFunc();
+
+    // Or
+    auto cloneFunc2 = [this](auto& attr){this->_attributes[attr->first] = new Sequence(*(attr->second));
+    std::for_each(s._attributes.begin(), s._attributes.end(), cloneFunc2);
+
+    // A nice explanation of the template expansion of [this](auto& attr)
+    // Can be found here:
+    // http://stackoverflow.com/questions/17233547/how-does-generic-lambda-work-in-c14/17233649#17233649
+}
+
+Struct::~Struct()
+{
+    Destroy destroy;
+    (void) std::for_each(_attributes.begin(), _attributes.end(), destroy);
+}
+
+void
+Struct::lookupAttribute(const std::string& name,
+                        Sequence& result) const
+{
+    std::map<std::string, Sequence*>::const_iterator it =
+        _attributes.find(name);
+    if (it != _attributes.end()) {
+        Sequence tmp(*(it->second));
+        result.splice(tmp);
+    }
+}
+
+void
+Struct::addAttribute(const std::string& name, Sequence* value)
+{
+    _attributes[name] = value;
+}
+
+std::ostream&
+Struct::put(std::ostream& os) const
+{
+    os << "(Struct " << _name << ")";
+    return os;
+}
+
+const Value*
+Struct::clone() const
+{
+    return new Struct(*this);
+}
+
+const std::string
+Struct::toString(const std::string& networkManagedElementId) const
+{
+    std::string result("struct(");
+
+    for (std::map<std::string, Sequence*>::const_iterator i = _attributes.begin();
+            i != _attributes.end();
+            ++i) {
+        if (i != _attributes.begin()) {
+            result += ", ";
+        }
+        result += i->first;
+        result += "=";
+        result += i->second->toString(networkManagedElementId);
+    }
+
+    result += ")";
+
+    return result;
+}

src/schematron_example/Struct.h

@@ -0,0 +1,51 @@
+#ifndef _STRUCT_HH_
+#define _STRUCT_HH_
+
+#include <string>
+#include <map>
+
+#include "Value.h"
+
+namespace MafXpathParser
+{
+
+// A value class representing struct attributes.
+// It is created _not_ by the bison parser but is a result of
+// looking up a struct attribute in the db.
+
+class Struct : public Value
+{
+public:
+    explicit Struct(const std::string& name);
+    ~Struct();
+    void lookupAttribute(const std::string& name, Sequence& result) const;
+    void addAttribute(const std::string& name, Sequence* value);
+    std::ostream& put(std::ostream& os) const;
+    const Value* clone() const;
+    const std::string toString(const std::string& networkManagedElementId="") const;
+private:
+    Struct(const Struct& name);
+
+    struct Destroy {
+        void operator() (const std::pair<const std::string, Sequence*>& p)
+        {
+            delete p.second;
+        }
+    };
+
+    struct Clone {
+        Clone(std::map<std::string, Sequence*>& attributes) : _attributes(attributes) {}
+        void operator() (const std::pair<const std::string, Sequence*>& p)
+        {
+            _attributes[p.first] = new Sequence(*(p.second));
+        }
+        std::map<std::string, Sequence*>& _attributes;
+    };
+
+    std::string _name;
+    std::map<std::string, Sequence*> _attributes;        // name, sequence of values
+    friend class Db;
+};
+
+} // namespace XpathParser
+#endif