ngx_cpp_module

Author: Chrono Law

ngxpp/Nginx.hpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NGX_COMMON_HEADERS_HPP
+#define _NGX_COMMON_HEADERS_HPP
+
+extern "C" {
+
+#include <ngx_http.h>
+
+}
+
+#include <cassert>
+#include <boost/core/ignore_unused.hpp>
+
+#define ngx_cpp_version 1000000
+#define NGX_CPP_VERSION "1.0.0"
+
+#endif  //_NGX_COMMON_HEADERS_HPP

ngxpp/NgxAll.hpp

@@ -0,0 +1,40 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NGX_ALL_HPP
+#define _NGX_ALL_HPP
+
+#include "Nginx.hpp"
+
+#include "NgxWrapper.hpp"
+
+#include "NgxValue.hpp"
+#include "NgxException.hpp"
+#include "NgxPool.hpp"
+#include "NgxAllocator.hpp"
+#include "NgxString.hpp"
+#include "NgxLog.hpp"
+#include "NgxClock.hpp"
+#include "NgxDatetime.hpp"
+
+#include "NgxArray.hpp"
+#include "NgxList.hpp"
+#include "NgxQueue.hpp"
+#include "NgxBuf.hpp"
+//#include "NgxFile.hpp"
+
+#include "NgxConfig.hpp"
+
+#include "NgxModule.hpp"
+#include "NgxHttpModule.hpp"
+
+#include "NgxRequest.hpp"
+#include "NgxFilter.hpp"
+#include "NgxUpstream.hpp"
+#include "NgxLoadBalance.hpp"
+#include "NgxSubRequest.hpp"
+
+#include "NgxDigest.hpp"
+#include "NgxTimer.hpp"
+#include "NgxVariable.hpp"
+
+#endif  //_NGX_ALL_HPP

ngxpp/NgxAllocator.hpp

@@ -0,0 +1,84 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NGX_ALLOCATOR_HPP
+#define _NGX_ALLOCATOR_HPP
+
+#include "NgxWrapper.hpp"
+
+template<typename T>
+class NgxAlloctor : public NgxWrapper<ngx_pool_t>
+{
+public:
+    typedef NgxWrapper<ngx_pool_t> super_type;
+    typedef NgxAlloctor this_type;
+public:
+    typedef std::size_t     size_type;
+    typedef std::ptrdiff_t  difference_type;
+    typedef T*              pointer;
+    typedef const T*        const_pointer;
+    typedef T&              reference;
+    typedef const T&        const_reference;
+    typedef T               value_type;
+
+    template<typename U>
+    struct rebind
+    {
+        typedef NgxAlloctor<U> other;
+    };
+public:
+    NgxAlloctor(ngx_pool_t* p) : super_type(p)
+    {}
+
+    ~NgxAlloctor() = default;
+/*
+public:
+    pointer address(reference r) const
+    {
+        return &r;
+    }
+
+    const_pointer address(const_reference r) const
+    {
+        return &r;
+    }
+
+    size_type max_size() const
+    {
+        return std::numeric_limits<size_type>::max();
+    }
+*/
+public:
+    pointer allocate(size_type n)
+    {
+        return reinterpret_cast<pointer>(
+                    ngx_pnalloc(get(), n * sizeof(T)));
+    }
+
+    void deallocate(pointer ptr, size_type n)
+    {
+        boost::ignore_unused(n);
+        ngx_pfree(get(), ptr);
+    }
+/*
+public:
+    bool operator==(const NgxAlloctor& o) const
+    {
+        return get() == o.get();
+    }
+
+    bool operator!=(const NgxAlloctor& o) const
+    {
+        return get() != o.get();
+    }
+*/
+};
+
+#ifdef NGX_STD_CONTAINER
+#include <vector>
+
+template<typename T>
+using NgxStdVector = std::vector<T, NgxAlloctor<T> >;
+
+#endif
+
+#endif  //_NGX_ALLOCATOR_HPP

ngxpp/NgxArray.hpp

@@ -0,0 +1,87 @@
+// Copyright (c) 2015
+// Author: Chrono Law
+#ifndef _NGX_ARRAY_HPP
+#define _NGX_ARRAY_HPP
+
+#include "NgxPool.hpp"
+
+template<typename T>
+class NgxArray final : public NgxWrapper<ngx_array_t>
+{
+public:
+    typedef NgxWrapper<ngx_array_t> super_type;
+    typedef NgxArray this_type;
+
+    typedef T value_type;
+public:
+    NgxArray(const NgxPool& p, ngx_uint_t n = 10):
+        super_type(p.array<T>(n))
+    {}
+
+    NgxArray(ngx_array_t* arr):super_type(arr)
+    {}
+
+    NgxArray(ngx_array_t& arr):super_type(arr)
+    {}
+
+    ~NgxArray() = default;
+public:
+    ngx_uint_t size() const
+    {
+        return get()?get()->nelts:0;
+    }
+
+    T& operator[](ngx_uint_t i) const
+    {
+        NgxException::require(i < size() && get());
+
+        return elts()[i];
+    }
+
+public:
+    template<typename V>
+    void visit(V v) const
+    {
+        auto p = elts();
+
+        for(ngx_uint_t i = 0;i < size(); ++i)
+        {
+            v(p[i]);
+        }
+    }
+public:
+    T& prepare() const
+    {
+        auto tmp = ngx_array_push(get());
+
+        NgxException::require(tmp);
+
+        assert(tmp);
+        return *reinterpret_cast<T*>(tmp);
+    }
+
+    void push(const T& x) const
+    {
+        prepare() = x;
+    }
+public:
+    void merge(const this_type& a) const
+    {
+        auto f = [this](const value_type& v)
+        {
+            prepare() = v;
+        };
+
+        a.visit(f);
+    }
+private:
+    T* elts() const
+    {
+        return reinterpret_cast<T*>(get()->elts);
+    }
+};
+
+typedef NgxArray<ngx_str_t> NgxStrArray;
+typedef NgxArray<ngx_keyval_t> NgxKvArray;
+
+#endif  //_NGX_ARRAY_HPP