diff --git a/headers/modsecurity/collection/collection.h b/headers/modsecurity/collection/collection.h
index 04159e20..0e9e60de 100644
--- a/headers/modsecurity/collection/collection.h
+++ b/headers/modsecurity/collection/collection.h
@@ -26,8 +26,8 @@
 
 #include "modsecurity/collection/variable.h"
 
-#ifndef HEADERS_MODSECURITY_TRANSACTION_COLLECTION_H_
-#define HEADERS_MODSECURITY_TRANSACTION_COLLECTION_H_
+#ifndef HEADERS_MODSECURITY_COLLECTION_COLLECTION_H_
+#define HEADERS_MODSECURITY_COLLECTION_COLLECTION_H_
 
 #ifndef __cplusplus
 typedef struct Variable_t Variables;
@@ -44,7 +44,8 @@ class Collection {
     virtual bool storeOrUpdateFirst(const std::string &key,
         const std::string &value) = 0;
 
-    virtual bool updateFirst(const std::string &key, const std::string &value) = 0;
+    virtual bool updateFirst(const std::string &key,
+        const std::string &value) = 0;
 
     virtual void del(const std::string& key) = 0;
 
@@ -56,6 +57,28 @@ class Collection {
         std::vector<const Variable *> *l) = 0;
     virtual void resolveRegularExpression(const std::string& var,
         std::vector<const Variable *> *l) = 0;
+
+
+    virtual void store(std::string key, std::string compartment,
+        std::string value) = 0;
+
+    virtual bool storeOrUpdateFirst(const std::string &key,
+        std::string compartment, const std::string &value) = 0;
+
+    virtual bool updateFirst(const std::string &key, std::string compartment,
+        const std::string &value) = 0;
+
+    virtual void del(const std::string& key, std::string compartment) = 0;
+
+    virtual std::string* resolveFirst(const std::string& var,
+        std::string compartment) = 0;
+    virtual void resolveSingleMatch(const std::string& var,
+        std::string compartment, std::vector<const Variable *> *l) = 0;
+    virtual void resolveMultiMatches(const std::string& var,
+        std::string compartment, std::vector<const Variable *> *l) = 0;
+    virtual void resolveRegularExpression(const std::string& var,
+        std::string compartment,
+        std::vector<const Variable *> *l) = 0;
 };
 
 }  // namespace collection
@@ -63,4 +86,4 @@ class Collection {
 #endif
 
 
-#endif  // HEADERS_MODSECURITY_TRANSACTION_COLLECTION_H_
+#endif  // HEADERS_MODSECURITY_COLLECTION_COLLECTION_H_
diff --git a/headers/modsecurity/collection/collections.h b/headers/modsecurity/collection/collections.h
index bbaad40f..a4001923 100644
--- a/headers/modsecurity/collection/collections.h
+++ b/headers/modsecurity/collection/collections.h
@@ -27,12 +27,11 @@
 #include <list>
 #endif
 
-#include "modsecurity/collection/global_collection.h"
 #include "modsecurity/collection/collection.h"
 #include "modsecurity/collection/variable.h"
 
-#ifndef HEADERS_MODSECURITY_TRANSACTION_COLLECTIONS_H_
-#define HEADERS_MODSECURITY_TRANSACTION_COLLECTIONS_H_
+#ifndef HEADERS_MODSECURITY_COLLECTION_COLLECTIONS_H_
+#define HEADERS_MODSECURITY_COLLECTION_COLLECTIONS_H_
 
 #ifndef __cplusplus
 typedef struct Collections_t Collections;
@@ -46,7 +45,7 @@ namespace collection {
 class Collections :
     public std::unordered_map<std::string, Collection *> {
  public:
-    Collections(GlobalCollection *global, GlobalCollection *ip);
+    Collections(Collection *global, Collection *ip);
     ~Collections();
 
     void store(std::string key, std::string value);
@@ -88,8 +87,8 @@ class Collections :
     std::string m_global_collection_key;
     std::string m_ip_collection_key;
 
-    GlobalCollection *m_global_collection;
-    GlobalCollection *m_ip_collection;
+    Collection *m_global_collection;
+    Collection *m_ip_collection;
 };
 
 }  // namespace collection
@@ -97,6 +96,6 @@ class Collections :
 #endif
 
 
-#endif  // HEADERS_MODSECURITY_TRANSACTION_COLLECTIONS_H_
+#endif  // HEADERS_MODSECURITY_COLLECTION_COLLECTIONS_H_
 
 
diff --git a/headers/modsecurity/collection/global_collection.h b/headers/modsecurity/collection/global_collection.h
deleted file mode 100644
index 67624360..00000000
--- a/headers/modsecurity/collection/global_collection.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * ModSecurity, http://www.modsecurity.org/
- * Copyright (c) 2015 Trustwave Holdings, Inc. (http://www.trustwave.com/)
- *
- * You may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * If any of the files related to licensing are missing or if you have any
- * other questions related to licensing please contact Trustwave Holdings, Inc.
- * directly using the email address security@modsecurity.org.
- *
- */
-
-
-#ifdef __cplusplus
-#include <algorithm>
-#include <iostream>
-#include <list>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#endif
-
-#include "modsecurity/collection/collection.h"
-#include "modsecurity/collection/variable.h"
-
-
-#ifndef HEADERS_MODSECURITY_TRANSACTION_GLOBAL_COLLECTION_H_
-#define HEADERS_MODSECURITY_TRANSACTION_GLOBAL_COLLECTION_H_
-
-#ifndef __cplusplus
-typedef struct GlobalCollection_t GlobalCollection;
-#endif
-
-#ifdef __cplusplus
-namespace modsecurity {
-namespace collection {
-
-class CollectionKey {
- public:
-    CollectionKey()
-        : m_compartiment(""),
-        m_name("") { }
-    explicit CollectionKey(std::string name)
-        : m_compartiment(""),
-        m_name(name) { }
-    CollectionKey(std::string name, std::string compartiment)
-        : m_compartiment(compartiment),
-        m_name(name) { }
-
-    std::string m_name;
-    std::string m_compartiment;
-};
-
-
-class collection_hash {
- public:
-    size_t operator()(const CollectionKey *v) const {
-        size_t h = 0;
-        std::for_each(v->m_name.begin(), v->m_name.end(), [&](char c) {
-            h += tolower(c);
-        });
-        std::for_each(v->m_compartiment.begin(),
-            v->m_compartiment.end(), [&](char c) {
-            h += tolower(c);
-        });
-
-        return h;
-    }
-};
-
-
-class collection_equal {
- public:
-    bool operator()(const CollectionKey *u, const CollectionKey *v) const {
-        return u->m_name == v->m_name
-            && u->m_compartiment == v->m_compartiment;
-    }
-};
-
-
-class GlobalCollection :
-    public std::unordered_multimap<CollectionKey *, std::string,
-        collection_hash, collection_equal> {
- public:
-    GlobalCollection();
-    ~GlobalCollection();
-    void store(std::string key, std::string compartment, std::string value);
-
-    bool storeOrUpdateFirst(const std::string &key, std::string compartment,
-        const std::string &value);
-
-    bool updateFirst(const std::string &key, std::string compartment,
-        const std::string &value);
-
-    void del(const std::string& key, std::string compartment);
-
-    std::string* resolveFirst(const std::string& var, std::string compartment);
-    void resolveSingleMatch(const std::string& var, std::string compartment,
-        std::vector<const Variable *> *l);
-    void resolveMultiMatches(const std::string& var, std::string compartment,
-        std::vector<const Variable *> *l);
-
-    void resolveRegularExpression(const std::string& var,
-        std::string compartment,
-        std::vector<const Variable *> *l);
-};
-
-}  // namespace collection
-}  // namespace modsecurity
-
-#endif
-
-
-#endif  // HEADERS_MODSECURITY_TRANSACTION_GLOBAL_COLLECTION_H_
-
-
diff --git a/headers/modsecurity/collection/variable.h b/headers/modsecurity/collection/variable.h
index 6c2a0211..10454450 100644
--- a/headers/modsecurity/collection/variable.h
+++ b/headers/modsecurity/collection/variable.h
@@ -19,8 +19,8 @@
 #endif
 
 
-#ifndef HEADERS_MODSECURITY_TRANSACTION_VARIABLE_H_
-#define HEADERS_MODSECURITY_TRANSACTION_VARIABLE_H_
+#ifndef HEADERS_MODSECURITY_COLLECTION_VARIABLE_H_
+#define HEADERS_MODSECURITY_COLLECTION_VARIABLE_H_
 
 
 #ifndef __cplusplus
@@ -44,4 +44,4 @@ class Variable {
 }  // namespace modsecurity
 #endif
 
-#endif  // HEADERS_MODSECURITY_TRANSACTION_VARIABLE_H_
+#endif  // HEADERS_MODSECURITY_COLLECTION_VARIABLE_H_
diff --git a/headers/modsecurity/modsecurity.h b/headers/modsecurity/modsecurity.h
index 52f1ea53..060449f3 100644
--- a/headers/modsecurity/modsecurity.h
+++ b/headers/modsecurity/modsecurity.h
@@ -93,7 +93,6 @@ typedef struct ModSecurity_t modsecurity;
 #include "modsecurity/transaction.h"
 #include "modsecurity/debug_log.h"
 #include "modsecurity/rules.h"
-#include "modsecurity/collection/global_collection.h"
 
 /**
  * TAG_NUM:
@@ -223,8 +222,9 @@ class ModSecurity {
      NUMBER_OF_PHASES,
     };
 
-    collection::GlobalCollection m_global_collection;
-    collection::GlobalCollection m_ip_collection;
+    collection::Collection *m_global_collection;
+    collection::Collection *m_ip_collection;
+
  private:
     std::string m_connector;
     LogCb m_logCb;
diff --git a/src/Makefile.am b/src/Makefile.am
index 026a047b..0968524d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -34,7 +34,6 @@ pkginclude_HEADERS = \
 libmodsecurity_includesub_HEADERS = \
 	../headers/modsecurity/collection/collection.h \
 	../headers/modsecurity/collection/collections.h \
-	../headers/modsecurity/collection/global_collection.h \
 	../headers/modsecurity/collection/variable.h
 
 
@@ -175,7 +174,6 @@ UTILS = \
 
 COLLECTION = \
 	collection/collections.cc \
-	collection/global_collections.cc \
 	collection/backend/in_memory-per_process.cc
 
 
diff --git a/src/collection/backend/in_memory-per_process.cc b/src/collection/backend/in_memory-per_process.cc
index 4269e051..f56acdc5 100644
--- a/src/collection/backend/in_memory-per_process.cc
+++ b/src/collection/backend/in_memory-per_process.cc
@@ -53,7 +53,8 @@ bool InMemoryPerProcess::storeOrUpdateFirst(const std::string &key,
 }
 
 
-bool InMemoryPerProcess::updateFirst(const std::string &key, const std::string &value) {
+bool InMemoryPerProcess::updateFirst(const std::string &key,
+    const std::string &value) {
     auto range = this->equal_range(key);
 
     for (auto it = range.first; it != range.second; ++it) {
@@ -121,6 +122,63 @@ std::string* InMemoryPerProcess::resolveFirst(const std::string& var) {
     return NULL;
 }
 
+
+void InMemoryPerProcess::store(std::string key, std::string compartment,
+    std::string value) {
+    std::string nkey = key + "::" + compartment;
+    store(nkey, value);
+}
+
+
+bool InMemoryPerProcess::storeOrUpdateFirst(const std::string &key,
+    std::string compartment, const std::string &value) {
+    std::string nkey = key + "::" + compartment;
+    return storeOrUpdateFirst(nkey, value);
+}
+
+
+bool InMemoryPerProcess::updateFirst(const std::string &key,
+    std::string compartment, const std::string &value) {
+    std::string nkey = key + "::" + compartment;
+    return updateFirst(nkey, value);
+}
+
+
+void InMemoryPerProcess::del(const std::string& key,
+    std::string compartment) {
+    std::string nkey = key + "::" + compartment;
+    del(nkey);
+}
+
+
+std::string* InMemoryPerProcess::resolveFirst(const std::string& var,
+    std::string compartment) {
+    std::string nkey = var + "::" + compartment;
+    return resolveFirst(nkey);
+}
+
+
+void InMemoryPerProcess::resolveSingleMatch(const std::string& var,
+    std::string compartment, std::vector<const Variable *> *l) {
+    std::string nkey = var + "::" + compartment;
+    resolveSingleMatch(nkey, l);
+}
+
+
+void InMemoryPerProcess::resolveMultiMatches(const std::string& var,
+    std::string compartment, std::vector<const Variable *> *l) {
+    std::string nkey = var + "::" + compartment;
+    resolveMultiMatches(nkey, l);
+}
+
+
+void InMemoryPerProcess::resolveRegularExpression(const std::string& var,
+    std::string compartment, std::vector<const Variable *> *l) {
+    std::string nkey = var + "::" + compartment;
+    resolveRegularExpression(nkey, l);
+}
+
+
 }  // namespace backend
 }  // namespace collection
 }  // namespace modsecurity
diff --git a/src/collection/backend/in_memory-per_process.h b/src/collection/backend/in_memory-per_process.h
index d821b1b4..bca65824 100644
--- a/src/collection/backend/in_memory-per_process.h
+++ b/src/collection/backend/in_memory-per_process.h
@@ -27,8 +27,8 @@
 #include "modsecurity/collection/variable.h"
 #include "modsecurity/collection/collection.h"
 
-#ifndef HEADERS_MODSECURITY_COLLECTION_BACKEND_IN_MEMORY_PER_PROCESS_H_
-#define HEADERS_MODSECURITY_COLLECTION_BACKEND_IN_MEMORY_PER_PROCESS_H_
+#ifndef SRC_COLLECTION_BACKEND_IN_MEMORY_PER_PROCESS_H_
+#define SRC_COLLECTION_BACKEND_IN_MEMORY_PER_PROCESS_H_
 
 #ifdef __cplusplus
 namespace modsecurity {
@@ -46,14 +46,11 @@ namespace backend {
  */
 struct MyEqual {
     bool operator()(const std::string& Left, const std::string& Right) const {
-        /*
         return Left.size() == Right.size()
              && std::equal(Left.begin(), Left.end(), Right.begin(),
             [](char a, char b) {
             return tolower(a) == tolower(b);
         });
-        */
-        return Left == Right;
     }
 };
 
@@ -75,23 +72,41 @@ class InMemoryPerProcess :
  public:
     InMemoryPerProcess();
     ~InMemoryPerProcess();
-    void store(std::string key, std::string value);
+    void store(std::string key, std::string value) override;
 
     bool storeOrUpdateFirst(const std::string &key,
-        const std::string &value);
+        const std::string &value) override;
 
-    bool updateFirst(const std::string &key, const std::string &value);
+    bool updateFirst(const std::string &key,
+        const std::string &value) override;
 
-    void del(const std::string& key);
+    void del(const std::string& key) override;
 
-    std::string* resolveFirst(const std::string& var);
+    std::string* resolveFirst(const std::string& var) override;
 
     void resolveSingleMatch(const std::string& var,
-        std::vector<const Variable *> *l);
+        std::vector<const Variable *> *l) override;
     void resolveMultiMatches(const std::string& var,
-        std::vector<const Variable *> *l);
+        std::vector<const Variable *> *l) override;
     void resolveRegularExpression(const std::string& var,
-        std::vector<const Variable *> *l);
+        std::vector<const Variable *> *l) override;
+
+    void store(std::string key, std::string compartment,
+        std::string value) override;
+    bool storeOrUpdateFirst(const std::string &key, std::string compartment,
+        const std::string &value) override;
+    bool updateFirst(const std::string &key, std::string compartment,
+        const std::string &value) override;
+    void del(const std::string& key, std::string compartment) override;
+
+    std::string* resolveFirst(const std::string& var,
+        std::string compartment) override;
+    void resolveSingleMatch(const std::string& var, std::string compartment,
+        std::vector<const Variable *> *l) override;
+    void resolveMultiMatches(const std::string& var, std::string compartment,
+        std::vector<const Variable *> *l) override;
+    void resolveRegularExpression(const std::string& var,
+        std::string compartment, std::vector<const Variable *> *l) override;
 };
 
 }  // namespace backend
@@ -100,4 +115,4 @@ class InMemoryPerProcess :
 #endif
 
 
-#endif  // HEADERS_MODSECURITY_COLLECTION_BACKEND_IN_MEMORY_PER_PROCESS_H_
+#endif  // SRC_COLLECTION_BACKEND_IN_MEMORY_PER_PROCESS_H_
diff --git a/src/collection/collections.cc b/src/collection/collections.cc
index 515233f7..f67a48eb 100644
--- a/src/collection/collections.cc
+++ b/src/collection/collections.cc
@@ -33,8 +33,8 @@ namespace modsecurity {
 namespace collection {
 
 
-Collections::Collections(GlobalCollection *global,
-    GlobalCollection *ip)
+Collections::Collections(Collection *global,
+    Collection *ip)
     : m_global_collection_key(""),
     m_ip_collection_key(""),
     m_global_collection(global),
@@ -139,7 +139,8 @@ std::string* Collections::resolveFirst(const std::string& collectionName,
 
         for (auto &a : *this) {
             if (tolower(a.first) == tolower(collectionName)) {
-                std::string *res = a.second->resolveFirst(toupper(a.first) + ":" + var);
+                std::string *res = a.second->resolveFirst(toupper(a.first)
+                    + ":" + var);
                 if (res != NULL) {
                     return res;
                 }
diff --git a/src/collection/global_collections.cc b/src/collection/global_collections.cc
deleted file mode 100644
index ddf20348..00000000
--- a/src/collection/global_collections.cc
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * ModSecurity, http://www.modsecurity.org/
- * Copyright (c) 2015 Trustwave Holdings, Inc. (http://www.trustwave.com/)
- *
- * You may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * If any of the files related to licensing are missing or if you have any
- * other questions related to licensing please contact Trustwave Holdings, Inc.
- * directly using the email address security@modsecurity.org.
- *
- */
-
-
-#include "modsecurity/collection/global_collection.h"
-
-#ifdef __cplusplus
-#include <string>
-#include <iostream>
-#include <unordered_map>
-#include <list>
-#endif
-
-#include "src/utils.h"
-
-namespace modsecurity {
-namespace collection {
-
-
-GlobalCollection::GlobalCollection() {
-    this->reserve(1000);
-}
-
-GlobalCollection::~GlobalCollection() {
-    this->clear();
-}
-
-void GlobalCollection::store(std::string key, std::string compartment,
-    std::string value) {
-    this->emplace(new CollectionKey(key, compartment), value);
-}
-
-
-bool GlobalCollection::storeOrUpdateFirst(const std::string &key,
-    std::string compartment, const std::string &value) {
-    if (updateFirst(key, compartment, value) == false) {
-        store(key, compartment, value);
-    }
-    return true;
-}
-
-
-bool GlobalCollection::updateFirst(const std::string &key,
-    std::string compartment, const std::string &value) {
-    auto range = this->equal_range(new CollectionKey(key, compartment));
-
-    for (auto it = range.first; it != range.second; ++it) {
-        it->second = value;
-        return true;
-    }
-    return false;
-}
-
-
-void GlobalCollection::del(const std::string& key, std::string compartment) {
-    this->erase(new CollectionKey(key, compartment));
-}
-
-
-
-void GlobalCollection::resolveSingleMatch(const std::string& var,
-    std::string compartment, std::vector<const Variable *> *l) {
-    auto range = this->equal_range(new CollectionKey(var, compartment));
-
-    for (auto it = range.first; it != range.second; ++it) {
-        l->push_back(new Variable(var, it->second));
-    }
-}
-
-void GlobalCollection::resolveMultiMatches(const std::string& var,
-    std::string compartment, std::vector<const Variable *> *l) {
-    size_t keySize = var.size();
-    l->reserve(15);
-
-    auto range = this->equal_range(new CollectionKey(var, compartment));
-
-    for (auto it = range.first; it != range.second; ++it) {
-        l->insert(l->begin(), new Variable(var, it->second));
-    }
-
-    for (const auto& x : *this) {
-        if (x.first->m_name.size() <= keySize + 1) {
-            continue;
-        }
-        if (x.first->m_name.at(keySize) != ':') {
-            continue;
-        }
-        if (x.first->m_name.compare(0, keySize, var) != 0) {
-            continue;
-        }
-        l->insert(l->begin(),
-            new Variable(x.first->m_name, x.second));
-    }
-}
-
-
-void GlobalCollection::resolveRegularExpression(const std::string& var,
-     std::string compartment, std::vector<const Variable *> *l) {
-    /* Not ready */
-}
-
-
-std::string* GlobalCollection::resolveFirst(const std::string& var,
-    std::string compartment) {
-    auto range = equal_range(new CollectionKey(var, compartment));
-
-    for (auto it = range.first; it != range.second; ++it) {
-        return &it->second;
-    }
-
-    return NULL;
-}
-
-
-}  // namespace collection
-}  // namespace modsecurity
diff --git a/src/collections/collection.cc b/src/collections/collection.cc
deleted file mode 100644
index bcf77705..00000000
--- a/src/collections/collection.cc
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * ModSecurity, http://www.modsecurity.org/
- * Copyright (c) 2015 Trustwave Holdings, Inc. (http://www.trustwave.com/)
- *
- * You may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * If any of the files related to licensing are missing or if you have any
- * other questions related to licensing please contact Trustwave Holdings, Inc.
- * directly using the email address security@modsecurity.org.
- *
- */
-
-
-#include "modsecurity/transaction/collections.h"
-
-#ifdef __cplusplus
-#include <string>
-#include <iostream>
-#include <unordered_map>
-#include <list>
-#endif
-
-#include "modsecurity/transaction/variable.h"
-#include "src/utils.h"
-
-namespace modsecurity {
-namespace transaction {
-
-
-Collection::Collection() {
-    this->reserve(1000);
-}
-
-Collection::~Collection() {
-    this->clear();
-}
-
-void Collection::store(std::string key, std::string value) {
-    this->emplace(key, value);
-}
-
-
-bool Collection::storeOrUpdateFirst(const std::string &key,
-    const std::string &value) {
-    if (updateFirst(key, value) == false) {
-        store(key, value);
-    }
-    return true;
-}
-
-
-bool Collection::updateFirst(const std::string &key, const std::string &value) {
-    auto range = this->equal_range(key);
-
-    for (auto it = range.first; it != range.second; ++it) {
-        it->second = value;
-        return true;
-    }
-    return false;
-}
-
-
-void Collection::del(const std::string& key) {
-    this->erase(key);
-}
-
-
-void Collection::resolveSingleMatch(const std::string& var,
-    std::vector<const transaction::Variable *> *l) {
-    auto range = this->equal_range(var);
-
-    for (auto it = range.first; it != range.second; ++it) {
-        l->push_back(new transaction::Variable(var, it->second));
-    }
-}
-
-
-void Collection::resolveMultiMatches(const std::string& var,
-    std::vector<const transaction::Variable *> *l) {
-    size_t keySize = var.size();
-    l->reserve(15);
-
-    auto range = this->equal_range(var);
-
-    for (auto it = range.first; it != range.second; ++it) {
-        l->insert(l->begin(), new transaction::Variable(var, it->second));
-    }
-
-    for (const auto& x : *this) {
-        if (x.first.size() <= keySize + 1) {
-            continue;
-        }
-        if (x.first.at(keySize) != ':') {
-            continue;
-        }
-        if (x.first.compare(0, keySize, var) != 0) {
-            continue;
-        }
-        l->insert(l->begin(), new transaction::Variable(x.first, x.second));
-    }
-}
-
-
-void Collection::resolveRegularExpression(const std::string& var,
-    std::vector<const transaction::Variable *> *l) {
-    /* Not ready */
-}
-
-
-std::string* Collection::resolveFirst(const std::string& var) {
-    auto range = equal_range(var);
-
-    for (auto it = range.first; it != range.second; ++it) {
-        return &it->second;
-    }
-
-    return NULL;
-}
-
-
-}  // namespace transaction
-}  // namespace modsecurity
diff --git a/src/collections/collections.cc b/src/collections/collections.cc
deleted file mode 100644
index 04fa5cda..00000000
--- a/src/collections/collections.cc
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- * ModSecurity, http://www.modsecurity.org/
- * Copyright (c) 2015 Trustwave Holdings, Inc. (http://www.trustwave.com/)
- *
- * You may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * If any of the files related to licensing are missing or if you have any
- * other questions related to licensing please contact Trustwave Holdings, Inc.
- * directly using the email address security@modsecurity.org.
- *
- */
-
-
-#include "modsecurity/transaction/collections.h"
-
-#ifdef __cplusplus
-#include <string>
-#include <iostream>
-#include <unordered_map>
-#include <list>
-#include <vector>
-#endif
-
-#include "modsecurity/transaction/variable.h"
-#include "modsecurity/transaction/collection.h"
-#include "src/utils.h"
-
-namespace modsecurity {
-namespace transaction {
-
-
-Collections::Collections(GlobalCollection *global,
-    GlobalCollection *ip)
-    : m_global_collection_key(""),
-    m_ip_collection_key(""),
-    m_global_collection(global),
-    m_ip_collection(ip) {
-    /* Create collection TX */
-    this->emplace("TX", new Collection());
-}
-
-
-Collections::~Collections() {
-    for (const auto &thing : *this) {
-        delete thing.second;
-    }
-    this->clear();
-}
-
-void Collections::storeOrUpdateFirst(const std::string& collectionName,
-    const std::string& variableName,
-    const std::string& targetValue) {
-    if (tolower(collectionName) == "ip"
-        && !m_ip_collection_key.empty()) {
-        m_ip_collection->storeOrUpdateFirst(collectionName + ":"
-            + variableName, m_ip_collection_key, targetValue);
-        return;
-    }
-
-    if (tolower(collectionName) == "global"
-        && !m_global_collection_key.empty()) {
-        m_global_collection->storeOrUpdateFirst(collectionName + ":"
-            + variableName, m_global_collection_key, targetValue);
-        return;
-    }
-
-    try {
-        Collection *collection;
-        collection = this->at(collectionName);
-        collection->storeOrUpdateFirst(collectionName + ":"
-            + variableName, targetValue);
-    } catch (...) {
-#if 0
-        debug(9, "don't know any collection named: "
-            + collectionName + ". it was created?");
-#endif
-    }
-}
-
-
-void Collections::store(std::string key, std::string value) {
-    m_transient.store(key, value);
-}
-
-
-bool Collections::storeOrUpdateFirst(const std::string &key,
-    const std::string &value) {
-    return m_transient.storeOrUpdateFirst(key, value);
-}
-
-
-bool Collections::updateFirst(const std::string &key,
-    const std::string &value) {
-    return m_transient.updateFirst(key, value);
-}
-
-
-void Collections::del(const std::string& key) {
-    return m_transient.del(key);
-}
-
-
-std::string* Collections::resolveFirst(const std::string& var) {
-    std::string *transientVar = m_transient.resolveFirst(var);
-
-    if (transientVar != NULL) {
-        return transientVar;
-    }
-
-    for (auto &a : *this) {
-        auto range = a.second->equal_range(var);
-        for (auto it = range.first; it != range.second; ++it) {
-            return & it->second;
-        }
-    }
-
-    return NULL;
-}
-
-
-std::string* Collections::resolveFirst(const std::string& collectionName,
-        const std::string& var) {
-        if (tolower(collectionName) == "ip"
-            && !m_ip_collection_key.empty()) {
-            return m_ip_collection->resolveFirst(toupper(collectionName)
-                    + ":" + var, m_ip_collection_key);
-        }
-
-        if (tolower(collectionName) == "global"
-            && !m_global_collection_key.empty()) {
-            return m_global_collection->resolveFirst(toupper(collectionName)
-                    + ":" + var, m_global_collection_key);
-        }
-
-        for (auto &a : *this) {
-            if (tolower(a.first) == tolower(collectionName)) {
-                Collection *t = a.second;
-                auto range = t->equal_range(toupper(collectionName)
-                    + ":" + var);
-                for (auto it = range.first; it != range.second; ++it) {
-                    return &it->second;
-                }
-            }
-        }
-
-        return NULL;
-}
-
-
-void Collections::resolveSingleMatch(const std::string& var,
-    std::vector<const transaction::Variable *> *l) {
-
-    m_transient.resolveSingleMatch(var, l);
-}
-
-
-void Collections::resolveSingleMatch(const std::string& var,
-    const std::string& collection,
-    std::vector<const transaction::Variable *> *l) {
-
-    if (tolower(collection) == "ip"
-        && !m_ip_collection_key.empty()) {
-        m_ip_collection->resolveSingleMatch(var, m_ip_collection_key, l);
-        return;
-    }
-
-    if (tolower(collection) == "global"
-        && !m_global_collection_key.empty()) {
-        m_global_collection->resolveSingleMatch(var,
-            m_global_collection_key, l);
-        return;
-    }
-
-    try {
-        this->at(collection)->resolveSingleMatch(var, l);
-    } catch (...) { }
-}
-
-void Collections::resolveMultiMatches(const std::string& var,
-    std::vector<const transaction::Variable *> *l) {
-
-    m_transient.resolveMultiMatches(var, l);
-}
-
-
-void Collections::resolveMultiMatches(const std::string& var,
-    const std::string& collection,
-    std::vector<const transaction::Variable *> *l) {
-    if (tolower(collection) == "ip"
-        && !m_ip_collection_key.empty()) {
-        m_ip_collection->resolveMultiMatches(var, m_ip_collection_key, l);
-        return;
-    }
-
-    if (tolower(collection) == "global"
-        && !m_global_collection_key.empty()) {
-        m_global_collection->resolveMultiMatches(var,
-            m_global_collection_key, l);
-        return;
-    }
-
-    try {
-        this->at(collection)->resolveMultiMatches(var, l);
-    } catch (...) { }
-}
-
-void Collections::resolveRegularExpression(const std::string& var,
-    std::vector<const transaction::Variable *> *l) {
-    m_transient.resolveRegularExpression(var, l);
-}
-
-
-void Collections::resolveRegularExpression(const std::string& var,
-    const std::string& collection,
-    std::vector<const transaction::Variable *> *l) {
-    if (tolower(collection) == "ip"
-        && !m_ip_collection_key.empty()) {
-        m_ip_collection->resolveRegularExpression(toupper(collection)
-            + ":" + var, m_ip_collection_key, l);
-        return;
-    }
-
-    if (tolower(collection) == "global"
-        && !m_global_collection_key.empty()) {
-        m_global_collection->resolveRegularExpression(toupper(collection)
-            + ":" + var, m_global_collection_key, l);
-        return;
-    }
-
-    try {
-        this->at(collection)->resolveRegularExpression(var, l);
-    } catch (...) { }
-}
-
-}  // namespace transaction
-}  // namespace modsecurity
diff --git a/src/modsecurity.cc b/src/modsecurity.cc
index 0aeee50c..61fa83d4 100644
--- a/src/modsecurity.cc
+++ b/src/modsecurity.cc
@@ -18,6 +18,7 @@
 
 #include "modsecurity/modsecurity.h"
 #include "modsecurity/rule.h"
+#include "src/collection/backend/in_memory-per_process.h"
 #include "src/config.h"
 #include "src/unique_id.h"
 #ifdef MSC_WITH_CURL
@@ -45,6 +46,8 @@ namespace modsecurity {
  */
 ModSecurity::ModSecurity()
     : m_connector(""),
+    m_global_collection(new collection::backend::InMemoryPerProcess()),
+    m_ip_collection(new collection::backend::InMemoryPerProcess()),
     m_logCb(NULL) {
     UniqueId::uniqueId();
     srand(time(NULL));
diff --git a/src/transaction.cc b/src/transaction.cc
index f5816e44..c99a3020 100644
--- a/src/transaction.cc
+++ b/src/transaction.cc
@@ -112,7 +112,7 @@ Transaction::Transaction(ModSecurity *ms, Rules *rules, void *logCbData)
     m_creationTimeStamp(cpu_seconds()),
     m_logCbData(logCbData),
     m_ms(ms),
-    m_collections(&ms->m_global_collection, &ms->m_ip_collection) {
+    m_collections(ms->m_global_collection, ms->m_ip_collection) {
     m_id = std::to_string(this->m_timeStamp) + \
         std::to_string(generate_transaction_unique_id());
     m_rules->incrementReferenceCount();