@digitalshieldfe/react-native-backup-card-sdk 0.1.1 → 0.1.3

package/android/src/main/jni/GPChannel/include/utility/mutex.h

@@ -0,0 +1,24 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/* 
+ * File:   mutex.h
+ * Author: zxc_work
+ *
+ * Created on 2020年2月22日, 下午2:08
+ */
+#pragma once
+
+#ifndef MUTEX_H
+#define MUTEX_H
+#include <mutex>
+
+extern std::mutex _mutex;
+
+#define CREATE_THREAD_LOCK_GUARD  std::lock_guard<std::mutex> lck(_mutex);
+
+#endif /* MUTEX_H */
+

package/android/src/main/jni/GPChannel/include/utility/trim.hpp

@@ -0,0 +1,155 @@
+//
+//  trim.hpp
+//  JubSDK
+//
+//  Created by panmin on 2019/9/26.
+//  Copyright © 2019 JuBiter. All rights reserved.
+//
+
+#ifndef trim_h
+#define trim_h
+
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+#include <iostream>
+#include <functional>
+
+namespace jub {
+namespace algorithm {
+
+namespace detail {
+//    template< typename ForwardIteratorT, typename PredicateT >
+//    inline ForwardIteratorT trim_end_iter_select(
+//                                                 ForwardIteratorT InBegin,
+//                                                 ForwardIteratorT InEnd,
+//                                                 PredicateT IsSpace,
+//                                                 std::forward_iterator_tag )
+//    {
+//        ForwardIteratorT TrimIt=InBegin;
+//
+//        for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
+//        {
+//            if ( !IsSpace(*It) )
+//            {
+//                TrimIt=It;
+//                ++TrimIt;
+//            }
+//        }
+//
+//        return TrimIt;
+//    }
+//
+//    template< typename ForwardIteratorT, typename PredicateT >
+//    inline ForwardIteratorT trim_end_iter_select(
+//                                                 ForwardIteratorT InBegin,
+//                                                 ForwardIteratorT InEnd,
+//                                                 PredicateT IsSpace,
+//                                                 std::bidirectional_iterator_tag )
+//    {
+//        for( ForwardIteratorT It=InEnd; It!=InBegin;  )
+//        {
+//            if ( !IsSpace(*(--It)) )
+//                return ++It;
+//        }
+//
+//        return InBegin;
+//    }
+
+template< typename ForwardIteratorT, typename PredicateT >
+inline ForwardIteratorT eTrim_iter_select(ForwardIteratorT InBegin,
+                                          ForwardIteratorT InEnd,
+                                          PredicateT IsSpace,
+                                          std::forward_iterator_tag ) {
+    ForwardIteratorT TrimIt=InBegin;
+    
+    for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
+    {
+        if ( !IsSpace(*It) )
+        {
+            TrimIt=It;
+            ++TrimIt;
+        }
+    }
+    
+    return TrimIt;
+}
+
+//    // Search for first non matching character from the beginning of the sequence
+//    template< typename ForwardIteratorT, typename PredicateT >
+//    inline ForwardIteratorT trim_begin(
+//                                       ForwardIteratorT InBegin,
+//                                       ForwardIteratorT InEnd,
+//                                       PredicateT IsSpace )
+//    {
+//        ForwardIteratorT It=InBegin;
+//        for(; It!=InEnd; ++It )
+//        {
+//            if (!IsSpace(*It))
+//                return It;
+//        }
+//
+//        return It;
+//    }
+template< typename ForwardIteratorT, typename PredicateT >
+inline ForwardIteratorT eTrim(ForwardIteratorT InBegin,
+                              ForwardIteratorT InEnd,
+                              PredicateT IsSpace ) {
+    typename std::iterator_traits<ForwardIteratorT>::iterator_category category;
+    return eTrim_iter_select(InBegin, InEnd, IsSpace, category);
+}
+
+} // namespace detail end
+
+template<typename SequenceT>
+inline SequenceT& lTrim(SequenceT &Input) {
+    auto p = find_if(Input.begin(), Input.end(), std::not1(std::function<bool(char)>(isspace)));
+    Input.erase(Input.begin(), p);
+    return Input;
+}
+
+//template<typename SequenceT, typename PredicateT>
+//inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
+//{
+//    Input.erase(
+//                ::boost::algorithm::detail::trim_end(
+//                                                     ::boost::begin(Input),
+//                                                     ::boost::end(Input),
+//                                                     IsSpace ),
+//                ::boost::end(Input)
+//                );
+//}
+template<typename SequenceT, typename PredicateT>
+inline void rTrim_if(SequenceT& Input, PredicateT IsSpace) {
+    Input.erase(detail::eTrim(Input.begin(),
+                              Input.end(),
+                              IsSpace),
+                Input.end());
+}
+
+//boost::algorithm::trim_right
+//template<typename SequenceT>
+//inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
+//{
+//    ::boost::algorithm::trim_right_if(
+//                                      Input,
+//                                      is_space(Loc) );
+//}
+template<typename SequenceT>
+inline SequenceT& rTrim(SequenceT &Input, const std::locale& Loc=std::locale()) {
+
+    auto p = find_if(Input.rbegin(), Input.rend(), std::not1(std::function<bool(char)>(isspace)));
+    Input.erase(p.base(), Input.end());
+    return Input;
+}
+
+template<typename SequenceT>
+inline SequenceT& trim(SequenceT &st) {
+    lTrim(rTrim(st));
+    return st;
+}
+
+} // namespace algorithm end
+} // namespace jub end
+#endif /* trim_h */

package/android/src/main/jni/GPChannel/include/utility/util.h

@@ -0,0 +1,104 @@
+#pragma once
+#ifndef COINPASS_BIO_UTIL_HPP
+#define COINPASS_BIO_UTIL_HPP
+
+#include <assert.h>
+#include <memory>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+#include <iostream>
+#include <cstring>
+#include "mSIGNA/stdutils/uchar_vector.h"
+//#include "Data.h"
+
+namespace jub {
+
+#define JUB_VERIFY_RET(x, r)    \
+do {                            \
+    if (!(x)) {                 \
+        return (r);             \
+    }                           \
+} while (0)
+
+#define JUB_VERIFY_RV(x)    \
+do {                        \
+    JUB_RV r = (x);         \
+    if (JUBR_OK != r) {     \
+        return r;           \
+    }                       \
+} while (0)
+
+#define JUB_CHECK_NULL(x)               \
+do {                                    \
+    if (!x) {                           \
+        assert(false);                  \
+        return JUBR_MEMORY_NULL_PTR;    \
+    }                                   \
+} while (0)
+
+#define JUB_UNREFERENCED_PARAMETER(P) (P)
+
+//template <class _Ty, size_t _Size>
+//constexpr size_t array_size(const _Ty (&)[_Size]) noexcept {
+//    return (_Size);
+//}
+//
+/*
+* String splitting function
+*/
+//std::vector<std::string> Split(std::string str, std::string pattern);
+/*
+* Merge string function
+*//*
+std::string Join(std::vector<std::string> v, std::string pattern);
+*/
+/*
+ * Decimal string conversion -> Hexadecimal string
+ */
+//std::string DecStringToHexString(std::string str);
+//
+//std::string numberToHexString(unsigned int val);
+//
+/*
+ * char array<uint8_t, 32> -> Hexadecimal string conversion
+ *//*
+std::string CharArray2HexStr(std::array<uint8_t, 32> v);
+*/
+/*
+ * Hexadecimal string conversion -> char array<uint8_t, 32>
+ *//*
+std::array<uint8_t, 32> HexStr2CharArray(std::string str);
+*/
+/*
+* std::vector<unsigned char> -> Hexadecimal string conversion
+*/
+//std::string CharPtr2HexStr(std::vector<unsigned char> v);
+//
+/*
+* Hexadecimal string conversion -> std::vector<unsigned char>
+*/
+//std::vector<unsigned char> HexStr2CharPtr(std::string str);
+/*
+// Put an array of strings into a vector
+std::vector<std::string> CharPtrArr2StrVector(const char* Arr[]);
+*/
+
+//#define ETH_PRDFIX "0x"
+/*
+ * std::vector<unsigned char> -> Hexadecimal string conversion
+ *//*
+std::string ETHCharPtr2HexStr(std::vector<unsigned char> v);
+*/
+/*
+ * Hexadecimal string conversion -> std::vector<unsigned char>
+ */
+//std::vector<unsigned char> ETHHexStr2CharPtr(std::string str);
+//
+//TW::Data ToTlv(uint8_t tag, const TW::Data &data);
+//std::vector<TW::Data> ParseTlv(const TW::Data &data);
+//TW::Data Tollv(const std::string& strData);
+} // namespace jub
+
+#endif

package/android/src/main/jni/GPChannel/include/utility/xFactory.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include <map>
+
+template<typename pI, typename T, typename F>
+class xFactory {
+
+protected:
+	typedef std::map<T, F> FactoryMap;
+	FactoryMap m_FactoryMap;
+
+public:
+	~xFactory() { m_FactoryMap.clear(); }
+
+	void Register(const T & name, F pfnCreate) {
+		m_FactoryMap[name] = pfnCreate;
+	};
+
+	template<typename... Args>
+	pI Create(const T &name, Args&&... args) {
+		auto it = m_FactoryMap.find(name);
+        if (it != m_FactoryMap.end()) {
+			return it->second(std::forward<Args>(args)...);
+        }
+		return nullptr;
+	}
+}; // class xFactory end

package/android/src/main/jni/GPChannel/include/utility/xManager.hpp

@@ -0,0 +1,84 @@
+#pragma once
+#ifndef __xManager__
+#define __xManager__
+
+#include "JUB_SDK.h"
+
+#include <map>
+
+template <class T>
+class xManager {
+public:
+    xManager() {
+        _ID = 0;
+        _last = nullptr;
+    };
+    ~xManager() {
+        ClearAll();
+    };
+
+    JUB_UINT16 AddOne(T* x) {
+        //srand((unsigned int)(time(NULL)));
+        //JUB_UINT16 ID = rand();
+        if (65535 == _ID) {
+            _ID = 0;
+        }
+        //JUB_UINT16 ID  = ++_ID;
+
+        //std::cout << "Add ID:" << ID << std::endl;
+        _mapList.insert(std::make_pair(++_ID, x));
+        return _ID;
+    };
+
+    JUB_UINT16 AddOne(JUB_UINT16 ID, T* x) {
+        _mapList.insert(std::make_pair(ID, x));
+
+        return ID;
+    };
+
+    T* GetLast() {
+        return _last;
+    };
+
+    void ClearLast() { _last = nullptr; };
+
+    void ClearOne(JUB_UINT16 ID) {
+        //std::cout << "Clear ID:" << ID << std::endl;
+        auto it = _mapList.find(ID);
+        if (it != _mapList.end()) {
+            delete it->second;
+            _mapList.erase(it);
+        }
+    }
+
+    void ClearAll() {
+        for (auto it : _mapList) {
+            delete it.second;
+        }
+        _mapList.clear();
+    }
+
+    T* GetOne(JUB_UINT16 ID) {
+        auto it = _mapList.find(ID);
+        if (it != _mapList.end()) {
+            _last = it->second;
+            return it->second;
+        }
+        return nullptr;
+    }
+
+    std::vector<JUB_UINT16> GetHandleList() {
+        std::vector<JUB_UINT16> vHandleList;
+        for (auto it : _mapList) {
+            vHandleList.push_back(it.first);
+        }
+        return vHandleList;
+    }
+
+protected:
+    std::map<JUB_UINT16, T*> _mapList;
+    T* _last;
+    JUB_UINT16 _ID;
+}; // class xManager end
+
+#endif