merging refactor (replacing)

slsSupportLib/CMakeLists.txt

@@ -0,0 +1,71 @@
+set(SOURCES
+    src/ClientInterface.cpp
+    src/CmdLineParser.cpp
+    src/string_utils.cpp
+    src/file_utils.cpp
+    src/ClientSocket.cpp
+    src/DataSocket.cpp
+    src/ServerSocket.cpp
+    src/ServerInterface.cpp
+    src/network_utils.cpp
+)
+
+set(HEADERS
+)
+
+set(PUBLICHEADERS
+    include/ansi.h
+    include/sls_detector_defs.h
+    include/sls_detector_funcs.h
+    include/error_defs.h
+    include/versionAPI.h
+    include/sls_detector_exceptions.h
+    include/file_utils.h
+    include/container_utils.h
+    include/string_utils.h
+    include/ClientInterface.h
+    include/MySocketTCP.h
+    include/genericSocket.h
+    include/logger.h
+    include/ClientSocket.h
+    include/DataSocket.h
+    include/ServerSocket.h
+    include/ServerInterface.h
+    include/network_utils.h
+)
+
+add_library(slsSupportLib SHARED
+    ${SOURCES}
+    ${HEADERS}
+)
+
+check_ipo_supported(RESULT result)
+if(result)
+    set_property(TARGET slsSupportLib PROPERTY INTERPROCEDURAL_OPTIMIZATION True)
+endif()
+
+target_include_directories(slsSupportLib PUBLIC
+    ${ZeroMQ_INCLUDE_DIRS}
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+
+set_target_properties(slsSupportLib PROPERTIES
+    LIBRARY_OUTPUT_NAME SlsSupport
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    PUBLIC_HEADER "${PUBLICHEADERS}"
+)
+
+target_link_libraries(slsSupportLib slsProjectOptions slsProjectWarnings)
+
+if (SLS_USE_TESTS)
+    add_subdirectory(tests)
+endif(SLS_USE_TESTS)
+
+# Install the library
+install(TARGETS slsSupportLib
+    EXPORT "${TARGETS_EXPORT_NAME}"
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)

slsSupportLib/include/ClientInterface.h

@@ -0,0 +1,71 @@
+#pragma once
+
+
+#include "sls_detector_defs.h"
+#include "MySocketTCP.h"
+#include "ClientSocket.h"
+
+
+/**
+ * @short the ClientInterface class is the interface between the client and the server
+ */
+// Do not overload to make it easier for manual comparison between client and server functions
+
+class ClientInterface: public virtual slsDetectorDefs{
+
+public:
+
+	/**
+	 * (default) constructor
+	 * @param socket tcp socket between client and receiver
+	 * @param n for debugging purposes (useful only for client side)
+	 * @param t string to identify type (Detector, Receiver) for printouts (useful only for client side)
+	 */
+	ClientInterface(sls::ClientSocket* socket, int n);
+
+	/**
+	 * destructor
+	 */
+	virtual ~ClientInterface() = default;
+
+	void SetSocket(sls::ClientSocket *socket){
+		socket_ = socket;
+	}
+
+	/**
+	 * Receive ret, mess or retval from Server
+	 * @param ret result of operation
+	 * @param mess pointer to message
+	 * @param retval pointer to retval
+	 * @param sizeOfRetval size of retval
+	 */
+	void Client_Receive(int& ret, char* mess, void* retval, int sizeOfRetval);
+
+	/**
+	 * Send Arguments to server and receives result back
+	 * @param fnum function enum to determine what parameter
+	 * @param args pointer to arguments
+	 * @param sizeOfArgs argument size
+	 * @param retval pointer to return value
+	 * @param sizeOfRetval return value size
+	 * @param mess pointer to message if message required externally
+	 * @returns success of operation
+	 */
+	int Client_Send(int fnum,
+			void* args, int sizeOfArgs,
+			void* retval, int sizeOfRetval,
+			char* mess = 0);
+
+
+
+
+private:
+
+	/**
+	 * socket for data acquisition
+	 */
+	sls::ClientSocket* socket_;
+
+};
+
+

slsSupportLib/include/ClientSocket.h

@@ -0,0 +1,44 @@
+#pragma once
+#include "DataSocket.h"
+#include <netdb.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+namespace sls {
+
+class ClientSocket : public DataSocket {
+  public:
+    ClientSocket(std::string stype, const std::string &hostname, uint16_t port_number);
+    ClientSocket(std::string stype, struct sockaddr_in addr);
+    int sendCommandThenRead(int fnum, void *args, size_t args_size, void *retval,
+                            size_t retval_size);
+
+  private:
+    void readReply(int &ret, void *retval, size_t retval_size);
+    struct sockaddr_in serverAddr {};
+    std::string socketType;
+};
+
+class ReceiverSocket : public ClientSocket {
+  public:
+    ReceiverSocket(const std::string &hostname, uint16_t port_number)
+        : ClientSocket("Receiver", hostname, port_number){};
+    ReceiverSocket(struct sockaddr_in addr) : ClientSocket("Receiver", addr){};
+};
+
+class DetectorSocket : public ClientSocket {
+  public:
+    DetectorSocket(const std::string &hostname, uint16_t port_number)
+        : ClientSocket("Detector", hostname, port_number){};
+    DetectorSocket(struct sockaddr_in addr) : ClientSocket("Detector", addr){};
+};
+
+class GuiSocket : public ClientSocket {
+  public:
+    GuiSocket(const std::string &hostname, uint16_t port_number)
+        : ClientSocket("Gui", hostname, port_number){};
+    GuiSocket(struct sockaddr_in addr) : ClientSocket("Gui", addr){};
+};
+
+}; // namespace sls

slsSupportLib/include/CmdLineParser.h

@@ -0,0 +1,31 @@
+#ifndef CMD_LINE_PARSER_H
+#define CMD_LINE_PARSER_H
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+class CmdLineParser {
+  public:
+    void Parse(int argc, char *argv[]);
+    void Parse(const std::string &s);
+    void Print();
+
+    //getters
+    int multi_id() const { return multi_id_; };
+    int detector_id() const { return detector_id_; };
+    int n_arguments() const { return arguments_.size(); }
+    const std::string &command() const { return command_; }
+    const std::string &executable() const { return executable_; }
+    const std::vector<std::string> &arguments() const { return arguments_; };
+    std::vector<char *> argv();
+
+  private:
+    void DecodeIdAndPosition(const char *c);
+    int multi_id_ = 0;
+    int detector_id_ = -1;
+    std::string command_;
+    std::string executable_;
+    std::vector<std::string> arguments_;
+};
+
+#endif // CMD_LINE_PARSER_H

slsSupportLib/include/DataSocket.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <netdb.h>
+#include <string>
+namespace sls {
+
+class DataSocket {
+  public:
+    DataSocket(int socketId);
+    DataSocket(DataSocket &&move) noexcept;
+    virtual ~DataSocket();
+    DataSocket &operator=(DataSocket &&move) noexcept;
+    void swap(DataSocket &other) noexcept;
+    DataSocket(const DataSocket &) = delete;
+    DataSocket &operator=(DataSocket const &) = delete;
+    int getSocketId() const {
+        return socketId_;
+    }
+    size_t sendData(void *buffer, size_t size);
+    size_t receiveData(void *buffer, size_t size);
+    int setTimeOut(int t_seconds);
+    void close();
+    void shutDownSocket();
+
+  private:
+    int socketId_ = -1;
+};
+
+int ConvertHostnameToInternetAddress(const char *const hostname, struct ::addrinfo **res);
+int ConvertInternetAddresstoIpString(struct ::addrinfo *res, char *ip, const int ipsize);
+
+struct ::sockaddr_in ConvertHostnameToInternetAddress(const std::string &hostname);
+
+}; // namespace sls

slsSupportLib/include/MySocketTCP.h

@@ -0,0 +1,42 @@
+#pragma once
+/**
+ * 
+ * @libdoc The MySocketTCP class provides a simple interface for creating and sending/receiving data over a TCP socket.
+ *
+ * @short This class provides a simple interface for creating and sending/receiving data over a TCP socket.
+ * @author Ian Johnson
+ * @version 1.0
+ */
+//version 1.0, base development, Ian 19/01/09
+/* Modified by anna on 19.01.2009 */
+/*
+  canceled SetupParameters() and varaibles intialized in the constructors' headers;
+  defined SEND_REC_MAX_SIZE (for compatibilty with mythen (and possibly other)  pure C servers (i would move it to the common header file)
+  added #ifndef C_ONLY... to cutout class definition when including in pure C servers (can be removed if SEND_REC_MAX_SIZE is moved to the common header file)
+  defined private variables char hostname[1000] and int portno to store connection informations;
+  defined public functions  int getHostname(char *name) and  int getPortNumber() to retrieve connection informations
+  added public function int getErrorStatus() returning 1 if socketDescriptor<0
+  remove exits in the constructors and replace them with socketDescriptor=-1
+  replaced the argument of send/receive data with void (to avoid too much casting or compiler errors/warnings)
+  added a function which really does not close the socket between send/receive (senddataonly, receivedataonly)
+
+ Modified by Anna on 31.10.2012 developed and 
+ */
+
+#include "genericSocket.h"
+#define TCP_PACKET_SIZE 4096
+
+class MySocketTCP : public genericSocket {
+  public:
+    // sender (client): where to? ip
+    MySocketTCP(const char *const host_ip_or_name, uint16_t port_number)
+        : genericSocket(host_ip_or_name, port_number, TCP) {
+        setPacketSize(TCP_PACKET_SIZE);
+    }
+    // receiver (server) local no need for ip
+    MySocketTCP(uint16_t port_number)
+        : genericSocket(port_number, TCP) {
+        setPacketSize(TCP_PACKET_SIZE);
+    }
+    virtual ~MySocketTCP(){};
+};

slsSupportLib/include/ServerInterface.h

@@ -0,0 +1,152 @@
+#pragma once
+
+
+#include "sls_detector_defs.h"
+#include "MySocketTCP.h"
+
+
+/**
+ * @short the ServerInterface class is the interface between the client and the server
+ */
+// Do not overload to make it easier for manual comparison between client and server functions
+
+class ServerInterface: public virtual slsDetectorDefs{
+
+public:
+
+	/**
+	 * (default) constructor
+	 * @param socket tcp socket between client and receiver
+	 * @param n for debugging purposes (useful only for client side)
+	 * @param t string to identify type (Detector, Receiver) for printouts (useful only for client side)
+	 */
+	ServerInterface(MySocketTCP *socket, int n=-1, std::string t="");
+
+	/**
+	 * destructor
+	 */
+	virtual ~ServerInterface() = default;
+
+	/**
+	 * Set the datasocket
+	 * @param socket the data socket
+	 */
+	void SetSocket(MySocketTCP *socket);
+
+	/**
+	 * Receive ret, mess or retval from Server
+	 * @param ret result of operation
+	 * @param mess pointer to message
+	 * @param retval pointer to retval
+	 * @param sizeOfRetval size of retval
+	 */
+	void Client_Receive(int& ret, char* mess, void* retval, int sizeOfRetval);
+
+	/**
+	 * Send Arguments to server and receives result back
+	 * @param fnum function enum to determine what parameter
+	 * @param args pointer to arguments
+	 * @param sizeOfArgs argument size
+	 * @param retval pointer to return value
+	 * @param sizeOfRetval return value size
+	 * @param mess pointer to message if message required externally
+	 * @returns success of operation
+	 */
+	int Client_Send(int fnum,
+			void* args, int sizeOfArgs,
+			void* retval, int sizeOfRetval,
+			char* mess = 0);
+
+
+	/** only Receiver
+	 * Server sends result to client (also set ret to force_update if different clients)
+	 * @param update true if one must update if different clients, else false
+	 * @param ret success of operation
+	 * @param retval pointer to result
+	 * @param retvalSize size of result
+	 * @param mess message
+	 * @returns success of operation
+	 */
+	int Server_SendResult(bool update, int ret, void* retval, int retvalSize, char* mess = 0);
+
+	/** only Receiver
+	 * Server receives arguments and checks if base object is null (if checkbase is true)
+	 * checking base object is null (for receiver only when it has not been configured yet)
+	 * @param ret pointer to success of operation
+	 * @param mess message
+	 * @param arg pointer to argument
+	 * @param sizeofArg size of argument
+	 * @param checkbase if true, checks if base object is null and sets ret and mess accordingly
+	 * @param base pointer to base object
+	 * @returns fail if socket crashes while reading arguments, else fail
+	 */
+	int Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg,bool checkbase=false, void* base=NULL);
+
+	/** only Receiver
+	 * Server verifies if it is unlocked,
+	 * sets and prints appropriate message if it is locked and different clients
+	 * @param ret pointer to success
+	 * @param mess message
+	 * @param lockstatus status of lock
+	 * @returns success of operaton
+	 */
+	int Server_VerifyLock(int& ret, char* mess, int lockstatus);
+
+	/** only Receiver
+	 * Server verifies if it is unlocked and idle,
+	 * sets and prints appropriate message if it is locked and different clients
+	 * @param ret pointer to success
+	 * @param mess message
+	 * @param lockstatus status of lock
+	 * @param status status of server
+	 * @param fnum function number for error message
+	 * @returns success of operaton
+	 */
+	int Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum);
+
+	/** only Receiver
+	 * Server sets and prints error message for null object error (receiver only)
+	 * @param ret pointer to success that will be set to FAIL
+	 * @param mess message
+	 */
+	void Server_NullObjectError(int& ret, char* mess);
+
+	/** only Receiver
+	 * Servers prints error message for socket crash when reading
+	 * @returns always FAIL
+	 */
+	int Server_SocketCrash();
+
+	/** only Receiver
+	 * Servers sets and prints error message for locked server
+	 * @param ret pointer to success that will be set to FAIL
+	 * @param mess message
+	 * @returns success of operaton
+	 */
+	int Server_LockedError(int& ret, char* mess);
+
+	/** only Receiver
+	 * Servers sets and prints error message for server not being idle
+	 * @param ret pointer to success that will be set to FAIL
+	 * @param mess message
+	 * @param fnum function number for error message
+	 * @returns success of operaton
+	 */
+	int Server_NotIdleError(int& ret, char* mess, int fnum);
+
+private:
+
+	/**
+	 * socket for data acquisition
+	 */
+	MySocketTCP *mySocket;
+
+	/** index for client debugging purposes */
+	int index;
+
+	/** string for type to differentiate between Detector & Receiver in printouts */
+	std::string type;
+
+};
+
+

slsSupportLib/include/ServerSocket.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "DataSocket.h"
+
+#include <cstdint>
+#include <netdb.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+namespace sls {
+
+class ServerSocket : public DataSocket {
+  public:
+    ServerSocket(int port);
+    DataSocket accept();
+    const std::string &getLastClient();
+    int getPort() const;
+    void SendResult(int &ret, void *retval, int retvalSize, char* mess);
+
+  private:
+    std::string lastClient_ = std::string(INET_ADDRSTRLEN, '\0');
+    std::string thisClient_ = std::string(INET_ADDRSTRLEN, '\0');
+    int serverPort;
+    // char lastClient_[INET_ADDRSTRLEN]{};
+};
+
+}; // namespace sls

slsSupportLib/include/Timer.h

@@ -0,0 +1,38 @@
+#ifndef TIMER_H
+#define TIMER_H
+#include <chrono>
+#include <iostream>
+#include <string>
+
+namespace sls{
+
+class Timer {
+    using clock = std::chrono::high_resolution_clock;
+    using time_point = std::chrono::time_point<clock>;
+
+  public:
+    Timer(std::string name = "0")
+        : t0(clock::now()), name_(name) {
+    }
+
+    double elapsed_ms() {
+        return std::chrono::duration<double, std::milli>(clock::now() - t0).count();
+    }
+    double elapsed_s() {
+        return std::chrono::duration<double>(clock::now() - t0).count();
+    }
+    void print_elapsed() {
+        std::cout << "Timer \"" << name_ << "\": Elapsed time " << elapsed_ms() << " ms\n";
+    }
+    void restart() {
+        t0 = clock::now();
+    }
+
+  private:
+    time_point t0;
+    std::string name_;
+};
+
+
+}; //namespace sls
+#endif // TIMER_H

slsSupportLib/include/ZmqSocket.h

@@ -0,0 +1,597 @@
+#pragma once
+/************************************************
+ * @file zmqSocket.h
+ * @short functions to open/close zmq sockets
+ ***********************************************/
+/**
+ *@short functions to open/close zmq sockets
+ */
+
+#include "ansi.h"
+#include "sls_detector_exceptions.h"
+
+#include <iostream>
+#include <zmq.h>
+#include <errno.h>
+#include <netdb.h>				//gethostbyname()
+#include <arpa/inet.h>			//inet_ntoa
+#include <rapidjson/document.h> //json header in zmq stream
+#include <string.h>
+#include <unistd.h> 			//usleep in some machines
+#include <vector>
+using namespace rapidjson;
+
+
+#define MAX_STR_LENGTH 1000
+
+// #define ZMQ_DETAIL
+#define ROIVERBOSITY
+
+
+
+class ZmqSocket {
+
+public:
+
+	//Socket Options for optimization
+	//ZMQ_LINGER default is already -1 means no messages discarded. use this options if optimizing required
+	//ZMQ_SNDHWM default is 0 means no limit. use this to optimize if optimizing required
+	// eg. int value = -1;
+	// if (zmq_setsockopt(socketDescriptor, ZMQ_LINGER, &value,sizeof(value))) {
+	//	Close();
+	/**
+	 * Constructor for a client
+	 * Creates socket, context and connects to server
+	 * @param hostname hostname or ip of server
+	 * @param portnumber port number
+	 */
+	ZmqSocket (const char* const hostname_or_ip, const uint32_t  portnumber):
+		portno (portnumber)
+		// headerMessage(0)
+	{
+		char ip[MAX_STR_LENGTH] = "";
+		memset(ip, 0, MAX_STR_LENGTH);
+
+		// convert hostname to ip (not required, but a test that returns if failed)
+		struct addrinfo *result;
+		if ((ConvertHostnameToInternetAddress(hostname_or_ip, &result)) ||
+		 (ConvertInternetAddresstoIpString(result, ip, MAX_STR_LENGTH)))
+		    throw sls::ZmqSocketError("Could convert IP to string");
+
+		// construct address
+		sprintf (sockfd.serverAddress, "tcp://%s:%d", ip, portno);
+#ifdef VERBOSE
+		cprintf(BLUE,"address:%s\n",sockfd.serverAddress);
+#endif
+
+		// create context
+		sockfd.contextDescriptor = zmq_ctx_new();
+		if (sockfd.contextDescriptor == 0)
+		    throw sls::ZmqSocketError("Could not create contextDescriptor");
+
+		// create publisher
+		sockfd.socketDescriptor = zmq_socket (sockfd.contextDescriptor, ZMQ_SUB);
+		if (sockfd.socketDescriptor == 0) {
+		    PrintError ();
+		    Close ();
+		    throw sls::ZmqSocketError("Could not create socket");
+		}
+
+		//Socket Options provided above
+	    // an empty string implies receiving any messages
+		if ( zmq_setsockopt(sockfd.socketDescriptor, ZMQ_SUBSCRIBE, "", 0)) {
+		    PrintError ();
+		    Close();
+		    throw sls::ZmqSocketError("Could set socket opt");
+		}
+		//ZMQ_LINGER default is already -1 means no messages discarded. use this options if optimizing required
+		//ZMQ_SNDHWM default is 0 means no limit. use this to optimize if optimizing required
+		// eg. int value = -1;
+		int value = 0;
+		if (zmq_setsockopt(sockfd.socketDescriptor, ZMQ_LINGER, &value,sizeof(value))) {
+		    PrintError ();
+		    Close();
+		    throw sls::ZmqSocketError("Could not set ZMQ_LINGER");
+		}
+	};
+
+	/**
+	 * Constructor for a server
+	 * Creates socket, context and connects to server
+	 * @param hostname hostname or ip of server
+	 * @param portnumber port number
+	 * @param ethip is the ip of the ethernet interface to stream zmq from
+	 */
+	ZmqSocket (const uint32_t portnumber, const char *ethip):
+
+		portno (portnumber)
+		// headerMessage(0)
+	{
+		sockfd.server = true;
+
+		// create context
+		sockfd.contextDescriptor = zmq_ctx_new();
+		if (sockfd.contextDescriptor == 0)
+		    throw sls::ZmqSocketError("Could not create contextDescriptor");
+		// create publisher
+		sockfd.socketDescriptor = zmq_socket (sockfd.contextDescriptor, ZMQ_PUB);
+		if (sockfd.socketDescriptor == 0) {
+			PrintError ();
+			Close ();
+			throw sls::ZmqSocketError("Could not create socket");
+		}
+
+		//Socket Options provided above
+
+		// construct addresss
+		sprintf (sockfd.serverAddress,"tcp://%s:%d", ethip, portno);
+#ifdef VERBOSE
+		cprintf(BLUE,"address:%s\n",sockfd.serverAddress);
+#endif
+		// bind address
+		if (zmq_bind (sockfd.socketDescriptor, sockfd.serverAddress) < 0) {
+			PrintError ();
+			Close ();
+			throw sls::ZmqSocketError("Could not bind socket");
+		}
+
+		//sleep for a few milliseconds to allow a slow-joiner
+		usleep(200* 1000);
+	};
+
+	/**
+	 * Destructor
+	 */
+	~ZmqSocket () {
+		//mySocketDescriptor destructor also gets called
+	};
+
+	/**
+	 * Returns Port Number
+	 * @returns Port Number
+	 */
+	uint32_t GetPortNumber () { return portno; };
+
+	/**
+	 * Returns Server Address
+	 * @returns Server Address
+	 */
+	char* GetZmqServerAddress () { return sockfd.serverAddress; };
+
+	/**
+	 * Returns Socket Descriptor
+	 * @reutns Socket descriptor
+	 */
+
+	void* GetsocketDescriptor () { return sockfd.socketDescriptor; };
+
+	/**
+	 * Connect client socket to server socket
+	 * @returns 1 for fail, 0 for success
+	 */
+	int Connect() {
+		if (zmq_connect(sockfd.socketDescriptor, sockfd.serverAddress) < 0) {
+			PrintError ();
+			return 1;
+		}
+		return 0;
+	}
+
+	/**
+	 * Unbinds the Socket
+	 */
+	void Disconnect () {sockfd.Disconnect();};
+
+	/**
+	 * Close Socket and destroy Context
+	 */
+	void Close () {	sockfd.Close();	};
+
+ 	/**
+ 	 * Convert Hostname to Internet address info structure
+ 	 * One must use freeaddrinfo(res) after using it
+ 	 * @param hostname hostname
+ 	 * @param res address of pointer to address info structure
+ 	 * @return 1 for fail, 0 for success
+ 	 */
+     // Do not make this static (for multi threading environment)
+     int ConvertHostnameToInternetAddress (const char* const hostname, struct addrinfo **res) {
+    	// criteria in selecting socket address structures returned by res
+ 		struct addrinfo hints;
+ 		memset (&hints, 0, sizeof (hints));
+ 		 hints.ai_family = AF_INET;
+ 		 hints.ai_socktype = SOCK_STREAM;
+ 		 // get host info into res
+ 		 int errcode = getaddrinfo (hostname, NULL, &hints, res);
+ 		 if (errcode != 0) {
+ 			 cprintf (RED,"Error: Could not convert %s hostname to internet address (zmq):"
+ 					 "%s\n", hostname, gai_strerror(errcode));
+ 		 } else {
+ 			 if (*res == NULL) {
+ 				 cprintf (RED,"Error: Could not convert %s hostname to internet address (zmq): "
+ 						 "gettaddrinfo returned null\n", hostname);
+ 			 } else{
+ 				 return 0;
+ 			 }
+ 		 }
+ 		 cprintf(RED, "Error: Could not convert hostname to internet address\n");
+ 		 return 1;
+ 	};
+
+     /**
+      * Convert Internet Address structure pointer to ip string (char*)
+      * Clears the internet address structure as well
+      * @param res pointer to internet address structure
+      * @param ip pointer to char array to store result in
+      * @param ipsize size available in ip buffer
+      * @return 1 for fail, 0 for success
+      */
+     // Do not make this static (for multi threading environment)
+     int ConvertInternetAddresstoIpString (struct addrinfo *res, char* ip, const int ipsize) {
+    	 if (inet_ntop (res->ai_family, &((struct sockaddr_in *) res->ai_addr)->sin_addr, ip, ipsize) != NULL) {
+    		 freeaddrinfo(res);
+    		 return 0;
+    	 }
+    	 cprintf(RED, "Error: Could not convert internet address to ip string\n");
+    	 return 1;
+     }
+
+
+
+	/**
+	 * Send Message Header
+	 * @param buf message
+	 * @param length length of message
+	 * @param dummy true if end of acquistion else false
+	 * @returns 0 if error, else 1
+	 */
+	int SendHeaderData ( int index, bool dummy, uint32_t jsonversion, uint32_t dynamicrange = 0, uint64_t fileIndex = 0,
+			uint32_t npixelsx = 0, uint32_t npixelsy = 0, uint32_t imageSize = 0,
+			uint64_t acqIndex = 0, uint64_t fIndex = 0, const char* fname = NULL,
+			uint64_t frameNumber = 0, uint32_t expLength = 0, uint32_t packetNumber = 0,
+			uint64_t bunchId = 0, uint64_t timestamp = 0,
+			uint16_t modId = 0, uint16_t row = 0, uint16_t column = 0, uint16_t reserved = 0,
+			uint32_t debug = 0, uint16_t roundRNumber = 0,
+			uint8_t detType = 0, uint8_t version = 0, int* flippedData = 0,
+			char* additionalJsonHeader = 0) {
+
+
+		
+		/** Json Header Format */
+		const char jsonHeaderFormat[] =
+				"{"
+				"\"jsonversion\":%u, "
+				"\"bitmode\":%u, "
+				"\"fileIndex\":%lu, "
+				"\"shape\":[%u, %u], "
+				"\"size\":%u, "
+				"\"acqIndex\":%lu, "
+				"\"fIndex\":%lu, "
+				"\"fname\":\"%s\", "
+				"\"data\": %d, "
+
+				"\"frameNumber\":%lu, "
+				"\"expLength\":%u, "
+				"\"packetNumber\":%u, "
+				"\"bunchId\":%lu, "
+				"\"timestamp\":%lu, "
+				"\"modId\":%u, "
+				"\"row\":%u, "
+				"\"column\":%u, "
+				"\"reserved\":%u, "
+				"\"debug\":%u, "
+				"\"roundRNumber\":%u, "
+				"\"detType\":%u, "
+				"\"version\":%u, "
+
+		        //additional stuff
+		        "\"flippedDataX\":%u"
+
+				;//"}\n";
+		char buf[MAX_STR_LENGTH] = "";
+		sprintf(buf, jsonHeaderFormat,
+				jsonversion, dynamicrange, fileIndex, npixelsx, npixelsy, imageSize,
+				acqIndex, fIndex, (fname == NULL)? "":fname, dummy?0:1,
+
+				        frameNumber, expLength, packetNumber, bunchId, timestamp,
+						modId, row, column, reserved, debug, roundRNumber,
+						detType, version,
+
+						//additional stuff
+						((flippedData == 0 ) ? 0 :flippedData[0])
+		);
+		
+		if (additionalJsonHeader && strlen(additionalJsonHeader)) {
+            strcat(buf, ", ");
+            strcat(buf, additionalJsonHeader);
+        }
+        strcat(buf, "}\n");
+        int length = strlen(buf);
+
+#ifdef VERBOSE
+		//if(!index)
+			cprintf(BLUE,"%d : Streamer: buf: %s\n", index, buf);
+#endif
+
+		if(zmq_send (sockfd.socketDescriptor, buf, length, dummy?0:ZMQ_SNDMORE) < 0) {
+			PrintError ();
+			return 0;
+		}
+#ifdef VERBOSE
+		cprintf(GREEN,"[%u] send header data\n",portno);
+#endif
+		return 1;
+	};
+
+	/**
+	 * Send Message Body
+	 * @param buf message
+	 * @param length length of message
+	 * @returns 0 if error, else 1
+	 */
+	int SendData (char* buf, int length) {
+		if(zmq_send (sockfd.socketDescriptor, buf, length, 0) < 0) {
+			PrintError ();
+			return 0;
+		}
+#ifdef VERBOSE
+		cprintf(GREEN,"[%u] send data\n",portno);
+#endif
+		return 1;
+	};
+
+
+	/**
+	 * Receive Message
+	 * @param index self index for debugging
+	 * @param message message
+	 * @returns length of message, -1 if error
+	 */
+	int ReceiveMessage(const int index, zmq_msg_t& message) {
+		int length = zmq_msg_recv (&message, sockfd.socketDescriptor, 0);
+		if (length == -1) {
+			PrintError ();
+			cprintf (BG_RED,"Error: Could not read header for socket %d\n",index);
+		}
+#ifdef VERBOSE
+		else
+			cprintf( RED,"Message %d Length: %d Header:%s \n", index, length, (char*) zmq_msg_data (&message) );
+#endif
+		return length;
+	};
+
+
+	/**
+	 * Receive Header (Important to close message after parsing header)
+	 * @param index self index for debugging
+	 * @param document parsed document reference
+	 * @param version version that has to match, -1 to not care
+	 * @returns 0 if error or end of acquisition, else 1 (call CloseHeaderMessage after parsing header)
+	 */
+	int ReceiveHeader(const int index, Document& document, uint32_t version)
+	{
+		std::vector<char>buffer(MAX_STR_LENGTH);
+		int len = zmq_recv(sockfd.socketDescriptor, buffer.data(), buffer.size(),0);
+		if ( len > 0 ) {
+			bool dummy = false;
+#ifdef ZMQ_DETAIL
+				cprintf( BLUE,"Header %d [%d] Length: %d Header:%s \n", index, portno, len, buffer.data());
+#endif
+			if ( ParseHeader (index, len, buffer.data(), document, dummy, version)) {
+#ifdef ZMQ_DETAIL
+				cprintf( RED,"Parsed Header %d [%d] Length: %d Header:%s \n", index, portno, len, buffer.data() );
+#endif
+				if (dummy) {
+#ifdef ZMQ_DETAIL
+					cprintf(RED,"%d [%d] Received end of acquisition\n", index, portno );
+#endif
+					return 0;
+				}
+#ifdef ZMQ_DETAIL
+				cprintf(GREEN,"%d [%d] data\n",index, portno );
+#endif
+				return 1;
+			}
+		}
+		return 0;
+	};
+
+
+    /**
+     * Close Header Message. Call this function if ReceiveHeader returned 1
+     */
+    // void CloseHeaderMessage() {
+    //     if (headerMessage)
+    //         zmq_msg_close(headerMessage);
+    //     headerMessage = 0;
+    // };
+    /**
+     * Parse Header
+     * @param index self index for debugging
+     * @param length length of message
+     * @param message message
+     * @param document parsed document reference
+     * @param dummy true if end of acqusition, else false, loaded upon parsing
+     * @param version version that has to match, -1 to not care
+     * @returns true if successful else false
+     */
+    int ParseHeader(const int index, int length, char* buff,
+            Document& document, bool& dummy, uint32_t version)
+    {
+        if ( document.Parse( buff, length).HasParseError() ) {
+            cprintf( RED,"%d Could not parse. len:%d: Message:%s \n", index, length, buff );
+            fflush ( stdout );
+            // char* buf =  (char*) zmq_msg_data (&message);
+            for ( int i= 0; i < length; ++i ) {
+                cprintf(RED,"%02x ",buff[i]);
+            }
+            printf("\n");
+            fflush( stdout );
+            return 0;
+        }
+
+        if (document["jsonversion"].GetUint() != version) {
+            cprintf( RED, "version mismatch. required %u, got %u\n", version, document["jsonversion"].GetUint());
+            return 0;
+        }
+
+        dummy = false;
+        int temp = document["data"].GetUint();
+        dummy = temp ? false : true;
+
+        return 1;
+    };
+
+
+	/**
+	 * Receive Data
+	 * @param index self index for debugging
+	 * @param buf buffer to copy image data to
+	 * @param size size of image
+	 * @returns length of data received
+	 */
+	int ReceiveData(const int index, char* buf, const int size)
+	{
+		zmq_msg_t message;
+		zmq_msg_init (&message);
+		int length = ReceiveMessage(index, message);
+
+		//actual data
+		if (length == size) {
+#ifdef VERBOSE
+			cprintf(BLUE,"%d actual data\n", index);
+#endif
+			memcpy(buf, (char*)zmq_msg_data(&message), size);
+		}
+
+		//incorrect size (smaller)
+        else if (length < size){
+#ifdef ROIVERBOSITY
+            cprintf(RED,"Error: Received smaller packet size %d for socket %d\n", length, index);
+#endif
+            memcpy(buf, (char*)zmq_msg_data(&message), length);
+            memset(buf+length,0xFF,size-length);
+        }
+        //incorrect size (larger)
+		else {
+			cprintf(RED,"Error: Received weird packet size %d for socket %d\n", length, index);
+			memset(buf,0xFF,size);
+		}
+
+		zmq_msg_close(&message);
+		return length;
+	};
+
+
+
+	/**
+	 * Print error
+	 */
+	void PrintError () {
+		switch (errno) {
+		case EINVAL:
+			cprintf(RED, "Error: The socket type/option or value/endpoint supplied is invalid (zmq)\n");
+			break;
+		case EAGAIN:
+			cprintf(RED, "Error: Non-blocking mode was requested and the message cannot be sent/available at the moment (zmq)\n");
+			break;
+		case ENOTSUP:
+			cprintf(RED, "Error: The zmq_send()/zmq_msg_recv() operation is not supported by this socket type (zmq)\n");
+			break;
+		case EFSM:
+			cprintf(RED, "Error: The zmq_send()/zmq_msg_recv() unavailable now as socket in inappropriate state (eg. ZMQ_REP). Look up messaging patterns (zmq)\n");
+			break;
+		case EFAULT:
+			cprintf(RED, "Error: The provided context/message is invalid (zmq)\n");
+			break;
+		case EMFILE:
+			cprintf(RED, "Error: The limit on the total number of open ØMQ sockets has been reached (zmq)\n");
+			break;
+		case EPROTONOSUPPORT:
+			cprintf(RED, "Error: The requested transport protocol is not supported (zmq)\n");
+			break;
+		case ENOCOMPATPROTO:
+			cprintf(RED, "Error: The requested transport protocol is not compatible with the socket type (zmq)\n");
+			break;
+		case EADDRINUSE:
+			cprintf(RED, "Error: The requested address is already in use (zmq)\n");
+			break;
+		case EADDRNOTAVAIL:
+			cprintf(RED, "Error: The requested address was not local (zmq)\n");
+			break;
+		case ENODEV:
+			cprintf(RED, "Error: The requested address specifies a nonexistent interface (zmq)\n");
+			break;
+		case ETERM:
+			cprintf(RED, "Error: The ØMQ context associated with the specified socket was terminated (zmq)\n");
+			break;
+		case ENOTSOCK:
+			cprintf(RED, "Error: The provided socket was invalid (zmq)\n");
+			break;
+		case EINTR:
+			cprintf(RED, "Error: The operation was interrupted by delivery of a signal (zmq)\n");
+			break;
+		case EMTHREAD:
+			cprintf(RED, "Error: No I/O thread is available to accomplish the task (zmq)\n");
+			break;
+		default:
+			cprintf(RED, "Error: Unknown socket error (zmq)\n");
+			break;
+		}
+	};
+
+
+private:
+
+	/**
+	 * Class to close socket descriptors automatically
+	 * upon encountering exceptions in the ZmqSocket constructor
+	 */
+	class mySocketDescriptors {
+	public:
+		/** Constructor */
+		mySocketDescriptors():
+			server(false),
+			contextDescriptor(0),
+			socketDescriptor(0) {};
+		/** Destructor */
+		~mySocketDescriptors() {
+			Disconnect();
+			Close();
+		}
+		/** Unbinds the Socket */
+		void Disconnect () {
+			if (server)
+				zmq_unbind (socketDescriptor, serverAddress);
+			else
+				zmq_disconnect (socketDescriptor, serverAddress);
+		};
+		/** Close Socket and destroy Context */
+		void Close () {
+			if (socketDescriptor != NULL) {
+				zmq_close (socketDescriptor);
+				socketDescriptor = NULL;
+			}
+
+			if (contextDescriptor != NULL) {
+				zmq_ctx_destroy (contextDescriptor);
+				contextDescriptor = NULL;
+			}
+		};
+		/** true if server, else false */
+		bool server;
+		/** Server Address */
+		char serverAddress[1000];
+		/** Context Descriptor */
+		void* contextDescriptor;
+		/** Socket Descriptor */
+		void* socketDescriptor;
+	};
+
+private:
+	/** Port Number */
+	uint32_t portno;
+
+	/** Socket descriptor */
+	mySocketDescriptors sockfd;
+};

slsSupportLib/include/ansi.h

@@ -0,0 +1,66 @@
+#define RED    	 	"\x1b[31m"
+#define GREEN   	"\x1b[32m"
+#define YELLOW  	"\x1b[33m"
+#define BLUE    	"\x1b[34m"
+#define MAGENTA 	"\x1b[35m"
+#define CYAN    	"\x1b[36m"
+#define GRAY		"\x1b[37m"
+#define DARKGRAY	"\x1b[30m"
+
+#define BG_BLACK	"\x1b[48;5;232m"
+#define BG_RED     	"\x1b[41m"
+#define BG_GREEN   	"\x1b[42m"
+#define BG_YELLOW  	"\x1b[43m"
+#define BG_BLUE    	"\x1b[44m"
+#define BG_MAGENTA 	"\x1b[45m"
+#define BG_CYAN    	"\x1b[46m"
+#define RESET   	"\x1b[0m"
+#define BOLD    	"\x1b[1m"
+
+//on background black
+#define bprintf(code, format, ...)	printf(code BG_BLACK format RESET, ##__VA_ARGS__)
+
+//normal printout
+#define cprintf(code, format, ...) printf(code format RESET, ##__VA_ARGS__)
+/*
+
+Code examples
+
+example 1 (a snippet):
+
+
+#ifdef MARTIN
+        cprintf(BLUE, "LL Write - Len: %2d - If: %X - Data: ",buffer_len, ll->ll_fifo_base);
+        for (i=0; i < buffer_len/4; i++)
+                cprintf(BLUE, "%.8X ",*(((unsigned *) buffer)+i));
+        printf("\n");
+#endif
+
+#ifdef MARTIN
+        cprintf(CYAN, "LL Read - If: %X - Data: ",ll->ll_fifo_base);
+#endif
+
+
+
+example 2:
+
+int main()
+{
+	int i=1;
+	printf("Normal %i\n", i);
+	cprintf(RED, "Red\n");
+	cprintf(GREEN, "Green\n");
+	cprintf(YELLOW, "Yellow\n");
+	cprintf(BLUE, "Blue\n");
+	cprintf(MAGENTA, "Mangenta %i\n", i);
+	cprintf(CYAN, "Cyan %i\n", i);
+	cprintf(BOLD, "White %i\n", i);
+	cprintf(RED BOLD, "Red %i\n", i);
+	cprintf(GREEN BOLD, "Green\n");
+	cprintf(YELLOW BOLD, "Yellow\n");
+	cprintf(BLUE BOLD, "Blue\n");
+	cprintf(MAGENTA BOLD, "Mangenta %i\n", i);
+	cprintf(CYAN BOLD, "Cyan %i\n", i);
+}
+
+*/

slsSupportLib/include/container_utils.h

@@ -0,0 +1,114 @@
+#ifndef CONTAINER_UTILS_H
+#define CONTAINER_UTILS_H
+
+#include <algorithm>
+#include <memory>
+#include <numeric>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace sls {
+
+// C++11 make_unique implementation for exception safety
+// already available as std::make_unique in C++14
+template <typename T, typename... Args>
+typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
+make_unique(Args &&... args) {
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+template <typename T>
+typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
+make_unique(std::size_t n) {
+    typedef typename std::remove_extent<T>::type RT;
+    return std::unique_ptr<T>(new RT[n]);
+}
+
+template <typename T> bool allEqual(const std::vector<T> &container) {
+    if (container.empty())
+        return false;
+    const auto &first = container[0];
+    return std::all_of(container.cbegin(), container.cend(),
+                       [first](const T &element) { return element == first; });
+}
+
+template <typename T>
+typename std::enable_if<std::is_arithmetic<T>::value, bool>::type
+allEqualWithTol(const std::vector<T> &container, const T tol) {
+    if (container.empty())
+        return false;
+
+    const auto &first = container[0];
+    return std::all_of(container.cbegin(), container.cend(),
+                       [first, tol](const T &element) {
+                           return (std::abs(element - first) < tol);
+                       });
+}
+
+template <typename T>
+bool allEqualTo(const std::vector<T> &container, const T value) {
+    if (container.empty())
+        return false;
+
+    return std::all_of(container.cbegin(), container.cend(),
+                       [value](const T &element) { return element == value; });
+}
+
+template <typename T>
+bool allEqualToWithTol(const std::vector<T> &container, const T value,
+                       const T tol) {
+    if (container.empty())
+        return false;
+
+    return std::all_of(container.cbegin(), container.cend(),
+                       [value, tol](const T &element) {
+                           return (std::abs(element - value) < tol);
+                       });
+}
+
+template <typename T>
+bool anyEqualTo(const std::vector<T> &container, const T value) {
+    return std::any_of(container.cbegin(), container.cend(),
+                       [value](const T &element) { return element == value; });
+}
+
+template <typename T>
+bool anyEqualToWithTol(const std::vector<T> &container, const T value,
+                       const T tol) {
+    return std::any_of(container.cbegin(), container.cend(),
+                       [value, tol](const T &element) {
+                           return (std::abs(element - value) < tol);
+                       });
+}
+
+template <typename T>
+typename std::enable_if<std::is_arithmetic<T>::value, T>::type
+sum(const std::vector<T> &container) {
+    return std::accumulate(container.cbegin(), container.cend(), T{0});
+}
+
+template <typename T> T minusOneIfDifferent(const std::vector<T> &container) {
+    if (allEqual(container))
+        return container.front();
+    return static_cast<T>(-1);
+}
+
+inline int minusOneIfDifferent(const std::vector<bool> &container) {
+    if (allEqual(container))
+        return static_cast<int>(container.front());
+    return -1;
+}
+
+template <typename T>
+std::vector<T>
+minusOneIfDifferent(const std::vector<std::vector<T>> &container) {
+    if (allEqual(container))
+        return container.front();
+    return std::vector<T>{-1};
+}
+
+} // namespace sls
+
+#endif // CONTAINER_UTILS_H

slsSupportLib/include/error_defs.h

@@ -0,0 +1,342 @@
+/*
+ * error_defs.h
+ *
+ *  Created on: Jan 18, 2013
+ *      Author: l_maliakal_d
+ */
+
+#ifndef ERROR_DEFS_H_
+#define ERROR_DEFS_H_
+
+#include "ansi.h"
+#include "sls_detector_defs.h"
+
+#include <stdio.h>
+#include <string>
+#include <cstring>
+#include <iostream>
+// 
+
+/** Error flags */
+/*Assumption: Only upto 63 detectors */
+
+// multi errors
+//											0xFFF0000000000000ULL
+#define MULTI_DETECTORS_NOT_ADDED			0x8000000000000000ULL
+#define MULTI_HAVE_DIFFERENT_VALUES			0x4000000000000000ULL
+#define MULTI_CONFIG_FILE_ERROR             0x2000000000000000ULL
+#define MULTI_POS_EXCEEDS_LIST             	0x1000000000000000ULL
+#define MUST_BE_MULTI_CMD	             	0x0800000000000000ULL
+#define MULTI_OTHER_ERROR	             	0x0400000000000000ULL
+
+// sls errors
+#define CRITICAL_ERROR_MASK 				0xFFFFFFF
+
+//											0xFFFFFFF000000000ULL
+#define CANNOT_CONNECT_TO_DETECTOR  		0x4000000000000000ULL
+#define CANNOT_CONNECT_TO_RECEIVER  		0x2000000000000000ULL
+#define COULDNOT_SET_CONTROL_PORT			0x1000000000000000ULL
+#define COULDNOT_SET_STOP_PORT				0x0800000000000000ULL
+#define COULDNOT_SET_DATA_PORT				0x0400000000000000ULL
+#define FILE_PATH_DOES_NOT_EXIST			0x0200000000000000ULL
+#define COULDNOT_CREATE_UDP_SOCKET			0x0100000000000000ULL
+#define COULDNOT_CREATE_FILE				0x0080000000000000ULL
+#define RECEIVER_DET_HOSTNAME_NOT_SET		0x0040000000000000ULL
+#define RECEIVER_DET_HOSTTYPE_NOT_SET		0x0020000000000000ULL
+#define DETECTOR_TEN_GIGA					0x0010000000000000ULL
+#define DETECTOR_ACTIVATE					0x0008000000000000ULL
+#define COULD_NOT_CONFIGURE_MAC				0x0004000000000000ULL
+#define COULDNOT_START_RECEIVER				0x0002000000000000ULL // default error like starting threads
+#define COULDNOT_STOP_RECEIVER				0x0001000000000000ULL
+#define RECEIVER_DET_POSID_NOT_SET			0x0000800000000000ULL
+#define RECEIVER_MULTI_DET_SIZE_NOT_SET		0x0000400000000000ULL
+#define PREPARE_ACQUISITION					0x0000200000000000ULL
+#define REGISER_WRITE_READ					0x0000100000000000ULL
+#define VERSION_COMPATIBILITY				0x0000080000000000ULL
+//											0xFFFFFF0000000000ULL
+
+//											0x000000FFFFFFFFFFULL
+#define COULDNOT_SET_NETWORK_PARAMETER		0x0000000000000001ULL
+#define COULDNOT_SET_ROI					0x0000000000000002ULL
+#define RECEIVER_STREAMING_FREQUENCY		0x0000000000000004ULL
+#define SETTINGS_NOT_SET					0x0000000000000008ULL
+#define SETTINGS_FILE_NOT_OPEN				0x0000000000000010ULL
+#define DETECTOR_TIMER_VALUE_NOT_SET		0x0000000000000020ULL
+#define RECEIVER_ACQ_PERIOD_NOT_SET			0x0000000000000040ULL
+#define RECEIVER_FRAME_NUM_NOT_SET			0x0000000000000080ULL
+#define RECEIVER_DYNAMIC_RANGE				0x0000000000000100ULL
+#define RECEIVER_TEN_GIGA					0x0000000000000200ULL
+#define ALLTIMBITS_NOT_SET					0x0000000000000400ULL
+#define COULD_NOT_SET_SPEED_PARAMETERS		0x0000000000000800ULL
+#define COULD_NOT_SET_READOUT_FLAGS			0x0000000000001000ULL
+#define COULD_NOT_SET_FIFO_DEPTH			0x0000000000002000ULL
+#define COULD_NOT_SET_COUNTER_BIT			0x0000000000004000ULL
+#define COULD_NOT_PULSE						0x0000000000008000ULL
+#define COULD_NOT_SET_RATE_CORRECTION		0x0000000000010000ULL
+#define DETECTOR_NETWORK_PARAMETER			0x0000000000020000ULL
+#define RATE_CORRECTION_NOT_32or16BIT		0x0000000000040000ULL
+#define RATE_CORRECTION_NO_TAU_PROVIDED		0x0000000000080000ULL
+#define PROGRAMMING_ERROR					0x0000000000100000ULL
+#define RECEIVER_ACTIVATE					0x0000000000200000ULL
+#define DATA_STREAMING						0x0000000000400000ULL
+#define RESET_ERROR						    0x0000000000800000ULL
+#define POWER_CHIP						    0x0000000001000000ULL
+#define RECEIVER_STREAMING_TIMER		    0x0000000002000000ULL
+#define RECEIVER_ACQ_TIME_NOT_SET			0x0000000004000000ULL
+#define RECEIVER_FLIPPED_DATA_NOT_SET		0x0000000008000000ULL
+#define THRESHOLD_NOT_SET					0x0000000010000000ULL
+#define RECEIVER_FILE_FORMAT				0x0000000020000000ULL
+#define RECEIVER_PARAMETER_NOT_SET			0x0000000040000000ULL
+#define RECEIVER_TIMER_NOT_SET				0x0000000080000000ULL
+#define RECEIVER_ENABLE_GAPPIXELS_NOT_SET	0x0000000100000000ULL
+#define RESTREAM_STOP_FROM_RECEIVER			0x0000000200000000ULL
+#define TEMPERATURE_CONTROL                 0x0000000400000000ULL
+#define AUTO_COMP_DISABLE                   0x0000000800000000ULL
+#define CONFIG_FILE                         0x0000001000000000ULL
+#define STORAGE_CELL_START                  0x0000002000000000ULL
+#define OTHER_ERROR_CODE					0x0000004000000000ULL
+//											0x000000FFFFFFFFFFULL
+
+
+/** @short class returning all error messages for error mask */
+class errorDefs {
+
+
+public:
+
+	/** Constructor */
+	errorDefs():errorMask(0){
+		strcpy(notAddedList,"");
+	};
+
+	/** Gets the error message
+	 * param errorMask error mask
+	 /returns error message from error mask
+	*/
+	static std::string getErrorMessage(int64_t slsErrorMask){
+
+		std::string retval = "";
+
+		if(slsErrorMask&CANNOT_CONNECT_TO_DETECTOR)
+			retval.append("Cannot connect to Detector\n");
+
+		if(slsErrorMask&CANNOT_CONNECT_TO_RECEIVER)
+			retval.append("Cannot connect to Receiver\n");
+
+		if(slsErrorMask&COULDNOT_SET_CONTROL_PORT)
+			retval.append("Could not set control port\n");
+
+		if(slsErrorMask&COULDNOT_SET_STOP_PORT)
+			retval.append("Could not set stop port\n");
+
+		if(slsErrorMask&COULDNOT_SET_DATA_PORT)
+			retval.append("Could not set receiver port\n");
+
+		if(slsErrorMask&FILE_PATH_DOES_NOT_EXIST)
+			retval.append("Path to Output Directory does not exist\n");
+
+		if(slsErrorMask&COULDNOT_CREATE_UDP_SOCKET)
+			retval.append("Could not create UDP socket to start receiver\n");
+
+		if(slsErrorMask&COULDNOT_CREATE_FILE)
+			retval.append("Could not create file to start receiver.\nCheck permissions of output directory or the overwrite flag\n");
+
+		if(slsErrorMask&RECEIVER_DET_HOSTNAME_NOT_SET)
+			retval.append("Could not send the detector hostname to the receiver.\n");
+
+		if(slsErrorMask&RECEIVER_DET_HOSTTYPE_NOT_SET)
+			retval.append("Could not send the detector type to the receiver.\n");
+
+		if(slsErrorMask&DETECTOR_TEN_GIGA)
+			retval.append("Could not enable/disable 10GbE in the detector.\n");
+
+		if(slsErrorMask&DETECTOR_ACTIVATE)
+			retval.append("Could not activate/deactivate detector\n");
+
+		if(slsErrorMask&RECEIVER_DET_POSID_NOT_SET)
+			retval.append("Could not set detector position id\n");
+
+		if(slsErrorMask&RECEIVER_MULTI_DET_SIZE_NOT_SET)
+			retval.append("Could not set multi detector size\n");
+
+		if(slsErrorMask&PREPARE_ACQUISITION)
+			retval.append("Could not prepare acquisition in detector\n");
+
+		if(slsErrorMask&REGISER_WRITE_READ)
+			retval.append("Could not read/write register in detector\n");
+
+		if(slsErrorMask&VERSION_COMPATIBILITY)
+			retval.append("Incompatible versions with detector or receiver. Please check log for more details.\n");
+
+
+
+		if(slsErrorMask&COULD_NOT_CONFIGURE_MAC)
+			retval.append("Could not configure mac\n");
+
+		if(slsErrorMask&COULDNOT_SET_NETWORK_PARAMETER)
+			retval.append("Could not set network parameter.\n");
+
+		if(slsErrorMask&COULDNOT_SET_ROI)
+			retval.append("Could not set the exact region of interest. Verify ROI set by detector.\n");
+
+		if(slsErrorMask&RECEIVER_STREAMING_FREQUENCY)
+			retval.append("Could not set receiver read frequency.\n");
+
+		if(slsErrorMask&SETTINGS_NOT_SET)
+			retval.append("Could not set settings.\n");
+
+		if(slsErrorMask&SETTINGS_FILE_NOT_OPEN)
+			retval.append("Could not open settings file. Verify if it exists.\n");
+
+		if(slsErrorMask&COULDNOT_START_RECEIVER)
+			retval.append("Could not start receiver.\n");
+
+		if(slsErrorMask&COULDNOT_STOP_RECEIVER)
+			retval.append("Could not stop receiver.\n");
+
+		if(slsErrorMask&DETECTOR_TIMER_VALUE_NOT_SET)
+			retval.append("Could not set one of timer values in detector.\n");
+
+		if(slsErrorMask&RECEIVER_ACQ_PERIOD_NOT_SET)
+			retval.append("Could not set acquisition period in receiver.\n");
+
+		if(slsErrorMask&RECEIVER_FRAME_NUM_NOT_SET)
+			retval.append("Could not set frame number in receiver.\n");
+
+		if(slsErrorMask&RECEIVER_DYNAMIC_RANGE)
+			retval.append("Could not set dynamic range in receiver.\n");
+
+		if(slsErrorMask&RECEIVER_TEN_GIGA)
+			retval.append("Could not enable/disable 10GbE in the receiver.\n");
+
+		if(slsErrorMask&ALLTIMBITS_NOT_SET)
+			retval.append("Could not set all trimbits to value.\n");
+
+		if(slsErrorMask&COULD_NOT_SET_SPEED_PARAMETERS)
+			retval.append("Could not set the speed parameter value\n");
+
+		if(slsErrorMask&COULD_NOT_SET_READOUT_FLAGS)
+			retval.append("Could not set the readout flag\n");
+
+		if(slsErrorMask&COULD_NOT_SET_FIFO_DEPTH)
+			retval.append("Could not set receiver fifo depth\n");
+
+		if(slsErrorMask&COULD_NOT_SET_COUNTER_BIT)
+			retval.append("Could not set/reset counter bit\n");
+
+		if(slsErrorMask&COULD_NOT_PULSE)
+			retval.append("Could not pulse pixel or chip\n");
+
+		if(slsErrorMask&COULD_NOT_SET_RATE_CORRECTION)
+			retval.append("Could not set rate correction\n");
+
+		if(slsErrorMask&DETECTOR_NETWORK_PARAMETER)
+			retval.append("Could not set/get detector network parameter\n");
+
+		if(slsErrorMask&RATE_CORRECTION_NOT_32or16BIT)
+			retval.append("Rate correction Deactivated, must be in 32 or 16 bit mode\n");
+
+		if(slsErrorMask&RATE_CORRECTION_NO_TAU_PROVIDED)
+			retval.append("Rate correction Deactivated. No default tau provided in file\n");
+
+		if(slsErrorMask&PROGRAMMING_ERROR)
+			retval.append("Could not program FPGA\n");
+
+		if(slsErrorMask&RECEIVER_ACTIVATE)
+			retval.append("Could not activate/deactivate receiver\n");
+
+		if(slsErrorMask&DATA_STREAMING)
+			retval.append("Could not enable/disable Data Streaming\n");
+
+		if(slsErrorMask&RESET_ERROR)
+			retval.append("Could not reset the FPGA\n");
+
+		if(slsErrorMask&POWER_CHIP)
+			retval.append("Could not power on/off/get the chip\n");
+
+		if(slsErrorMask&RECEIVER_STREAMING_TIMER)
+			retval.append("Could not set receiver read timer\n");
+
+		if(slsErrorMask&RECEIVER_FLIPPED_DATA_NOT_SET)
+			retval.append("Could not set receiver flipped data/bottom\n");
+
+		if(slsErrorMask&THRESHOLD_NOT_SET)
+			retval.append("Could not set threshold\n");
+
+		if(slsErrorMask&RECEIVER_FILE_FORMAT)
+			retval.append("Could not set receiver file format\n");
+
+		if(slsErrorMask&RECEIVER_TIMER_NOT_SET)
+			retval.append("Could not set timer in receiver.\n");
+
+		if(slsErrorMask&RECEIVER_PARAMETER_NOT_SET)
+			retval.append("Could not set a paramater in receiver.\n");
+
+		if(slsErrorMask&RECEIVER_ENABLE_GAPPIXELS_NOT_SET)
+			retval.append("Could not enable/disable gap pixels in receiver.\n");
+
+		if(slsErrorMask&RESTREAM_STOP_FROM_RECEIVER)
+				retval.append("Could not restream stop from receiver.\n");
+
+        if(slsErrorMask&TEMPERATURE_CONTROL)
+                retval.append("Could not set/get threshold temperature, temp control or temp event.\n");
+
+        if(slsErrorMask&AUTO_COMP_DISABLE)
+                retval.append("Could not set/get auto comparator disable\n");
+
+        if(slsErrorMask&CONFIG_FILE)
+                retval.append("Could not load/write config file\n");
+
+        if(slsErrorMask&OTHER_ERROR_CODE)
+                retval.append("Some error occured.\n");
+
+		//------------------------------------------------------ length of message
+
+
+		return retval;
+
+	}
+
+
+	  /** Sets multi error mask
+	     @param multi error mask to be set to
+	     /returns multi error mask
+	  */
+	  int64_t  setErrorMask(int64_t i){errorMask=i;return getErrorMask();};
+
+	  /**returns multi error mask  */
+	   int64_t  getErrorMask(){return errorMask;};
+
+	   /** Clears error mask
+	      /returns error mask
+	   */
+	   int64_t clearErrorMask(){errorMask=0;return errorMask;};
+
+	   /** Gets the not added detector list
+	      /returns list
+	   */
+	   char* getNotAddedList(){return notAddedList;};
+
+	   /** Append the detector to not added detector list
+	    * @param name append to the list
+	      /returns list
+	   */
+	   void appendNotAddedList(const char* name){strcat(notAddedList,name);strcat(notAddedList,"+");};
+
+	   /** Clears not added detector list
+	      /returns error mask
+	   */
+	   void clearNotAddedList(){strcpy(notAddedList,"");};
+
+
+protected:
+
+	  /** Error Mask */
+	  int64_t errorMask;
+
+	  /** Detectors Not added List */
+	  char notAddedList[MAX_STR_LENGTH];
+
+};
+
+#endif /* ERROR_DEFS_H_ */

slsSupportLib/include/file_utils.h

@@ -0,0 +1,56 @@
+#pragma once
+
+
+#include "sls_detector_defs.h"
+
+#include <string>
+#include <fstream>
+#include <stdio.h>
+
+
+/** (used by multi and sls)
+ * reads a short int raw data file
+ * @param infile input file stream
+ * @param data array of data values
+ * @param nch number of channels
+ * @param offset start channel value
+ * @returns OK or FAIL if it could not read the file or data=NULL
+ */
+int readDataFile(std::ifstream &infile, short int *data, int nch, int offset=0);
+
+
+/** (used by multi and sls)
+ * reads a short int rawdata file
+ * @param name of the file to be read
+ * @param data array of data value
+ * @param nch number of channels
+ * @returns OK or FAIL if it could not read the file or data=NULL
+ */
+int readDataFile(std::string fname, short int *data, int nch);
+
+
+/** (used by multi and sls)
+ * writes a short int raw data file
+ * @param outfile output file stream
+ * @param nch number of channels
+ * @param data array of data values
+ * @param offset start channel number
+ * @returns OK or FAIL if it could not write the file or data=NULL
+ */
+int writeDataFile(std::ofstream &outfile,int nch,  short int *data, int offset=0);
+
+
+
+/** (used by multi and sls)
+ * writes a short int raw data file
+ * @param fname of the file to be written
+ * @param nch number of channels
+ * @param data array of data values
+ * @returns OK or FAIL if it could not write the file or data=NULL
+ */
+int writeDataFile(std::string fname,int nch, short int *data);
+
+
+
+
+

slsSupportLib/include/genericSocket.h

@@ -0,0 +1,822 @@
+#pragma once
+/**
+ * 
+ * @libdoc genericSocket provides some functions to open/close sockets both TCP and UDP
+ *
+ * @short some functions to open/close sockets both TCP and UDP
+ * @author Anna Bergamaschi
+ * @version 0.0
+ */
+
+#include "ansi.h"
+#include "sls_detector_exceptions.h"
+
+#ifdef __CINT__
+//class  sockaddr_in;
+class socklen_t;
+class uint32_t;
+class uint32_t_ss; 
+// CINT view of types:
+class sockaddr_in;
+// {
+//     unsigned short int sa_family;
+//    unsigned char sa_data[14];
+//   };
+#else
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#include <sys/prctl.h> // capabilities
+#include <linux/capability.h>
+
+#endif
+
+#include <stdlib.h>  /******exit */
+#include <unistd.h>
+#include <string.h>
+#include <iostream>
+#include <math.h>
+#include <errno.h>
+#include <stdio.h>
+#include "logger.h"
+
+
+#define DEFAULT_PACKET_SIZE 1286
+#define SOCKET_BUFFER_SIZE (100*1024*1024) //100 MB
+#define DEFAULT_BACKLOG 5
+
+using sls::SocketError;
+
+class genericSocket{
+
+public:
+
+	/**  Communication protocol	 */
+	enum communicationProtocol{
+		TCP,  	/**< TCP/IP */
+		UDP 	/**< UDP */
+	};
+
+	/**
+	 * The constructor for a client
+	 * throws an exception if the hostname/ip could not be converted to an internet address
+	 * @param host_ip_or_name hostname or ip of the client
+	 * @param port_number port number to connect to
+	 * @param p TCP or UDP
+	 * @param ps a single packet size
+	 */
+	genericSocket(const char* const host_ip_or_name,
+			unsigned short int const port_number,
+			communicationProtocol p, int ps = DEFAULT_PACKET_SIZE) :
+				portno(port_number),
+				protocol(p),
+				is_a_server(0),
+				packet_size(ps),
+				nsending(0),
+				nsent(0),
+				total_sent(0),// sender (client): where to? ip
+				header_packet_size(0),
+				actual_udp_socket_buffer_size(0) {
+		memset(&serverAddress, 0, sizeof(serverAddress));
+		memset(&clientAddress, 0, sizeof(clientAddress));
+		memset(lastClientIP,0,INET_ADDRSTRLEN);
+		memset(thisClientIP,0,INET_ADDRSTRLEN);
+		memset(dummyClientIP,0,INET_ADDRSTRLEN);
+		differentClients = 0;
+
+		struct addrinfo *result;
+		if (ConvertHostnameToInternetAddress(host_ip_or_name, &result)) {
+			sockfd.fd  = -1;
+			throw SocketError("Could convert hostname to address");
+		}
+
+		sockfd.fd = 0;
+		serverAddress.sin_family = result->ai_family;
+		memcpy((char *) &serverAddress.sin_addr.s_addr,
+				&((struct sockaddr_in *) result->ai_addr)->sin_addr, sizeof(in_addr_t));
+		freeaddrinfo(result);
+		serverAddress.sin_port = htons(port_number);
+		clientAddress_length=sizeof(clientAddress);
+	};
+
+	/**
+	 * The constructor for a server
+	 * throws an exception if socket could not be created, closes descriptor before throwing
+	 * @param port_number port number to connect to
+	 * @param p TCP or UDP
+	 * @param ps a single packet size
+	 * @param eth interface name or IP address to listen to (if NULL, listen to all interfaces)
+	 */
+	genericSocket(unsigned short int const port_number, communicationProtocol p,
+			int ps = DEFAULT_PACKET_SIZE, const char *eth=NULL, int hsize=0,
+			uint64_t buf_size=SOCKET_BUFFER_SIZE):
+				portno(port_number),
+				protocol(p),
+				is_a_server(1),
+				packet_size(ps),
+				nsending(0),
+				nsent(0),
+				total_sent(0),
+				header_packet_size(hsize),
+				actual_udp_socket_buffer_size(0) {
+
+
+		memset(&serverAddress, 0, sizeof(serverAddress));
+		memset(&clientAddress, 0, sizeof(clientAddress));
+		memset(lastClientIP,0,INET_ADDRSTRLEN);
+		memset(thisClientIP,0,INET_ADDRSTRLEN);
+		memset(dummyClientIP,0,INET_ADDRSTRLEN);
+		differentClients = 0;
+
+		// same port
+		if(serverAddress.sin_port == htons(port_number)){
+			sockfd.fd = -10;
+			throw SocketError("Cannot create socket on same port");
+		}
+
+		char ip[20];
+
+		strcpy(ip,"0.0.0.0");
+		clientAddress_length=sizeof(clientAddress);
+		if (eth) {
+			strcpy(ip,nameToIp(std::string(eth)).c_str());
+			if (std::string(ip)==std::string("0.0.0.0"))
+				strcpy(ip,eth);
+		}
+
+		sockfd.fd = socket(AF_INET, getProtocol(),0); //tcp
+
+		if (sockfd.fd < 0) {
+			FILE_LOG(logERROR) << "Can not create socket";
+			sockfd.fd =-1;
+			throw SocketError("Can not create socket");
+		}
+
+		// Set some fields in the serverAddress structure.
+		serverAddress.sin_family = AF_INET;
+		serverAddress.sin_port = htons(port_number);
+		serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+
+
+		if (std::string(ip)!=std::string("0.0.0.0")) {
+			if (inet_pton(AF_INET, ip, &(serverAddress.sin_addr)));
+			else
+				serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+		}
+
+
+		// reuse port
+		{
+			int val=1;
+			if (setsockopt(sockfd.fd,SOL_SOCKET,SO_REUSEADDR,
+					&val,sizeof(int)) == -1) {
+			    FILE_LOG(logERROR) << "setsockopt REUSEADDR failed";
+				sockfd.fd =-1;
+				throw SocketError("setsockopt REUSEADDR failed");
+			}
+		}
+
+		//increase socket buffer size if its udp
+		if (p == UDP) {
+			uint64_t desired_size = buf_size;
+			uint64_t real_size = desired_size * 2; // kernel doubles this value for bookkeeping overhead
+			uint64_t ret_size = -1;
+			socklen_t optlen = sizeof(uint64_t);
+
+			// confirm if sufficient
+			if (getsockopt(sockfd.fd, SOL_SOCKET, SO_RCVBUF, &ret_size, &optlen) == -1) {
+				FILE_LOG(logWARNING) << "[Port " << port_number << "] "
+						"Could not get rx socket receive buffer size";
+			} else if (ret_size >= real_size) {
+				actual_udp_socket_buffer_size = ret_size;
+				FILE_LOG(logDEBUG1) << "[Port " << port_number << "] "
+						"UDP rx socket buffer size is sufficient (" << ret_size << ")";
+			}
+
+			// not sufficient, enhance size
+			else {
+				// set buffer size (could not set)
+				if (setsockopt(sockfd.fd, SOL_SOCKET, SO_RCVBUF,
+						&desired_size, optlen) == -1) {
+					FILE_LOG(logWARNING) << "[Port " << port_number << "] "
+							"Could not set rx socket buffer size to "
+							<< desired_size << ". (No Root Privileges?)";
+				}
+				// confirm size
+				else if (getsockopt(sockfd.fd, SOL_SOCKET, SO_RCVBUF,
+						&ret_size, &optlen) == -1) {
+					FILE_LOG(logWARNING) << "[Port " << port_number << "] "
+							"Could not get rx socket buffer size";
+				}
+				else if (ret_size >= real_size) {
+					actual_udp_socket_buffer_size = ret_size;
+					FILE_LOG(logINFO) << "[Port " << port_number << "] "
+							"UDP rx socket buffer size modified to " << ret_size;
+				}
+				// buffer size too large
+				else {
+					actual_udp_socket_buffer_size = ret_size;
+					// force a value larger than system limit
+					// (if run in a privileged context (capability CAP_NET_ADMIN set))
+					int ret = setsockopt(sockfd.fd, SOL_SOCKET, SO_RCVBUFFORCE,
+							&desired_size, optlen);
+					getsockopt(sockfd.fd, SOL_SOCKET, SO_RCVBUF,
+							&ret_size, &optlen);
+					if (ret == -1) {
+						FILE_LOG(logWARNING) << "[Port " << port_number << "] "
+								"Could not force rx socket buffer size to "
+								<< desired_size << ".\n  Real size: " << ret_size <<
+								". (No Root Privileges?)\n"
+								"  To remove this warning: set rx_udpsocksize from client to <= " <<
+								(ret_size/2) << " (Real size:" << ret_size << ").";
+					} else {
+						FILE_LOG(logINFO) << "[Port " << port_number << "] "
+								"UDP rx socket buffer size modified to " << ret_size;
+					}
+				}
+			}
+		}
+
+
+		if(bind(sockfd.fd,(struct sockaddr *) &serverAddress,sizeof(serverAddress))<0){
+            FILE_LOG(logERROR) << "Can not bind socket";
+			sockfd.fd =-1;
+			throw SocketError("Can not bind socket");
+		}
+
+
+		if (getProtocol()==SOCK_STREAM)
+			listen(sockfd.fd, DEFAULT_BACKLOG);
+
+	}
+
+	/**
+	 * The destructor: disconnects and close the socket
+	 */
+	~genericSocket() {
+		//mySocketDescriptor destructor also gets called
+		serverAddress.sin_port=-1;
+	};
+
+	/**
+	 * Returns actual udp socket buffer size/2.
+	 * Halving is because of kernel book keeping
+	 * @returns actual udp socket buffer size/2
+	 */
+	uint64_t getActualUDPSocketBufferSize(){return actual_udp_socket_buffer_size;};
+
+	/**
+	 * Get protocol TCP or UDP
+-    * @returns TCP or UDP
+	 */
+	int getCommunicationProtocol(){return protocol;};
+
+	/**
+	 * Get port number
+	 * @retrns port number
+	 */
+	uint16_t getPortNumber(){return ntohs(serverAddress.sin_port);}
+
+	/**
+	 * Get TCP Server File Descriptor
+	 * @returns TCP Server file descriptor
+	 */
+	int getFileDes(){return sockfd.newfd;};
+
+	/**
+	 * Get socket descriptor
+	 * @returns socket descriptor
+	 */
+	int getsocketDescriptor(){return sockfd.fd;};
+
+	/**
+	 * Get total bytes sent/received
+	 * Makes sense only for udp socket as there is only receive data
+	 */
+	int getCurrentTotalReceived(){return total_sent;};
+
+	/**
+	 * Get type of protocol based on protocol
+	 * @param p TCP or UDP
+	 * @returns SOCK_STREAM/SOCK_DGRAM or -1
+	 */
+	int getProtocol(communicationProtocol p) {
+		switch (p) {
+		case TCP:
+			return SOCK_STREAM;
+			break;
+		case UDP:
+			return SOCK_DGRAM;
+		default:
+		    FILE_LOG(logERROR) << "unknown protocol: " << p;
+			return -1;
+		}
+	};
+
+	/**
+	 * Get current protocol type
+	 * @returns SOCK_STREAM/SOCK_DGRAM or -1
+	 */
+	int getProtocol() {return getProtocol(protocol);};
+
+	/**
+	 * Close TCP Server socket descriptor
+	 */
+	void CloseServerTCPSocketDescriptor() {
+		if (protocol == TCP && is_a_server) {
+			if (sockfd.fd >= 0) {
+				close(sockfd.fd);
+				sockfd.fd = -1;
+			}
+		}
+	};
+
+	/**
+	 * Disconnect
+	 */
+	void Disconnect(){
+		if (protocol == TCP && is_a_server) {
+			if (sockfd.newfd >= 0) {
+				close(sockfd.newfd);
+				sockfd.newfd = -1;
+			}
+			return;
+		}
+		if (sockfd.fd >= 0) {
+			close(sockfd.fd);
+			sockfd.fd = -1;
+		}
+	};
+
+	/**
+	 * Establishes connection
+	 * @returns 1 if error
+	 */
+	int  Connect(){
+
+		if(sockfd.newfd>0) return sockfd.newfd;
+		if (protocol==UDP) return -1;
+
+		if(is_a_server && protocol==TCP){ //server tcp; the server will wait for the clients connection
+			if (sockfd.fd>0) {
+				if ((sockfd.newfd = accept(sockfd.fd,(struct sockaddr *) &clientAddress, &clientAddress_length)) < 0) {
+				    FILE_LOG(logERROR) << "with server accept, connection refused";
+					switch(errno) {
+					case EWOULDBLOCK:
+					    FILE_LOG(logERROR) << "ewouldblock eagain";
+						break;
+					case EBADF:
+						FILE_LOG(logERROR) << "ebadf";
+						break;
+					case ECONNABORTED:
+						FILE_LOG(logERROR) << "econnaborted";
+						break;
+					case EFAULT:
+						FILE_LOG(logERROR) << "efault";
+						break;
+					case EINTR:
+						FILE_LOG(logERROR) << "eintr";
+						break;
+					case EINVAL:
+						FILE_LOG(logERROR) << "einval";
+						break;
+					case EMFILE:
+						FILE_LOG(logERROR) << "emfile";
+						break;
+					case ENFILE:
+						FILE_LOG(logERROR) << "enfile";
+						break;
+					case ENOTSOCK:
+						FILE_LOG(logERROR) << "enotsock";
+						break;
+					case EOPNOTSUPP:
+						FILE_LOG(logERROR) << "eOPNOTSUPP";
+						break;
+					case ENOBUFS:
+						FILE_LOG(logERROR) << "ENOBUFS";
+						break;
+					case ENOMEM:
+						FILE_LOG(logERROR) << "ENOMEM";
+						break;
+					case ENOSR:
+						FILE_LOG(logERROR) << "ENOSR";
+						break;
+					case EPROTO:
+						FILE_LOG(logERROR) << "EPROTO";
+						break;
+					default:
+						FILE_LOG(logERROR) << "unknown error";
+					}
+				}
+				else{
+					inet_ntop(AF_INET, &(clientAddress.sin_addr), dummyClientIP, INET_ADDRSTRLEN);
+					FILE_LOG(logDEBUG1) << "client connected " << sockfd.newfd;
+				}
+			}
+			FILE_LOG(logDEBUG1) << "fd " << sockfd.newfd;
+			return sockfd.newfd;
+		} else {
+			if (sockfd.fd<=0)
+				sockfd.fd = socket(AF_INET, getProtocol(),0);
+			//    SetTimeOut(10);
+			if (sockfd.fd < 0){
+			    FILE_LOG(logERROR) << "Can not create socket";
+			} else {
+				if(connect(sockfd.fd,(struct sockaddr *) &serverAddress,sizeof(serverAddress))<0){
+				    FILE_LOG(logERROR) << "Can not connect to socket";
+					return -1;
+				}
+			}
+			return sockfd.fd;
+		}
+	};
+
+	/**
+	 * Exit server
+	 */
+	void exitServer(){
+		Disconnect();
+		CloseServerTCPSocketDescriptor();
+	};
+
+	/**
+	 * Shut down socket
+	 */
+	void ShutDownSocket(){
+		shutdown(sockfd.fd, SHUT_RDWR);
+		Disconnect();
+	};
+
+	/**
+	 * Set the socket timeout ts is in seconds
+	 * @param ts time in seconds
+	 * @returns 0 for success, else -1
+	 */
+	int SetTimeOut(int ts){
+		if (ts<=0)
+			return -1;
+
+		struct timeval tout;
+		tout.tv_sec  = 0;
+		tout.tv_usec = 0;
+		if(::setsockopt(sockfd.fd, SOL_SOCKET, SO_RCVTIMEO,
+				&tout, sizeof(struct timeval)) <0) {
+		    FILE_LOG(logERROR) << "setsockopt SO_RCVTIMEO " << 0;
+		}
+		tout.tv_sec  = ts;
+		tout.tv_usec = 0;
+		if(::setsockopt(sockfd.fd, SOL_SOCKET, SO_SNDTIMEO,
+				&tout, sizeof(struct timeval)) < 0)	{
+		    FILE_LOG(logERROR) << "setsockopt SO_SNDTIMEO " << ts;
+		}
+		return 0;
+	};
+
+	/**
+	 * Set packet size
+	 * @param i packet size
+	 * @returns current packet size
+	 */
+	int setPacketSize(int i=-1) { if (i>=0) packet_size=i;return packet_size;};
+
+	/**
+	 * Convert IP to hostname
+	 * @param ip IP
+	 * @returns hostname
+	 */
+	static std::string ipToName(std::string ip) {
+		struct ifaddrs *addrs, *iap;
+		struct sockaddr_in *sa;
+
+		char buf[32];
+		const int buf_len = sizeof(buf);
+		memset(buf,0,buf_len);
+		strcpy(buf,"none");
+
+		getifaddrs(&addrs);
+		for (iap = addrs; iap != NULL; iap = iap->ifa_next) {
+			if (iap->ifa_addr && (iap->ifa_flags & IFF_UP) && iap->ifa_addr->sa_family == AF_INET) {
+				sa = (struct sockaddr_in *)(iap->ifa_addr);
+				inet_ntop(iap->ifa_addr->sa_family, (void *)&(sa->sin_addr), buf, buf_len);
+				if (ip==std::string(buf)) {
+					strcpy(buf,iap->ifa_name);
+					break;
+				}
+			}
+		}
+		freeifaddrs(addrs);
+		return std::string(buf);
+	};
+
+	/**
+	 * Convert interface to mac address
+	 * @param inf interface
+	 * @returns mac address
+	 */
+	static std::string nameToMac(std::string inf) {
+		struct ifreq ifr;
+		int sock, j, k;
+		char mac[32];
+		const int mac_len = sizeof(mac);
+		memset(mac,0,mac_len);
+
+		sock=getSock(inf,&ifr);
+
+		if (-1==ioctl(sock, SIOCGIFHWADDR, &ifr)) {
+			perror("ioctl(SIOCGIFHWADDR) ");
+			return std::string("00:00:00:00:00:00");
+		}
+		for (j=0, k=0; j<6; j++) {
+			k+=snprintf(mac+k, mac_len-k-1, j ? ":%02X" : "%02X",
+					(int)(unsigned int)(unsigned char)ifr.ifr_hwaddr.sa_data[j]);
+		}
+		mac[mac_len-1]='\0';
+
+		if(sock!=1){
+			close(sock);
+		}
+		return std::string(mac);
+
+	};
+
+	/**
+	 * Convert hostname to ip
+	 * @param inf hostname
+	 * @returns IP
+	 */
+	static std::string nameToIp(std::string inf){
+		struct ifreq ifr;
+		int sock;
+		char *p, addr[32];
+		const int addr_len = sizeof(addr);
+		memset(addr,0,addr_len);
+
+		sock=getSock(inf,&ifr);
+
+		if (-1==ioctl(sock, SIOCGIFADDR, &ifr)) {
+			perror("ioctl(SIOCGIFADDR) ");
+			return std::string("0.0.0.0");
+		}
+		p=inet_ntoa(((struct sockaddr_in *)(&ifr.ifr_addr))->sin_addr);
+		strncpy(addr,p,addr_len-1);
+		addr[addr_len-1]='\0';
+
+		if(sock!=1){
+			close(sock);
+		}
+		return std::string(addr);
+
+	};
+
+	/**
+	 * Get socket
+	 * @param inf hostname
+	 * @param ifr interface request structure
+	 * @returns sock
+	 */
+	static int getSock(std::string inf, struct ifreq *ifr) {
+
+		int sock;
+		sock=socket(PF_INET, SOCK_STREAM, 0);
+		if (-1==sock) {
+			perror("socket() ");
+			return 1;
+		}
+		strncpy(ifr->ifr_name,inf.c_str(),sizeof(ifr->ifr_name)-1);
+		ifr->ifr_name[sizeof(ifr->ifr_name)-1]='\0';
+
+		return sock;
+	};
+
+	/**
+	 * Convert Hostname to Internet address info structure
+	 * One must use freeaddrinfo(res) after using it
+	 * @param hostname hostname
+	 * @param res address of pointer to address info structure
+	 * @return 1 for fail, 0 for success
+	 */
+	// Do not make this static (for multi threading environment)
+	int ConvertHostnameToInternetAddress (const char* const hostname, struct addrinfo **res) {
+		// criteria in selecting socket address structures returned by res
+		struct addrinfo hints;
+		memset (&hints, 0, sizeof (hints));
+		hints.ai_family = AF_INET;
+		hints.ai_socktype = SOCK_STREAM;
+		// get host info into res
+		int errcode = getaddrinfo (hostname, NULL, &hints, res);
+		if (errcode != 0) {
+		    FILE_LOG(logERROR) << "Could not convert hostname (" << hostname << ") to internet address (zmq):" <<
+					gai_strerror(errcode);
+		} else {
+			if (*res == NULL) {
+			    FILE_LOG(logERROR) << "Could not converthostname (" << hostname << ") to internet address (zmq):"
+						"gettaddrinfo returned null";
+			} else{
+				return 0;
+			}
+		}
+		 FILE_LOG(logERROR) << "Could not convert hostname to internet address";
+		return 1;
+	};
+
+	/**
+	 * Convert Internet Address structure pointer to ip string (char*)
+	 * Clears the internet address structure as well
+	 * @param res pointer to internet address structure
+	 * @param ip pointer to char array to store result in
+	 * @param ipsize size available in ip buffer
+	 * @return 1 for fail, 0 for success
+	 */
+	// Do not make this static (for multi threading environment)
+	int ConvertInternetAddresstoIpString (struct addrinfo *res, char* ip, const int ipsize) {
+		if (inet_ntop (res->ai_family, &((struct sockaddr_in *) res->ai_addr)->sin_addr, ip, ipsize) != NULL) {
+			freeaddrinfo(res);
+			return 0;
+		}
+		 FILE_LOG(logERROR) << "Could not convert internet address to ip string";
+		return 1;
+	}
+
+	/**
+	 * Receive data only
+	 * @param buf data
+	 * @param length size of data expecting, 0 for a single packet
+	 * @returns size of data received
+	 */
+	int ReceiveDataOnly(void* buf,int length=0){
+
+		if (buf==NULL) return -1;
+
+		total_sent=0;
+		int tcpfd = sockfd.fd;
+
+		switch(protocol) {
+		case TCP:
+			tcpfd = (is_a_server ? sockfd.newfd : sockfd.fd);
+			if (tcpfd<0) return -1;
+			while(length>0){
+				nsending = (length>packet_size) ? packet_size:length;
+				nsent = read(tcpfd,(char*)buf+total_sent,nsending);
+				if(!nsent) {
+					if(!total_sent) {
+						return -1; //to handle it
+					}
+					break;
+				}
+				length-=nsent;
+				total_sent+=nsent;
+			}
+
+			if (total_sent>0)
+				strcpy(thisClientIP,dummyClientIP);
+
+			if (strcmp(lastClientIP,thisClientIP))
+				differentClients=1;
+			else
+				differentClients=0;
+
+			break;
+		case UDP:
+			if (sockfd.fd<0) return -1;
+			//if length given, listens to length, else listens for packetsize till length is reached
+			if(length){
+				while(length>0){
+					nsending = (length>packet_size) ? packet_size:length;
+					nsent = recvfrom(sockfd.fd,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length);
+					if(nsent == header_packet_size)
+						continue;
+					if(nsent != nsending){
+						if(nsent && (nsent != -1)) {
+						    FILE_LOG(logERROR) << "Incomplete Packet size " << nsent;
+						}
+						break;
+					}
+					length-=nsent;
+					total_sent+=nsent;
+				}
+			}
+			//listens to only 1 packet
+			else{
+				//normal
+				nsending=packet_size;
+				while(1){
+					nsent = recvfrom(sockfd.fd,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length);
+					//break out of loop only if read one packets size or read didnt work (cuz of shutdown)
+					if(nsent<=0 || nsent == packet_size)
+						break;
+					//incomplete packets or header packets ignored and read buffer again
+					if(nsent != packet_size && nsent != header_packet_size) {
+					    FILE_LOG(logERROR) << portno << ": Incomplete Packet size " << nsent;
+					}
+				}
+				//nsent = 1040;
+				if(nsent > 0)total_sent+=nsent;
+			}
+			break;
+		default:
+			;
+		}
+		FILE_LOG(logDEBUG1) << "sent " << total_sent << " Bytes";
+		return total_sent;
+	}
+
+	/**
+	 * Send data only
+	 * @param buf data
+	 * @param length size of data expecting
+	 * @returns size of data sent
+	 */
+	int SendDataOnly(void *buf, int length) {
+	    FILE_LOG(logDEBUG1) << "want to send " << length << " Bytes";
+		if (buf==NULL) return -1;
+
+		total_sent=0;
+
+		int tcpfd = sockfd.fd;
+
+		switch(protocol) {
+		case TCP:
+			tcpfd = (is_a_server ? sockfd.newfd : sockfd.fd);
+			if (tcpfd<0) return -1;
+			while(length>0){
+				nsending = (length>packet_size) ? packet_size:length;
+				nsent = write(tcpfd,(char*)buf+total_sent,nsending);
+				if(is_a_server && nsent < 0) {
+				    FILE_LOG(logERROR) << "Could not write to socket. Possible client socket crash";
+					break;
+				}
+				if(!nsent) break;
+				length-=nsent;
+				total_sent+=nsent;
+			}
+			break;
+		case UDP:
+			if (sockfd.fd<0) return -1;
+			while(length>0){
+				nsending = (length>packet_size) ? packet_size:length;
+				nsent = sendto(sockfd.fd,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, clientAddress_length);
+				if(!nsent) break;
+				length-=nsent;
+				total_sent+=nsent;
+			}
+
+			break;
+		default:
+			;
+		}
+		FILE_LOG(logDEBUG1) << "sent "<< total_sent << " Bytes";
+		return total_sent;
+	}
+
+	char lastClientIP[INET_ADDRSTRLEN];
+	char thisClientIP[INET_ADDRSTRLEN];
+	int differentClients;
+
+private:
+	/**
+	 * Class to close socket descriptors automatically
+	 * upon encountering exceptions in the genericSocket constructor
+	 */
+	class mySocketDescriptors {
+	public:
+
+		/** Constructor */
+		mySocketDescriptors():fd(-1), newfd(-1){};
+		/** Destructor */
+		~mySocketDescriptors() {
+			// close TCP server new socket descriptor from accept
+			if (newfd >= 0) {
+				close(newfd);
+			}
+			// close socket descriptor
+			if (fd >= 0) {
+				close(fd);
+			}
+		}
+		/** socket descriptor */
+		int fd;
+		/** new socket descriptor in TCP server from accept */
+		int newfd;
+	};
+
+protected:
+	int portno;
+	communicationProtocol protocol;
+	int is_a_server;
+	mySocketDescriptors sockfd;
+	int packet_size;
+	struct sockaddr_in clientAddress, serverAddress;
+	socklen_t clientAddress_length;
+	char dummyClientIP[INET_ADDRSTRLEN];
+
+private:
+	int nsending;
+	int nsent;
+	int total_sent;
+	int header_packet_size;
+	uint64_t actual_udp_socket_buffer_size;
+};

slsSupportLib/include/logger.h

@@ -0,0 +1,190 @@
+#pragma once
+
+#include <sstream>
+#include <string>
+#include <stdio.h>
+#include <unistd.h>
+#include <ansi.h>
+
+
+
+#ifdef FIFODEBUG
+#define FILELOG_MAX_LEVEL logDEBUG5
+#elif VERYVERBOSE
+#define FILELOG_MAX_LEVEL logDEBUG4
+#elif VERBOSE
+#define FILELOG_MAX_LEVEL logDEBUG
+#endif
+
+#ifndef FILELOG_MAX_LEVEL
+#define FILELOG_MAX_LEVEL logINFO
+//#define FILELOG_MAX_LEVEL logDEBUG5
+#endif
+
+
+#define STRINGIFY(x) #x
+#define TOSTRING(x) STRINGIFY(x)
+#define MYCONCAT(x,y)  
+#define __AT__  std::string(__FILE__) + std::string("::") + std::string(__func__) + std::string("(): ")
+#define __SHORT_FORM_OF_FILE__ \
+(strrchr(__FILE__,'/') \
+? strrchr(__FILE__,'/')+1 \
+: __FILE__ \
+)
+#define __SHORT_AT__  std::string(__SHORT_FORM_OF_FILE__) + std::string("::") + std::string(__func__) + std::string("(): ")
+
+
+
+
+inline std::string NowTime();
+// 1 normal debug, 3 function names, 5 fifodebug
+enum TLogLevel {logERROR, logWARNING, logINFOBLUE, logINFOGREEN, logINFORED, logINFO,
+	logDEBUG, logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4, logDEBUG5};
+
+template <typename T> class Log{
+ public:
+	Log();
+	virtual ~Log();
+	std::ostringstream& Get(TLogLevel level = logINFO);
+	static TLogLevel& ReportingLevel();
+	static std::string ToString(TLogLevel level);
+	static TLogLevel FromString(const std::string& level);
+ protected:
+	std::ostringstream os;
+	TLogLevel lev;
+ private:
+	Log(const Log&);
+	Log& operator =(const Log&);
+};
+
+
+class Output2FILE {
+public:
+    static FILE*& Stream();
+    static void Output(const std::string& msg);
+    static void Output(const std::string& msg, TLogLevel level);
+};
+
+
+#define FILELOG_DECLSPEC
+
+class FILELOG_DECLSPEC FILELog : public Log<Output2FILE> {};
+
+
+#define FILE_LOG(level) \
+	if (level > FILELOG_MAX_LEVEL) ;				\
+	else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
+	else FILELog().Get(level)
+
+
+#include <sys/time.h>
+
+inline std::string NowTime()
+{
+    char buffer[12];
+    const int buffer_len = sizeof(buffer);
+    time_t t;
+    time(&t);
+    tm r;
+    strftime(buffer, buffer_len, "%X", localtime_r(&t, &r));
+    buffer[buffer_len - 1] = 0;
+    struct timeval tv;
+    gettimeofday(&tv, 0);
+    char result[100];
+    const int result_len = sizeof(result);
+    snprintf(result, result_len, "%s.%03ld", buffer, (long)tv.tv_usec / 1000);
+    result[result_len - 1] = 0;
+    return result;
+}
+
+
+template <typename T> Log<T>::Log():lev(logDEBUG){}
+
+template <typename T> std::ostringstream& Log<T>::Get(TLogLevel level)
+{
+	lev = level;
+    os << "- " << NowTime();
+    os << " " << ToString(level) << ": ";
+    if (level > logDEBUG)
+    	os << std::string(level - logDEBUG, ' ');
+    return os;
+}
+
+template <typename T> Log<T>::~Log()
+{
+    os << std::endl;
+    T::Output( os.str(),lev); // T::Output( os.str());
+}
+
+template <typename T> TLogLevel& Log<T>::ReportingLevel()
+{
+    static TLogLevel reportingLevel = logDEBUG5;
+    return reportingLevel;
+}
+
+template <typename T> std::string Log<T>::ToString(TLogLevel level)
+{
+	static const char* const buffer[] = {
+			"ERROR", "WARNING", "INFO", "INFO", "INFO", "INFO",
+			"DEBUG", "DEBUG1", "DEBUG2", "DEBUG3", "DEBUG4","DEBUG5"};
+    return buffer[level];
+}
+
+template <typename T>
+TLogLevel Log<T>::FromString(const std::string& level)
+{
+    if (level == "DEBUG5")
+        return logDEBUG5;
+    if (level == "DEBUG4")
+        return logDEBUG4;
+    if (level == "DEBUG3")
+        return logDEBUG3;
+    if (level == "DEBUG2")
+        return logDEBUG2;
+    if (level == "DEBUG1")
+        return logDEBUG1;
+    if (level == "DEBUG")
+        return logDEBUG;
+    if (level == "INFO")
+        return logINFO;
+    if (level == "WARNING")
+        return logWARNING;
+    if (level == "ERROR")
+        return logERROR;
+    Log<T>().Get(logWARNING) << "Unknown logging level '" << level << "'. Using INFO level as default.";
+    return logINFO;
+}
+
+
+inline FILE*& Output2FILE::Stream()
+{
+    static FILE* pStream = stderr;
+    return pStream;
+}
+
+inline void Output2FILE::Output(const std::string& msg)
+{   
+    FILE* pStream = Stream();
+    if (!pStream)
+        return;
+    fprintf(pStream, "%s", msg.c_str());
+    fflush(pStream);
+}
+
+inline void Output2FILE::Output(const std::string& msg, TLogLevel level)
+{
+    FILE* pStream = Stream();
+    if (!pStream)
+        return;
+    bool out = true;
+    switch(level){
+    case logERROR:		cprintf(RED BOLD,"%s",msg.c_str()); 	break;
+    case logWARNING:	cprintf(YELLOW BOLD,"%s",msg.c_str()); 	break;
+    case logINFO:		cprintf(RESET,"%s",msg.c_str());		break;
+    case logINFOBLUE:	cprintf(BLUE,"%s",msg.c_str());			break;
+    case logINFORED:	cprintf(RED,"%s",msg.c_str());			break;
+    case logINFOGREEN:	cprintf(GREEN,"%s",msg.c_str());		break;
+    default: 			fprintf(pStream,"%s",msg.c_str()); 	out = false; 	break;
+    }
+    fflush(out ? stdout : pStream);
+}

slsSupportLib/include/network_utils.h

@@ -0,0 +1,63 @@
+#pragma once
+#include <iostream>
+#include <string>
+
+namespace sls {
+
+uint32_t HostnameToIp(const char *hostname);
+
+class IpAddr {
+  private:
+    uint32_t addr_{0};
+
+  public:
+    constexpr IpAddr(uint32_t address) noexcept : addr_{address} {}
+    IpAddr(const std::string &address);
+    IpAddr(const char *address);
+    std::string str() const;
+    std::string hex() const;
+    constexpr bool operator==(const IpAddr &other) const noexcept {
+        return addr_ == other.addr_;
+    }
+    constexpr bool operator!=(const IpAddr &other) const noexcept {
+        return addr_ != other.addr_;
+    }
+    constexpr bool operator==(const uint32_t other) const noexcept {
+        return addr_ == other;
+    }
+    constexpr bool operator!=(const uint32_t other) const noexcept {
+        return addr_ != other;
+    }
+    constexpr uint32_t uint32() const noexcept { return addr_; }
+};
+
+class MacAddr {
+  private:
+    uint64_t addr_{0};
+    std::string to_hex(const char delimiter = 0) const;
+
+  public:
+    constexpr MacAddr(uint64_t mac) noexcept : addr_{mac} {}
+    MacAddr(std::string mac);
+    MacAddr(const char *address);
+    std::string str() const;
+    std::string hex() const;
+    constexpr bool operator==(const MacAddr &other) const noexcept {
+        return addr_ == other.addr_;
+    }
+    constexpr bool operator!=(const MacAddr &other) const noexcept {
+        return addr_ != other.addr_;
+    }
+    constexpr bool operator==(const uint64_t other) const noexcept {
+        return addr_ == other;
+    }
+    constexpr bool operator!=(const uint64_t other) const noexcept {
+        return addr_ != other;
+    }
+    constexpr uint64_t uint64() const noexcept { return addr_; }
+};
+
+std::ostream &operator<<(std::ostream &out, const IpAddr &addr);
+std::ostream &operator<<(std::ostream &out, const MacAddr &addr);
+
+} // namespace sls

slsSupportLib/include/rapidjson/allocators.h

@@ -0,0 +1,271 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ALLOCATORS_H_
+#define RAPIDJSON_ALLOCATORS_H_
+
+#include "rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Allocator
+
+/*! \class rapidjson::Allocator
+    \brief Concept for allocating, resizing and freeing memory block.
+    
+    Note that Malloc() and Realloc() are non-static but Free() is static.
+    
+    So if an allocator need to support Free(), it needs to put its pointer in 
+    the header of memory block.
+
+\code
+concept Allocator {
+    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().
+
+    // Allocate a memory block.
+    // \param size of the memory block in bytes.
+    // \returns pointer to the memory block.
+    void* Malloc(size_t size);
+
+    // Resize a memory block.
+    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
+    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
+    // \param newSize the new size in bytes.
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);
+
+    // Free a memory block.
+    // \param pointer to the memory block. Null pointer is permitted.
+    static void Free(void *ptr);
+};
+\endcode
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// CrtAllocator
+
+//! C-runtime library allocator.
+/*! This class is just wrapper for standard C library memory routines.
+    \note implements Allocator concept
+*/
+class CrtAllocator {
+public:
+    static const bool kNeedFree = true;
+    void* Malloc(size_t size) { 
+        if (size) //  behavior of malloc(0) is implementation defined.
+            return std::malloc(size);
+        else
+            return NULL; // standardize to returning NULL.
+    }
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
+        (void)originalSize;
+        if (newSize == 0) {
+            std::free(originalPtr);
+            return NULL;
+        }
+        return std::realloc(originalPtr, newSize);
+    }
+    static void Free(void *ptr) { std::free(ptr); }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// MemoryPoolAllocator
+
+//! Default memory allocator used by the parser and DOM.
+/*! This allocator allocate memory blocks from pre-allocated memory chunks. 
+
+    It does not free memory blocks. And Realloc() only allocate new memory.
+
+    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.
+
+    User may also supply a buffer as the first chunk.
+
+    If the user-buffer is full then additional chunks are allocated by BaseAllocator.
+
+    The user-buffer is not deallocated by this allocator.
+
+    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
+    \note implements Allocator concept
+*/
+template <typename BaseAllocator = CrtAllocator>
+class MemoryPoolAllocator {
+public:
+    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)
+
+    //! Constructor with chunkSize.
+    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
+        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+    }
+
+    //! Constructor with user-supplied buffer.
+    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.
+
+        The user buffer will not be deallocated when this allocator is destructed.
+
+        \param buffer User supplied buffer.
+        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
+        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
+        \param baseAllocator The allocator for allocating memory chunks.
+    */
+    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
+        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
+    {
+        RAPIDJSON_ASSERT(buffer != 0);
+        RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
+        chunkHead_ = reinterpret_cast<ChunkHeader*>(buffer);
+        chunkHead_->capacity = size - sizeof(ChunkHeader);
+        chunkHead_->size = 0;
+        chunkHead_->next = 0;
+    }
+
+    //! Destructor.
+    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
+    */
+    ~MemoryPoolAllocator() {
+        Clear();
+        RAPIDJSON_DELETE(ownBaseAllocator_);
+    }
+
+    //! Deallocates all memory chunks, excluding the user-supplied buffer.
+    void Clear() {
+        while (chunkHead_ && chunkHead_ != userBuffer_) {
+            ChunkHeader* next = chunkHead_->next;
+            baseAllocator_->Free(chunkHead_);
+            chunkHead_ = next;
+        }
+        if (chunkHead_ && chunkHead_ == userBuffer_)
+            chunkHead_->size = 0; // Clear user buffer
+    }
+
+    //! Computes the total capacity of allocated memory chunks.
+    /*! \return total capacity in bytes.
+    */
+    size_t Capacity() const {
+        size_t capacity = 0;
+        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
+            capacity += c->capacity;
+        return capacity;
+    }
+
+    //! Computes the memory blocks allocated.
+    /*! \return total used bytes.
+    */
+    size_t Size() const {
+        size_t size = 0;
+        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
+            size += c->size;
+        return size;
+    }
+
+    //! Allocates a memory block. (concept Allocator)
+    void* Malloc(size_t size) {
+        if (!size)
+            return NULL;
+
+        size = RAPIDJSON_ALIGN(size);
+        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
+            if (!AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size))
+                return NULL;
+
+        void *buffer = reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size;
+        chunkHead_->size += size;
+        return buffer;
+    }
+
+    //! Resizes a memory block (concept Allocator)
+    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
+        if (originalPtr == 0)
+            return Malloc(newSize);
+
+        if (newSize == 0)
+            return NULL;
+
+        originalSize = RAPIDJSON_ALIGN(originalSize);
+        newSize = RAPIDJSON_ALIGN(newSize);
+
+        // Do not shrink if new size is smaller than original
+        if (originalSize >= newSize)
+            return originalPtr;
+
+        // Simply expand it if it is the last allocation and there is sufficient space
+        if (originalPtr == reinterpret_cast<char *>(chunkHead_) + RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + chunkHead_->size - originalSize) {
+            size_t increment = static_cast<size_t>(newSize - originalSize);
+            if (chunkHead_->size + increment <= chunkHead_->capacity) {
+                chunkHead_->size += increment;
+                return originalPtr;
+            }
+        }
+
+        // Realloc process: allocate and copy memory, do not free original buffer.
+        if (void* newBuffer = Malloc(newSize)) {
+            if (originalSize)
+                std::memcpy(newBuffer, originalPtr, originalSize);
+            return newBuffer;
+        }
+        else
+            return NULL;
+    }
+
+    //! Frees a memory block (concept Allocator)
+    static void Free(void *ptr) { (void)ptr; } // Do nothing
+
+private:
+    //! Copy constructor is not permitted.
+    MemoryPoolAllocator(const MemoryPoolAllocator& rhs) /* = delete */;
+    //! Copy assignment operator is not permitted.
+    MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) /* = delete */;
+
+    //! Creates a new chunk.
+    /*! \param capacity Capacity of the chunk in bytes.
+        \return true if success.
+    */
+    bool AddChunk(size_t capacity) {
+        if (!baseAllocator_)
+            ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator());
+        if (ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(RAPIDJSON_ALIGN(sizeof(ChunkHeader)) + capacity))) {
+            chunk->capacity = capacity;
+            chunk->size = 0;
+            chunk->next = chunkHead_;
+            chunkHead_ =  chunk;
+            return true;
+        }
+        else
+            return false;
+    }
+
+    static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity.
+
+    //! Chunk header for perpending to each chunk.
+    /*! Chunks are stored as a singly linked list.
+    */
+    struct ChunkHeader {
+        size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
+        size_t size;        //!< Current size of allocated memory in bytes.
+        ChunkHeader *next;  //!< Next chunk in the linked list.
+    };
+
+    ChunkHeader *chunkHead_;    //!< Head of the chunk linked-list. Only the head chunk serves allocation.
+    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
+    void *userBuffer_;          //!< User supplied buffer.
+    BaseAllocator* baseAllocator_;  //!< base allocator for allocating memory chunks.
+    BaseAllocator* ownBaseAllocator_;   //!< base allocator created by this object.
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ENCODINGS_H_

slsSupportLib/include/rapidjson/encodedstream.h

@@ -0,0 +1,299 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ENCODEDSTREAM_H_
+#define RAPIDJSON_ENCODEDSTREAM_H_
+
+#include "stream.h"
+#include "memorystream.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Input byte stream wrapper with a statically bound encoding.
+/*!
+    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
+    \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
+*/
+template <typename Encoding, typename InputByteStream>
+class EncodedInputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+public:
+    typedef typename Encoding::Ch Ch;
+
+    EncodedInputStream(InputByteStream& is) : is_(is) { 
+        current_ = Encoding::TakeBOM(is_);
+    }
+
+    Ch Peek() const { return current_; }
+    Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
+    size_t Tell() const { return is_.Tell(); }
+
+    // Not implemented
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); } 
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    EncodedInputStream(const EncodedInputStream&);
+    EncodedInputStream& operator=(const EncodedInputStream&);
+
+    InputByteStream& is_;
+    Ch current_;
+};
+
+//! Specialized for UTF8 MemoryStream.
+template <>
+class EncodedInputStream<UTF8<>, MemoryStream> {
+public:
+    typedef UTF8<>::Ch Ch;
+
+    EncodedInputStream(MemoryStream& is) : is_(is) {
+        if (static_cast<unsigned char>(is_.Peek()) == 0xEFu) is_.Take();
+        if (static_cast<unsigned char>(is_.Peek()) == 0xBBu) is_.Take();
+        if (static_cast<unsigned char>(is_.Peek()) == 0xBFu) is_.Take();
+    }
+    Ch Peek() const { return is_.Peek(); }
+    Ch Take() { return is_.Take(); }
+    size_t Tell() const { return is_.Tell(); }
+
+    // Not implemented
+    void Put(Ch) {}
+    void Flush() {} 
+    Ch* PutBegin() { return 0; }
+    size_t PutEnd(Ch*) { return 0; }
+
+    MemoryStream& is_;
+
+private:
+    EncodedInputStream(const EncodedInputStream&);
+    EncodedInputStream& operator=(const EncodedInputStream&);
+};
+
+//! Output byte stream wrapper with statically bound encoding.
+/*!
+    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
+    \tparam OutputByteStream Type of input byte stream. For example, FileWriteStream.
+*/
+template <typename Encoding, typename OutputByteStream>
+class EncodedOutputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+public:
+    typedef typename Encoding::Ch Ch;
+
+    EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) { 
+        if (putBOM)
+            Encoding::PutBOM(os_);
+    }
+
+    void Put(Ch c) { Encoding::Put(os_, c);  }
+    void Flush() { os_.Flush(); }
+
+    // Not implemented
+    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
+    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
+    size_t Tell() const { RAPIDJSON_ASSERT(false);  return 0; }
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    EncodedOutputStream(const EncodedOutputStream&);
+    EncodedOutputStream& operator=(const EncodedOutputStream&);
+
+    OutputByteStream& os_;
+};
+
+#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
+
+//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
+/*!
+    \tparam CharType Type of character for reading.
+    \tparam InputByteStream type of input byte stream to be wrapped.
+*/
+template <typename CharType, typename InputByteStream>
+class AutoUTFInputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+public:
+    typedef CharType Ch;
+
+    //! Constructor.
+    /*!
+        \param is input stream to be wrapped.
+        \param type UTF encoding type if it is not detected from the stream.
+    */
+    AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);        
+        DetectType();
+        static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
+        takeFunc_ = f[type_];
+        current_ = takeFunc_(*is_);
+    }
+
+    UTFType GetType() const { return type_; }
+    bool HasBOM() const { return hasBOM_; }
+
+    Ch Peek() const { return current_; }
+    Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
+    size_t Tell() const { return is_->Tell(); }
+
+    // Not implemented
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); } 
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    AutoUTFInputStream(const AutoUTFInputStream&);
+    AutoUTFInputStream& operator=(const AutoUTFInputStream&);
+
+    // Detect encoding type with BOM or RFC 4627
+    void DetectType() {
+        // BOM (Byte Order Mark):
+        // 00 00 FE FF  UTF-32BE
+        // FF FE 00 00  UTF-32LE
+        // FE FF        UTF-16BE
+        // FF FE        UTF-16LE
+        // EF BB BF     UTF-8
+
+        const unsigned char* c = reinterpret_cast<const unsigned char *>(is_->Peek4());
+        if (!c)
+            return;
+
+        unsigned bom = static_cast<unsigned>(c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24));
+        hasBOM_ = false;
+        if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
+        else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
+        else if ((bom & 0xFFFF) == 0xFFFE)      { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take();                           }
+        else if ((bom & 0xFFFF) == 0xFEFF)      { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take();                           }
+        else if ((bom & 0xFFFFFF) == 0xBFBBEF)  { type_ = kUTF8;    hasBOM_ = true; is_->Take(); is_->Take(); is_->Take();              }
+
+        // RFC 4627: Section 3
+        // "Since the first two characters of a JSON text will always be ASCII
+        // characters [RFC0020], it is possible to determine whether an octet
+        // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
+        // at the pattern of nulls in the first four octets."
+        // 00 00 00 xx  UTF-32BE
+        // 00 xx 00 xx  UTF-16BE
+        // xx 00 00 00  UTF-32LE
+        // xx 00 xx 00  UTF-16LE
+        // xx xx xx xx  UTF-8
+
+        if (!hasBOM_) {
+            unsigned pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
+            switch (pattern) {
+            case 0x08: type_ = kUTF32BE; break;
+            case 0x0A: type_ = kUTF16BE; break;
+            case 0x01: type_ = kUTF32LE; break;
+            case 0x05: type_ = kUTF16LE; break;
+            case 0x0F: type_ = kUTF8;    break;
+            default: break; // Use type defined by user.
+            }
+        }
+
+        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
+    }
+
+    typedef Ch (*TakeFunc)(InputByteStream& is);
+    InputByteStream* is_;
+    UTFType type_;
+    Ch current_;
+    TakeFunc takeFunc_;
+    bool hasBOM_;
+};
+
+//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
+/*!
+    \tparam CharType Type of character for writing.
+    \tparam OutputByteStream type of output byte stream to be wrapped.
+*/
+template <typename CharType, typename OutputByteStream>
+class AutoUTFOutputStream {
+    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+public:
+    typedef CharType Ch;
+
+    //! Constructor.
+    /*!
+        \param os output stream to be wrapped.
+        \param type UTF encoding type.
+        \param putBOM Whether to write BOM at the beginning of the stream.
+    */
+    AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
+        RAPIDJSON_ASSERT(type >= kUTF8 && type <= kUTF32BE);
+
+        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
+        if (type_ == kUTF16LE || type_ == kUTF16BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
+        if (type_ == kUTF32LE || type_ == kUTF32BE) RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
+
+        static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
+        putFunc_ = f[type_];
+
+        if (putBOM)
+            PutBOM();
+    }
+
+    UTFType GetType() const { return type_; }
+
+    void Put(Ch c) { putFunc_(*os_, c); }
+    void Flush() { os_->Flush(); } 
+
+    // Not implemented
+    Ch Peek() const { RAPIDJSON_ASSERT(false); return 0;}
+    Ch Take() { RAPIDJSON_ASSERT(false); return 0;}
+    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    AutoUTFOutputStream(const AutoUTFOutputStream&);
+    AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
+
+    void PutBOM() { 
+        typedef void (*PutBOMFunc)(OutputByteStream&);
+        static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
+        f[type_](*os_);
+    }
+
+    typedef void (*PutFunc)(OutputByteStream&, Ch);
+
+    OutputByteStream* os_;
+    UTFType type_;
+    PutFunc putFunc_;
+};
+
+#undef RAPIDJSON_ENCODINGS_FUNC
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_

slsSupportLib/include/rapidjson/encodings.h

@@ -0,0 +1,716 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ENCODINGS_H_
+#define RAPIDJSON_ENCODINGS_H_
+
+#include "rapidjson.h"
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
+RAPIDJSON_DIAG_OFF(4702)  // unreachable code
+#elif defined(__GNUC__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+RAPIDJSON_DIAG_OFF(overflow)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// Encoding
+
+/*! \class rapidjson::Encoding
+    \brief Concept for encoding of Unicode characters.
+
+\code
+concept Encoding {
+    typename Ch;    //! Type of character. A "character" is actually a code unit in unicode's definition.
+
+    enum { supportUnicode = 1 }; // or 0 if not supporting unicode
+
+    //! \brief Encode a Unicode codepoint to an output stream.
+    //! \param os Output stream.
+    //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively.
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint);
+
+    //! \brief Decode a Unicode codepoint from an input stream.
+    //! \param is Input stream.
+    //! \param codepoint Output of the unicode codepoint.
+    //! \return true if a valid codepoint can be decoded from the stream.
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint);
+
+    //! \brief Validate one Unicode codepoint from an encoded stream.
+    //! \param is Input stream to obtain codepoint.
+    //! \param os Output for copying one codepoint.
+    //! \return true if it is valid.
+    //! \note This function just validating and copying the codepoint without actually decode it.
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os);
+
+    // The following functions are deal with byte streams.
+
+    //! Take a character from input byte stream, skip BOM if exist.
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is);
+
+    //! Take a character from input byte stream.
+    template <typename InputByteStream>
+    static Ch Take(InputByteStream& is);
+
+    //! Put BOM to output byte stream.
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os);
+
+    //! Put a character to output byte stream.
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, Ch c);
+};
+\endcode
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF8
+
+//! UTF-8 encoding.
+/*! http://en.wikipedia.org/wiki/UTF-8
+    http://tools.ietf.org/html/rfc3629
+    \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char.
+    \note implements Encoding concept
+*/
+template<typename CharType = char>
+struct UTF8 {
+    typedef CharType Ch;
+
+    enum { supportUnicode = 1 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        if (codepoint <= 0x7F) 
+            os.Put(static_cast<Ch>(codepoint & 0xFF));
+        else if (codepoint <= 0x7FF) {
+            os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
+        }
+        else if (codepoint <= 0xFFFF) {
+            os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
+            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+    }
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        if (codepoint <= 0x7F) 
+            PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
+        else if (codepoint <= 0x7FF) {
+            PutUnsafe(os, static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
+        }
+        else if (codepoint <= 0xFFFF) {
+            PutUnsafe(os, static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            PutUnsafe(os, static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
+            PutUnsafe(os, static_cast<Ch>(0x80 | (codepoint & 0x3F)));
+        }
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | (static_cast<unsigned char>(c) & 0x3Fu)
+#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define TAIL() COPY(); TRANS(0x70)
+        typename InputStream::Ch c = is.Take();
+        if (!(c & 0x80)) {
+            *codepoint = static_cast<unsigned char>(c);
+            return true;
+        }
+
+        unsigned char type = GetRange(static_cast<unsigned char>(c));
+        if (type >= 32) {
+            *codepoint = 0;
+        } else {
+            *codepoint = (0xFF >> type) & static_cast<unsigned char>(c);
+        }
+        bool result = true;
+        switch (type) {
+        case 2: TAIL(); return result;
+        case 3: TAIL(); TAIL(); return result;
+        case 4: COPY(); TRANS(0x50); TAIL(); return result;
+        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
+        case 6: TAIL(); TAIL(); TAIL(); return result;
+        case 10: COPY(); TRANS(0x20); TAIL(); return result;
+        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+        default: return false;
+        }
+#undef COPY
+#undef TRANS
+#undef TAIL
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+#define COPY() os.Put(c = is.Take())
+#define TRANS(mask) result &= ((GetRange(static_cast<unsigned char>(c)) & mask) != 0)
+#define TAIL() COPY(); TRANS(0x70)
+        Ch c;
+        COPY();
+        if (!(c & 0x80))
+            return true;
+
+        bool result = true;
+        switch (GetRange(static_cast<unsigned char>(c))) {
+        case 2: TAIL(); return result;
+        case 3: TAIL(); TAIL(); return result;
+        case 4: COPY(); TRANS(0x50); TAIL(); return result;
+        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
+        case 6: TAIL(); TAIL(); TAIL(); return result;
+        case 10: COPY(); TRANS(0x20); TAIL(); return result;
+        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
+        default: return false;
+        }
+#undef COPY
+#undef TRANS
+#undef TAIL
+    }
+
+    static unsigned char GetRange(unsigned char c) {
+        // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+        // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types.
+        static const unsigned char type[] = {
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+            0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+            0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
+            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+            8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+            10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
+        };
+        return type[c];
+    }
+
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        typename InputByteStream::Ch c = Take(is);
+        if (static_cast<unsigned char>(c) != 0xEFu) return c;
+        c = is.Take();
+        if (static_cast<unsigned char>(c) != 0xBBu) return c;
+        c = is.Take();
+        if (static_cast<unsigned char>(c) != 0xBFu) return c;
+        c = is.Take();
+        return c;
+    }
+
+    template <typename InputByteStream>
+    static Ch Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        return static_cast<Ch>(is.Take());
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xEFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xBBu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xBFu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, Ch c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(c));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF16
+
+//! UTF-16 encoding.
+/*! http://en.wikipedia.org/wiki/UTF-16
+    http://tools.ietf.org/html/rfc2781
+    \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead.
+    \note implements Encoding concept
+
+    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
+    For streaming, use UTF16LE and UTF16BE, which handle endianness.
+*/
+template<typename CharType = wchar_t>
+struct UTF16 {
+    typedef CharType Ch;
+    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2);
+
+    enum { supportUnicode = 1 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+        if (codepoint <= 0xFFFF) {
+            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
+            os.Put(static_cast<typename OutputStream::Ch>(codepoint));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            unsigned v = codepoint - 0x10000;
+            os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
+            os.Put((v & 0x3FF) | 0xDC00);
+        }
+    }
+
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+        if (codepoint <= 0xFFFF) {
+            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
+            PutUnsafe(os, static_cast<typename OutputStream::Ch>(codepoint));
+        }
+        else {
+            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+            unsigned v = codepoint - 0x10000;
+            PutUnsafe(os, static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
+            PutUnsafe(os, (v & 0x3FF) | 0xDC00);
+        }
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
+        typename InputStream::Ch c = is.Take();
+        if (c < 0xD800 || c > 0xDFFF) {
+            *codepoint = static_cast<unsigned>(c);
+            return true;
+        }
+        else if (c <= 0xDBFF) {
+            *codepoint = (static_cast<unsigned>(c) & 0x3FF) << 10;
+            c = is.Take();
+            *codepoint |= (static_cast<unsigned>(c) & 0x3FF);
+            *codepoint += 0x10000;
+            return c >= 0xDC00 && c <= 0xDFFF;
+        }
+        return false;
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
+        typename InputStream::Ch c;
+        os.Put(static_cast<typename OutputStream::Ch>(c = is.Take()));
+        if (c < 0xD800 || c > 0xDFFF)
+            return true;
+        else if (c <= 0xDBFF) {
+            os.Put(c = is.Take());
+            return c >= 0xDC00 && c <= 0xDFFF;
+        }
+        return false;
+    }
+};
+
+//! UTF-16 little endian encoding.
+template<typename CharType = wchar_t>
+struct UTF16LE : UTF16<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<uint8_t>(is.Take());
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
+    }
+};
+
+//! UTF-16 big endian encoding.
+template<typename CharType = wchar_t>
+struct UTF16BE : UTF16<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint16_t>(c) == 0xFEFFu ? Take(is) : c;
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        c |= static_cast<uint8_t>(is.Take());
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>((static_cast<unsigned>(c) >> 8) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(static_cast<unsigned>(c) & 0xFFu));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// UTF32
+
+//! UTF-32 encoding. 
+/*! http://en.wikipedia.org/wiki/UTF-32
+    \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead.
+    \note implements Encoding concept
+
+    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
+    For streaming, use UTF32LE and UTF32BE, which handle endianness.
+*/
+template<typename CharType = unsigned>
+struct UTF32 {
+    typedef CharType Ch;
+    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4);
+
+    enum { supportUnicode = 1 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        os.Put(codepoint);
+    }
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
+        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
+        PutUnsafe(os, codepoint);
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
+        Ch c = is.Take();
+        *codepoint = c;
+        return c <= 0x10FFFF;
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
+        Ch c;
+        os.Put(c = is.Take());
+        return c <= 0x10FFFF;
+    }
+};
+
+//! UTF-32 little endian enocoding.
+template<typename CharType = unsigned>
+struct UTF32LE : UTF32<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c;
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<uint8_t>(is.Take());
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
+    }
+};
+
+//! UTF-32 big endian encoding.
+template<typename CharType = unsigned>
+struct UTF32BE : UTF32<CharType> {
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        CharType c = Take(is);
+        return static_cast<uint32_t>(c) == 0x0000FEFFu ? Take(is) : c; 
+    }
+
+    template <typename InputByteStream>
+    static CharType Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        unsigned c = static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 24;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 16;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take())) << 8;
+        c |= static_cast<unsigned>(static_cast<uint8_t>(is.Take()));
+        return static_cast<CharType>(c);
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0x00u));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFEu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(0xFFu));
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, CharType c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 24) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 16) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>((c >> 8) & 0xFFu));
+        os.Put(static_cast<typename OutputByteStream::Ch>(c & 0xFFu));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// ASCII
+
+//! ASCII encoding.
+/*! http://en.wikipedia.org/wiki/ASCII
+    \tparam CharType Code unit for storing 7-bit ASCII data. Default is char.
+    \note implements Encoding concept
+*/
+template<typename CharType = char>
+struct ASCII {
+    typedef CharType Ch;
+
+    enum { supportUnicode = 0 };
+
+    template<typename OutputStream>
+    static void Encode(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_ASSERT(codepoint <= 0x7F);
+        os.Put(static_cast<Ch>(codepoint & 0xFF));
+    }
+
+    template<typename OutputStream>
+    static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        RAPIDJSON_ASSERT(codepoint <= 0x7F);
+        PutUnsafe(os, static_cast<Ch>(codepoint & 0xFF));
+    }
+
+    template <typename InputStream>
+    static bool Decode(InputStream& is, unsigned* codepoint) {
+        uint8_t c = static_cast<uint8_t>(is.Take());
+        *codepoint = c;
+        return c <= 0X7F;
+    }
+
+    template <typename InputStream, typename OutputStream>
+    static bool Validate(InputStream& is, OutputStream& os) {
+        uint8_t c = static_cast<uint8_t>(is.Take());
+        os.Put(static_cast<typename OutputStream::Ch>(c));
+        return c <= 0x7F;
+    }
+
+    template <typename InputByteStream>
+    static CharType TakeBOM(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        uint8_t c = static_cast<uint8_t>(Take(is));
+        return static_cast<Ch>(c);
+    }
+
+    template <typename InputByteStream>
+    static Ch Take(InputByteStream& is) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
+        return static_cast<Ch>(is.Take());
+    }
+
+    template <typename OutputByteStream>
+    static void PutBOM(OutputByteStream& os) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        (void)os;
+    }
+
+    template <typename OutputByteStream>
+    static void Put(OutputByteStream& os, Ch c) {
+        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
+        os.Put(static_cast<typename OutputByteStream::Ch>(c));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// AutoUTF
+
+//! Runtime-specified UTF encoding type of a stream.
+enum UTFType {
+    kUTF8 = 0,      //!< UTF-8.
+    kUTF16LE = 1,   //!< UTF-16 little endian.
+    kUTF16BE = 2,   //!< UTF-16 big endian.
+    kUTF32LE = 3,   //!< UTF-32 little endian.
+    kUTF32BE = 4    //!< UTF-32 big endian.
+};
+
+//! Dynamically select encoding according to stream's runtime-specified UTF encoding type.
+/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType().
+*/
+template<typename CharType>
+struct AutoUTF {
+    typedef CharType Ch;
+
+    enum { supportUnicode = 1 };
+
+#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
+
+    template<typename OutputStream>
+    RAPIDJSON_FORCEINLINE static void Encode(OutputStream& os, unsigned codepoint) {
+        typedef void (*EncodeFunc)(OutputStream&, unsigned);
+        static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) };
+        (*f[os.GetType()])(os, codepoint);
+    }
+
+    template<typename OutputStream>
+    RAPIDJSON_FORCEINLINE static void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
+        typedef void (*EncodeFunc)(OutputStream&, unsigned);
+        static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(EncodeUnsafe) };
+        (*f[os.GetType()])(os, codepoint);
+    }
+
+    template <typename InputStream>
+    RAPIDJSON_FORCEINLINE static bool Decode(InputStream& is, unsigned* codepoint) {
+        typedef bool (*DecodeFunc)(InputStream&, unsigned*);
+        static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) };
+        return (*f[is.GetType()])(is, codepoint);
+    }
+
+    template <typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+        typedef bool (*ValidateFunc)(InputStream&, OutputStream&);
+        static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) };
+        return (*f[is.GetType()])(is, os);
+    }
+
+#undef RAPIDJSON_ENCODINGS_FUNC
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Transcoder
+
+//! Encoding conversion.
+template<typename SourceEncoding, typename TargetEncoding>
+struct Transcoder {
+    //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
+        unsigned codepoint;
+        if (!SourceEncoding::Decode(is, &codepoint))
+            return false;
+        TargetEncoding::Encode(os, codepoint);
+        return true;
+    }
+
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
+        unsigned codepoint;
+        if (!SourceEncoding::Decode(is, &codepoint))
+            return false;
+        TargetEncoding::EncodeUnsafe(os, codepoint);
+        return true;
+    }
+
+    //! Validate one Unicode codepoint from an encoded stream.
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+        return Transcode(is, os);   // Since source/target encoding is different, must transcode.
+    }
+};
+
+// Forward declaration.
+template<typename Stream>
+inline void PutUnsafe(Stream& stream, typename Stream::Ch c);
+
+//! Specialization of Transcoder with same source and target encoding.
+template<typename Encoding>
+struct Transcoder<Encoding, Encoding> {
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
+        os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
+        return true;
+    }
+    
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool TranscodeUnsafe(InputStream& is, OutputStream& os) {
+        PutUnsafe(os, is.Take());  // Just copy one code unit. This semantic is different from primary template class.
+        return true;
+    }
+    
+    template<typename InputStream, typename OutputStream>
+    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
+        return Encoding::Validate(is, os);  // source/target encoding are the same
+    }
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ENCODINGS_H_

slsSupportLib/include/rapidjson/error/en.h

@@ -0,0 +1,74 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ERROR_EN_H_
+#define RAPIDJSON_ERROR_EN_H_
+
+#include "error.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(switch-enum)
+RAPIDJSON_DIAG_OFF(covered-switch-default)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Maps error code of parsing into error message.
+/*!
+    \ingroup RAPIDJSON_ERRORS
+    \param parseErrorCode Error code obtained in parsing.
+    \return the error message.
+    \note User can make a copy of this function for localization.
+        Using switch-case is safer for future modification of error codes.
+*/
+inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) {
+    switch (parseErrorCode) {
+        case kParseErrorNone:                           return RAPIDJSON_ERROR_STRING("No error.");
+
+        case kParseErrorDocumentEmpty:                  return RAPIDJSON_ERROR_STRING("The document is empty.");
+        case kParseErrorDocumentRootNotSingular:        return RAPIDJSON_ERROR_STRING("The document root must not be followed by other values.");
+    
+        case kParseErrorValueInvalid:                   return RAPIDJSON_ERROR_STRING("Invalid value.");
+    
+        case kParseErrorObjectMissName:                 return RAPIDJSON_ERROR_STRING("Missing a name for object member.");
+        case kParseErrorObjectMissColon:                return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
+        case kParseErrorObjectMissCommaOrCurlyBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
+    
+        case kParseErrorArrayMissCommaOrSquareBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
+
+        case kParseErrorStringUnicodeEscapeInvalidHex:  return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
+        case kParseErrorStringUnicodeSurrogateInvalid:  return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
+        case kParseErrorStringEscapeInvalid:            return RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
+        case kParseErrorStringMissQuotationMark:        return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
+        case kParseErrorStringInvalidEncoding:          return RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
+
+        case kParseErrorNumberTooBig:                   return RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
+        case kParseErrorNumberMissFraction:             return RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
+        case kParseErrorNumberMissExponent:             return RAPIDJSON_ERROR_STRING("Miss exponent in number.");
+
+        case kParseErrorTermination:                    return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
+        case kParseErrorUnspecificSyntaxError:          return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
+
+        default:                                        return RAPIDJSON_ERROR_STRING("Unknown error.");
+    }
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ERROR_EN_H_

slsSupportLib/include/rapidjson/error/error.h

@@ -0,0 +1,155 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ERROR_ERROR_H_
+#define RAPIDJSON_ERROR_ERROR_H_
+
+#include "../rapidjson.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+/*! \file error.h */
+
+/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ERROR_CHARTYPE
+
+//! Character type of error messages.
+/*! \ingroup RAPIDJSON_ERRORS
+    The default character type is \c char.
+    On Windows, user can define this macro as \c TCHAR for supporting both
+    unicode/non-unicode settings.
+*/
+#ifndef RAPIDJSON_ERROR_CHARTYPE
+#define RAPIDJSON_ERROR_CHARTYPE char
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ERROR_STRING
+
+//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[].
+/*! \ingroup RAPIDJSON_ERRORS
+    By default this conversion macro does nothing.
+    On Windows, user can define this macro as \c _T(x) for supporting both
+    unicode/non-unicode settings.
+*/
+#ifndef RAPIDJSON_ERROR_STRING
+#define RAPIDJSON_ERROR_STRING(x) x
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// ParseErrorCode
+
+//! Error code of parsing.
+/*! \ingroup RAPIDJSON_ERRORS
+    \see GenericReader::Parse, GenericReader::GetParseErrorCode
+*/
+enum ParseErrorCode {
+    kParseErrorNone = 0,                        //!< No error.
+
+    kParseErrorDocumentEmpty,                   //!< The document is empty.
+    kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.
+
+    kParseErrorValueInvalid,                    //!< Invalid value.
+
+    kParseErrorObjectMissName,                  //!< Missing a name for object member.
+    kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
+    kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.
+
+    kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.
+
+    kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
+    kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
+    kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
+    kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
+    kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.
+
+    kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
+    kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
+    kParseErrorNumberMissExponent,              //!< Miss exponent in number.
+
+    kParseErrorTermination,                     //!< Parsing was terminated.
+    kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
+};
+
+//! Result of parsing (wraps ParseErrorCode)
+/*!
+    \ingroup RAPIDJSON_ERRORS
+    \code
+        Document doc;
+        ParseResult ok = doc.Parse("[42]");
+        if (!ok) {
+            fprintf(stderr, "JSON parse error: %s (%u)",
+                    GetParseError_En(ok.Code()), ok.Offset());
+            exit(EXIT_FAILURE);
+        }
+    \endcode
+    \see GenericReader::Parse, GenericDocument::Parse
+*/
+struct ParseResult {
+public:
+    //! Default constructor, no error.
+    ParseResult() : code_(kParseErrorNone), offset_(0) {}
+    //! Constructor to set an error.
+    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
+
+    //! Get the error code.
+    ParseErrorCode Code() const { return code_; }
+    //! Get the error offset, if \ref IsError(), 0 otherwise.
+    size_t Offset() const { return offset_; }
+
+    //! Conversion to \c bool, returns \c true, iff !\ref IsError().
+    operator bool() const { return !IsError(); }
+    //! Whether the result is an error.
+    bool IsError() const { return code_ != kParseErrorNone; }
+
+    bool operator==(const ParseResult& that) const { return code_ == that.code_; }
+    bool operator==(ParseErrorCode code) const { return code_ == code; }
+    friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }
+
+    //! Reset error code.
+    void Clear() { Set(kParseErrorNone); }
+    //! Update error code and offset.
+    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }
+
+private:
+    ParseErrorCode code_;
+    size_t offset_;
+};
+
+//! Function pointer type of GetParseError().
+/*! \ingroup RAPIDJSON_ERRORS
+
+    This is the prototype for \c GetParseError_X(), where \c X is a locale.
+    User can dynamically change locale in runtime, e.g.:
+\code
+    GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
+    const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
+\endcode
+*/
+typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_ERROR_ERROR_H_

slsSupportLib/include/rapidjson/filereadstream.h

@@ -0,0 +1,99 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FILEREADSTREAM_H_
+#define RAPIDJSON_FILEREADSTREAM_H_
+
+#include "stream.h"
+#include <cstdio>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(missing-noreturn)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! File byte stream for input using fread().
+/*!
+    \note implements Stream concept
+*/
+class FileReadStream {
+public:
+    typedef char Ch;    //!< Character type (byte).
+
+    //! Constructor.
+    /*!
+        \param fp File pointer opened for read.
+        \param buffer user-supplied buffer.
+        \param bufferSize size of buffer in bytes. Must >=4 bytes.
+    */
+    FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
+        RAPIDJSON_ASSERT(fp_ != 0);
+        RAPIDJSON_ASSERT(bufferSize >= 4);
+        Read();
+    }
+
+    Ch Peek() const { return *current_; }
+    Ch Take() { Ch c = *current_; Read(); return c; }
+    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
+
+    // Not implemented
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); } 
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    // For encoding detection only.
+    const Ch* Peek4() const {
+        return (current_ + 4 <= bufferLast_) ? current_ : 0;
+    }
+
+private:
+    void Read() {
+        if (current_ < bufferLast_)
+            ++current_;
+        else if (!eof_) {
+            count_ += readCount_;
+            readCount_ = fread(buffer_, 1, bufferSize_, fp_);
+            bufferLast_ = buffer_ + readCount_ - 1;
+            current_ = buffer_;
+
+            if (readCount_ < bufferSize_) {
+                buffer_[readCount_] = '\0';
+                ++bufferLast_;
+                eof_ = true;
+            }
+        }
+    }
+
+    std::FILE* fp_;
+    Ch *buffer_;
+    size_t bufferSize_;
+    Ch *bufferLast_;
+    Ch *current_;
+    size_t readCount_;
+    size_t count_;  //!< Number of characters read
+    bool eof_;
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_

slsSupportLib/include/rapidjson/filewritestream.h

@@ -0,0 +1,104 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FILEWRITESTREAM_H_
+#define RAPIDJSON_FILEWRITESTREAM_H_
+
+#include "stream.h"
+#include <cstdio>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of C file stream for input using fread().
+/*!
+    \note implements Stream concept
+*/
+class FileWriteStream {
+public:
+    typedef char Ch;    //!< Character type. Only support char.
+
+    FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 
+        RAPIDJSON_ASSERT(fp_ != 0);
+    }
+
+    void Put(char c) { 
+        if (current_ >= bufferEnd_)
+            Flush();
+
+        *current_++ = c;
+    }
+
+    void PutN(char c, size_t n) {
+        size_t avail = static_cast<size_t>(bufferEnd_ - current_);
+        while (n > avail) {
+            std::memset(current_, c, avail);
+            current_ += avail;
+            Flush();
+            n -= avail;
+            avail = static_cast<size_t>(bufferEnd_ - current_);
+        }
+
+        if (n > 0) {
+            std::memset(current_, c, n);
+            current_ += n;
+        }
+    }
+
+    void Flush() {
+        if (current_ != buffer_) {
+            size_t result = fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
+            if (result < static_cast<size_t>(current_ - buffer_)) {
+                // failure deliberately ignored at this time
+                // added to avoid warn_unused_result build errors
+            }
+            current_ = buffer_;
+        }
+    }
+
+    // Not implemented
+    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
+    char Take() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
+    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    FileWriteStream(const FileWriteStream&);
+    FileWriteStream& operator=(const FileWriteStream&);
+
+    std::FILE* fp_;
+    char *buffer_;
+    char *bufferEnd_;
+    char *current_;
+};
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(FileWriteStream& stream, char c, size_t n) {
+    stream.PutN(c, n);
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_FILESTREAM_H_

slsSupportLib/include/rapidjson/fwd.h

@@ -0,0 +1,151 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_FWD_H_
+#define RAPIDJSON_FWD_H_
+
+#include "rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+// encodings.h
+
+template<typename CharType> struct UTF8;
+template<typename CharType> struct UTF16;
+template<typename CharType> struct UTF16BE;
+template<typename CharType> struct UTF16LE;
+template<typename CharType> struct UTF32;
+template<typename CharType> struct UTF32BE;
+template<typename CharType> struct UTF32LE;
+template<typename CharType> struct ASCII;
+template<typename CharType> struct AutoUTF;
+
+template<typename SourceEncoding, typename TargetEncoding>
+struct Transcoder;
+
+// allocators.h
+
+class CrtAllocator;
+
+template <typename BaseAllocator>
+class MemoryPoolAllocator;
+
+// stream.h
+
+template <typename Encoding>
+struct GenericStringStream;
+
+typedef GenericStringStream<UTF8<char> > StringStream;
+
+template <typename Encoding>
+struct GenericInsituStringStream;
+
+typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
+
+// stringbuffer.h
+
+template <typename Encoding, typename Allocator>
+class GenericStringBuffer;
+
+typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
+
+// filereadstream.h
+
+class FileReadStream;
+
+// filewritestream.h
+
+class FileWriteStream;
+
+// memorybuffer.h
+
+template <typename Allocator>
+struct GenericMemoryBuffer;
+
+typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
+
+// memorystream.h
+
+struct MemoryStream;
+
+// reader.h
+
+template<typename Encoding, typename Derived>
+struct BaseReaderHandler;
+
+template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator>
+class GenericReader;
+
+typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
+
+// writer.h
+
+template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
+class Writer;
+
+// prettywriter.h
+
+template<typename OutputStream, typename SourceEncoding, typename TargetEncoding, typename StackAllocator, unsigned writeFlags>
+class PrettyWriter;
+
+// document.h
+
+template <typename Encoding, typename Allocator> 
+struct GenericMember;
+
+template <bool Const, typename Encoding, typename Allocator>
+class GenericMemberIterator;
+
+template<typename CharType>
+struct GenericStringRef;
+
+template <typename Encoding, typename Allocator> 
+class GenericValue;
+
+typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
+
+template <typename Encoding, typename Allocator, typename StackAllocator>
+class GenericDocument;
+
+typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, CrtAllocator> Document;
+
+// pointer.h
+
+template <typename ValueType, typename Allocator>
+class GenericPointer;
+
+typedef GenericPointer<Value, CrtAllocator> Pointer;
+
+// schema.h
+
+template <typename SchemaDocumentType>
+class IGenericRemoteSchemaDocumentProvider;
+
+template <typename ValueT, typename Allocator>
+class GenericSchemaDocument;
+
+typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
+typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSchemaDocumentProvider;
+
+template <
+    typename SchemaDocumentType,
+    typename OutputHandler,
+    typename StateAllocator>
+class GenericSchemaValidator;
+
+typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<char>, void>, CrtAllocator> SchemaValidator;
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_RAPIDJSONFWD_H_

slsSupportLib/include/rapidjson/internal/biginteger.h

@@ -0,0 +1,290 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_BIGINTEGER_H_
+#define RAPIDJSON_BIGINTEGER_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && defined(_M_AMD64)
+#include <intrin.h> // for _umul128
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+class BigInteger {
+public:
+    typedef uint64_t Type;
+
+    BigInteger(const BigInteger& rhs) : count_(rhs.count_) {
+        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+    }
+
+    explicit BigInteger(uint64_t u) : count_(1) {
+        digits_[0] = u;
+    }
+
+    BigInteger(const char* decimals, size_t length) : count_(1) {
+        RAPIDJSON_ASSERT(length > 0);
+        digits_[0] = 0;
+        size_t i = 0;
+        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
+        while (length >= kMaxDigitPerIteration) {
+            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
+            length -= kMaxDigitPerIteration;
+            i += kMaxDigitPerIteration;
+        }
+
+        if (length > 0)
+            AppendDecimal64(decimals + i, decimals + i + length);
+    }
+    
+    BigInteger& operator=(const BigInteger &rhs)
+    {
+        if (this != &rhs) {
+            count_ = rhs.count_;
+            std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
+        }
+        return *this;
+    }
+    
+    BigInteger& operator=(uint64_t u) {
+        digits_[0] = u;            
+        count_ = 1;
+        return *this;
+    }
+
+    BigInteger& operator+=(uint64_t u) {
+        Type backup = digits_[0];
+        digits_[0] += u;
+        for (size_t i = 0; i < count_ - 1; i++) {
+            if (digits_[i] >= backup)
+                return *this; // no carry
+            backup = digits_[i + 1];
+            digits_[i + 1] += 1;
+        }
+
+        // Last carry
+        if (digits_[count_ - 1] < backup)
+            PushBack(1);
+
+        return *this;
+    }
+
+    BigInteger& operator*=(uint64_t u) {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++) {
+            uint64_t hi;
+            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
+            k = hi;
+        }
+        
+        if (k > 0)
+            PushBack(k);
+
+        return *this;
+    }
+
+    BigInteger& operator*=(uint32_t u) {
+        if (u == 0) return *this = 0;
+        if (u == 1) return *this;
+        if (*this == 1) return *this = u;
+
+        uint64_t k = 0;
+        for (size_t i = 0; i < count_; i++) {
+            const uint64_t c = digits_[i] >> 32;
+            const uint64_t d = digits_[i] & 0xFFFFFFFF;
+            const uint64_t uc = u * c;
+            const uint64_t ud = u * d;
+            const uint64_t p0 = ud + k;
+            const uint64_t p1 = uc + (p0 >> 32);
+            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
+            k = p1 >> 32;
+        }
+        
+        if (k > 0)
+            PushBack(k);
+
+        return *this;
+    }
+
+    BigInteger& operator<<=(size_t shift) {
+        if (IsZero() || shift == 0) return *this;
+
+        size_t offset = shift / kTypeBit;
+        size_t interShift = shift % kTypeBit;
+        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
+
+        if (interShift == 0) {
+            std::memmove(&digits_[count_ - 1 + offset], &digits_[count_ - 1], count_ * sizeof(Type));
+            count_ += offset;
+        }
+        else {
+            digits_[count_] = 0;
+            for (size_t i = count_; i > 0; i--)
+                digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
+            digits_[offset] = digits_[0] << interShift;
+            count_ += offset;
+            if (digits_[count_])
+                count_++;
+        }
+
+        std::memset(digits_, 0, offset * sizeof(Type));
+
+        return *this;
+    }
+
+    bool operator==(const BigInteger& rhs) const {
+        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
+    }
+
+    bool operator==(const Type rhs) const {
+        return count_ == 1 && digits_[0] == rhs;
+    }
+
+    BigInteger& MultiplyPow5(unsigned exp) {
+        static const uint32_t kPow5[12] = {
+            5,
+            5 * 5,
+            5 * 5 * 5,
+            5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
+        };
+        if (exp == 0) return *this;
+        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
+        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
+        if (exp > 0)                 *this *= kPow5[exp - 1];
+        return *this;
+    }
+
+    // Compute absolute difference of this and rhs.
+    // Assume this != rhs
+    bool Difference(const BigInteger& rhs, BigInteger* out) const {
+        int cmp = Compare(rhs);
+        RAPIDJSON_ASSERT(cmp != 0);
+        const BigInteger *a, *b;  // Makes a > b
+        bool ret;
+        if (cmp < 0) { a = &rhs; b = this; ret = true; }
+        else         { a = this; b = &rhs; ret = false; }
+
+        Type borrow = 0;
+        for (size_t i = 0; i < a->count_; i++) {
+            Type d = a->digits_[i] - borrow;
+            if (i < b->count_)
+                d -= b->digits_[i];
+            borrow = (d > a->digits_[i]) ? 1 : 0;
+            out->digits_[i] = d;
+            if (d != 0)
+                out->count_ = i + 1;
+        }
+
+        return ret;
+    }
+
+    int Compare(const BigInteger& rhs) const {
+        if (count_ != rhs.count_)
+            return count_ < rhs.count_ ? -1 : 1;
+
+        for (size_t i = count_; i-- > 0;)
+            if (digits_[i] != rhs.digits_[i])
+                return digits_[i] < rhs.digits_[i] ? -1 : 1;
+
+        return 0;
+    }
+
+    size_t GetCount() const { return count_; }
+    Type GetDigit(size_t index) const { RAPIDJSON_ASSERT(index < count_); return digits_[index]; }
+    bool IsZero() const { return count_ == 1 && digits_[0] == 0; }
+
+private:
+    void AppendDecimal64(const char* begin, const char* end) {
+        uint64_t u = ParseUint64(begin, end);
+        if (IsZero())
+            *this = u;
+        else {
+            unsigned exp = static_cast<unsigned>(end - begin);
+            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
+        }
+    }
+
+    void PushBack(Type digit) {
+        RAPIDJSON_ASSERT(count_ < kCapacity);
+        digits_[count_++] = digit;
+    }
+
+    static uint64_t ParseUint64(const char* begin, const char* end) {
+        uint64_t r = 0;
+        for (const char* p = begin; p != end; ++p) {
+            RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
+            r = r * 10u + static_cast<unsigned>(*p - '0');
+        }
+        return r;
+    }
+
+    // Assume a * b + k < 2^128
+    static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t low = _umul128(a, b, outHigh) + k;
+        if (low < k)
+            (*outHigh)++;
+        return low;
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(a) * static_cast<uint128>(b);
+        p += k;
+        *outHigh = static_cast<uint64_t>(p >> 64);
+        return static_cast<uint64_t>(p);
+#else
+        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
+        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
+        x1 += (x0 >> 32); // can't give carry
+        x1 += x2;
+        if (x1 < x2)
+            x3 += (static_cast<uint64_t>(1) << 32);
+        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
+        uint64_t hi = x3 + (x1 >> 32);
+
+        lo += k;
+        if (lo < k)
+            hi++;
+        *outHigh = hi;
+        return lo;
+#endif
+    }
+
+    static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
+    static const size_t kCapacity = kBitCount / sizeof(Type);
+    static const size_t kTypeBit = sizeof(Type) * 8;
+
+    Type digits_[kCapacity];
+    size_t count_;
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_BIGINTEGER_H_

slsSupportLib/include/rapidjson/internal/diyfp.h

@@ -0,0 +1,258 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
+// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
+// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
+
+#ifndef RAPIDJSON_DIYFP_H_
+#define RAPIDJSON_DIYFP_H_
+
+#include "../rapidjson.h"
+
+#if defined(_MSC_VER) && defined(_M_AMD64)
+#include <intrin.h>
+#pragma intrinsic(_BitScanReverse64)
+#pragma intrinsic(_umul128)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+struct DiyFp {
+    DiyFp() : f(), e() {}
+
+    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
+
+    explicit DiyFp(double d) {
+        union {
+            double d;
+            uint64_t u64;
+        } u = { d };
+
+        int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
+        uint64_t significand = (u.u64 & kDpSignificandMask);
+        if (biased_e != 0) {
+            f = significand + kDpHiddenBit;
+            e = biased_e - kDpExponentBias;
+        } 
+        else {
+            f = significand;
+            e = kDpMinExponent + 1;
+        }
+    }
+
+    DiyFp operator-(const DiyFp& rhs) const {
+        return DiyFp(f - rhs.f, e);
+    }
+
+    DiyFp operator*(const DiyFp& rhs) const {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        uint64_t h;
+        uint64_t l = _umul128(f, rhs.f, &h);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
+        __extension__ typedef unsigned __int128 uint128;
+        uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
+        uint64_t h = static_cast<uint64_t>(p >> 64);
+        uint64_t l = static_cast<uint64_t>(p);
+        if (l & (uint64_t(1) << 63)) // rounding
+            h++;
+        return DiyFp(h, e + rhs.e + 64);
+#else
+        const uint64_t M32 = 0xFFFFFFFF;
+        const uint64_t a = f >> 32;
+        const uint64_t b = f & M32;
+        const uint64_t c = rhs.f >> 32;
+        const uint64_t d = rhs.f & M32;
+        const uint64_t ac = a * c;
+        const uint64_t bc = b * c;
+        const uint64_t ad = a * d;
+        const uint64_t bd = b * d;
+        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
+        tmp += 1U << 31;  /// mult_round
+        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
+#endif
+    }
+
+    DiyFp Normalize() const {
+#if defined(_MSC_VER) && defined(_M_AMD64)
+        unsigned long index;
+        _BitScanReverse64(&index, f);
+        return DiyFp(f << (63 - index), e - (63 - index));
+#elif defined(__GNUC__) && __GNUC__ >= 4
+        int s = __builtin_clzll(f);
+        return DiyFp(f << s, e - s);
+#else
+        DiyFp res = *this;
+        while (!(res.f & (static_cast<uint64_t>(1) << 63))) {
+            res.f <<= 1;
+            res.e--;
+        }
+        return res;
+#endif
+    }
+
+    DiyFp NormalizeBoundary() const {
+        DiyFp res = *this;
+        while (!(res.f & (kDpHiddenBit << 1))) {
+            res.f <<= 1;
+            res.e--;
+        }
+        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
+        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
+        return res;
+    }
+
+    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
+        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
+        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
+        mi.f <<= mi.e - pl.e;
+        mi.e = pl.e;
+        *plus = pl;
+        *minus = mi;
+    }
+
+    double ToDouble() const {
+        union {
+            double d;
+            uint64_t u64;
+        }u;
+        const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : 
+            static_cast<uint64_t>(e + kDpExponentBias);
+        u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
+        return u.d;
+    }
+
+    static const int kDiySignificandSize = 64;
+    static const int kDpSignificandSize = 52;
+    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
+    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
+    static const int kDpMinExponent = -kDpExponentBias;
+    static const int kDpDenormalExponent = -kDpExponentBias + 1;
+    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    uint64_t f;
+    int e;
+};
+
+inline DiyFp GetCachedPowerByIndex(size_t index) {
+    // 10^-348, 10^-340, ..., 10^340
+    static const uint64_t kCachedPowers_F[] = {
+        RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
+        RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
+        RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
+        RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
+        RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
+        RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
+        RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
+        RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
+        RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
+        RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
+        RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
+        RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
+        RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
+        RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
+        RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
+        RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
+        RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
+        RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
+        RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
+        RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
+        RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
+        RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
+        RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
+        RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
+        RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
+        RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
+        RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
+        RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
+        RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
+        RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
+        RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
+        RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
+        RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
+        RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
+        RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
+        RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
+        RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
+        RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
+        RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
+        RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
+        RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
+        RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
+        RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
+        RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
+    };
+    static const int16_t kCachedPowers_E[] = {
+        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
+        -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
+        -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
+        -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
+        -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
+        109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
+        375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
+        641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
+        907,   933,   960,   986,  1013,  1039,  1066
+    };
+    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
+}
+    
+inline DiyFp GetCachedPower(int e, int* K) {
+
+    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
+    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
+    int k = static_cast<int>(dk);
+    if (dk - k > 0.0)
+        k++;
+
+    unsigned index = static_cast<unsigned>((k >> 3) + 1);
+    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
+
+    return GetCachedPowerByIndex(index);
+}
+
+inline DiyFp GetCachedPower10(int exp, int *outExp) {
+     unsigned index = (static_cast<unsigned>(exp) + 348u) / 8u;
+     *outExp = -348 + static_cast<int>(index) * 8;
+     return GetCachedPowerByIndex(index);
+ }
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_DIYFP_H_

slsSupportLib/include/rapidjson/internal/dtoa.h

@@ -0,0 +1,245 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
+// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
+// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
+
+#ifndef RAPIDJSON_DTOA_
+#define RAPIDJSON_DTOA_
+
+#include "itoa.h" // GetDigitsLut()
+#include "diyfp.h"
+#include "ieee754.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+RAPIDJSON_DIAG_OFF(array-bounds) // some gcc versions generate wrong warnings https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124
+#endif
+
+inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
+    while (rest < wp_w && delta - rest >= ten_kappa &&
+           (rest + ten_kappa < wp_w ||  /// closer
+            wp_w - rest > rest + ten_kappa - wp_w)) {
+        buffer[len - 1]--;
+        rest += ten_kappa;
+    }
+}
+
+inline unsigned CountDecimalDigit32(uint32_t n) {
+    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
+    if (n < 10) return 1;
+    if (n < 100) return 2;
+    if (n < 1000) return 3;
+    if (n < 10000) return 4;
+    if (n < 100000) return 5;
+    if (n < 1000000) return 6;
+    if (n < 10000000) return 7;
+    if (n < 100000000) return 8;
+    // Will not reach 10 digits in DigitGen()
+    //if (n < 1000000000) return 9;
+    //return 10;
+    return 9;
+}
+
+inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
+    static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
+    const DiyFp wp_w = Mp - W;
+    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
+    uint64_t p2 = Mp.f & (one.f - 1);
+    unsigned kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
+    *len = 0;
+
+    while (kappa > 0) {
+        uint32_t d = 0;
+        switch (kappa) {
+            case  9: d = p1 /  100000000; p1 %=  100000000; break;
+            case  8: d = p1 /   10000000; p1 %=   10000000; break;
+            case  7: d = p1 /    1000000; p1 %=    1000000; break;
+            case  6: d = p1 /     100000; p1 %=     100000; break;
+            case  5: d = p1 /      10000; p1 %=      10000; break;
+            case  4: d = p1 /       1000; p1 %=       1000; break;
+            case  3: d = p1 /        100; p1 %=        100; break;
+            case  2: d = p1 /         10; p1 %=         10; break;
+            case  1: d = p1;              p1 =           0; break;
+            default:;
+        }
+        if (d || *len)
+            buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
+        kappa--;
+        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
+        if (tmp <= delta) {
+            *K += kappa;
+            GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
+            return;
+        }
+    }
+
+    // kappa = 0
+    for (;;) {
+        p2 *= 10;
+        delta *= 10;
+        char d = static_cast<char>(p2 >> -one.e);
+        if (d || *len)
+            buffer[(*len)++] = static_cast<char>('0' + d);
+        p2 &= one.f - 1;
+        kappa--;
+        if (p2 < delta) {
+            *K += kappa;
+            int index = -static_cast<int>(kappa);
+            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * (index < 9 ? kPow10[-static_cast<int>(kappa)] : 0));
+            return;
+        }
+    }
+}
+
+inline void Grisu2(double value, char* buffer, int* length, int* K) {
+    const DiyFp v(value);
+    DiyFp w_m, w_p;
+    v.NormalizedBoundaries(&w_m, &w_p);
+
+    const DiyFp c_mk = GetCachedPower(w_p.e, K);
+    const DiyFp W = v.Normalize() * c_mk;
+    DiyFp Wp = w_p * c_mk;
+    DiyFp Wm = w_m * c_mk;
+    Wm.f++;
+    Wp.f--;
+    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
+}
+
+inline char* WriteExponent(int K, char* buffer) {
+    if (K < 0) {
+        *buffer++ = '-';
+        K = -K;
+    }
+
+    if (K >= 100) {
+        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
+        K %= 100;
+        const char* d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+    }
+    else if (K >= 10) {
+        const char* d = GetDigitsLut() + K * 2;
+        *buffer++ = d[0];
+        *buffer++ = d[1];
+    }
+    else
+        *buffer++ = static_cast<char>('0' + static_cast<char>(K));
+
+    return buffer;
+}
+
+inline char* Prettify(char* buffer, int length, int k, int maxDecimalPlaces) {
+    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
+
+    if (0 <= k && kk <= 21) {
+        // 1234e7 -> 12340000000
+        for (int i = length; i < kk; i++)
+            buffer[i] = '0';
+        buffer[kk] = '.';
+        buffer[kk + 1] = '0';
+        return &buffer[kk + 2];
+    }
+    else if (0 < kk && kk <= 21) {
+        // 1234e-2 -> 12.34
+        std::memmove(&buffer[kk + 1], &buffer[kk], static_cast<size_t>(length - kk));
+        buffer[kk] = '.';
+        if (0 > k + maxDecimalPlaces) {
+            // When maxDecimalPlaces = 2, 1.2345 -> 1.23, 1.102 -> 1.1
+            // Remove extra trailing zeros (at least one) after truncation.
+            for (int i = kk + maxDecimalPlaces; i > kk + 1; i--)
+                if (buffer[i] != '0')
+                    return &buffer[i + 1];
+            return &buffer[kk + 2]; // Reserve one zero
+        }
+        else
+            return &buffer[length + 1];
+    }
+    else if (-6 < kk && kk <= 0) {
+        // 1234e-6 -> 0.001234
+        const int offset = 2 - kk;
+        std::memmove(&buffer[offset], &buffer[0], static_cast<size_t>(length));
+        buffer[0] = '0';
+        buffer[1] = '.';
+        for (int i = 2; i < offset; i++)
+            buffer[i] = '0';
+        if (length - kk > maxDecimalPlaces) {
+            // When maxDecimalPlaces = 2, 0.123 -> 0.12, 0.102 -> 0.1
+            // Remove extra trailing zeros (at least one) after truncation.
+            for (int i = maxDecimalPlaces + 1; i > 2; i--)
+                if (buffer[i] != '0')
+                    return &buffer[i + 1];
+            return &buffer[3]; // Reserve one zero
+        }
+        else
+            return &buffer[length + offset];
+    }
+    else if (kk < -maxDecimalPlaces) {
+        // Truncate to zero
+        buffer[0] = '0';
+        buffer[1] = '.';
+        buffer[2] = '0';
+        return &buffer[3];
+    }
+    else if (length == 1) {
+        // 1e30
+        buffer[1] = 'e';
+        return WriteExponent(kk - 1, &buffer[2]);
+    }
+    else {
+        // 1234e30 -> 1.234e33
+        std::memmove(&buffer[2], &buffer[1], static_cast<size_t>(length - 1));
+        buffer[1] = '.';
+        buffer[length + 1] = 'e';
+        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
+    }
+}
+
+inline char* dtoa(double value, char* buffer, int maxDecimalPlaces = 324) {
+    RAPIDJSON_ASSERT(maxDecimalPlaces >= 1);
+    Double d(value);
+    if (d.IsZero()) {
+        if (d.Sign())
+            *buffer++ = '-';     // -0.0, Issue #289
+        buffer[0] = '0';
+        buffer[1] = '.';
+        buffer[2] = '0';
+        return &buffer[3];
+    }
+    else {
+        if (value < 0) {
+            *buffer++ = '-';
+            value = -value;
+        }
+        int length, K;
+        Grisu2(value, buffer, &length, &K);
+        return Prettify(buffer, length, K, maxDecimalPlaces);
+    }
+}
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_DTOA_

slsSupportLib/include/rapidjson/internal/ieee754.h

@@ -0,0 +1,78 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_IEEE754_
+#define RAPIDJSON_IEEE754_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+class Double {
+public:
+    Double() {}
+    Double(double d) : d_(d) {}
+    Double(uint64_t u) : u_(u) {}
+
+    double Value() const { return d_; }
+    uint64_t Uint64Value() const { return u_; }
+
+    double NextPositiveDouble() const {
+        RAPIDJSON_ASSERT(!Sign());
+        return Double(u_ + 1).Value();
+    }
+
+    bool Sign() const { return (u_ & kSignMask) != 0; }
+    uint64_t Significand() const { return u_ & kSignificandMask; }
+    int Exponent() const { return static_cast<int>(((u_ & kExponentMask) >> kSignificandSize) - kExponentBias); }
+
+    bool IsNan() const { return (u_ & kExponentMask) == kExponentMask && Significand() != 0; }
+    bool IsInf() const { return (u_ & kExponentMask) == kExponentMask && Significand() == 0; }
+    bool IsNanOrInf() const { return (u_ & kExponentMask) == kExponentMask; }
+    bool IsNormal() const { return (u_ & kExponentMask) != 0 || Significand() == 0; }
+    bool IsZero() const { return (u_ & (kExponentMask | kSignificandMask)) == 0; }
+
+    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
+    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
+    uint64_t ToBias() const { return (u_ & kSignMask) ? ~u_ + 1 : u_ | kSignMask; }
+
+    static unsigned EffectiveSignificandSize(int order) {
+        if (order >= -1021)
+            return 53;
+        else if (order <= -1074)
+            return 0;
+        else
+            return static_cast<unsigned>(order) + 1074;
+    }
+
+private:
+    static const int kSignificandSize = 52;
+    static const int kExponentBias = 0x3FF;
+    static const int kDenormalExponent = 1 - kExponentBias;
+    static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
+    static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
+    static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
+    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
+
+    union {
+        double d_;
+        uint64_t u_;
+    };
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_IEEE754_

slsSupportLib/include/rapidjson/internal/itoa.h

@@ -0,0 +1,304 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ITOA_
+#define RAPIDJSON_ITOA_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+inline const char* GetDigitsLut() {
+    static const char cDigitsLut[200] = {
+        '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
+        '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
+        '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
+        '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
+        '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
+        '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
+        '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
+        '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
+        '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
+        '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
+    };
+    return cDigitsLut;
+}
+
+inline char* u32toa(uint32_t value, char* buffer) {
+    const char* cDigitsLut = GetDigitsLut();
+
+    if (value < 10000) {
+        const uint32_t d1 = (value / 100) << 1;
+        const uint32_t d2 = (value % 100) << 1;
+        
+        if (value >= 1000)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= 100)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 10)
+            *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+    }
+    else if (value < 100000000) {
+        // value = bbbbcccc
+        const uint32_t b = value / 10000;
+        const uint32_t c = value % 10000;
+        
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+        
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+        
+        if (value >= 10000000)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= 1000000)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= 100000)
+            *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+    }
+    else {
+        // value = aabbbbcccc in decimal
+        
+        const uint32_t a = value / 100000000; // 1 to 42
+        value %= 100000000;
+        
+        if (a >= 10) {
+            const unsigned i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+
+        const uint32_t b = value / 10000; // 0 to 9999
+        const uint32_t c = value % 10000; // 0 to 9999
+        
+        const uint32_t d1 = (b / 100) << 1;
+        const uint32_t d2 = (b % 100) << 1;
+        
+        const uint32_t d3 = (c / 100) << 1;
+        const uint32_t d4 = (c % 100) << 1;
+        
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+    }
+    return buffer;
+}
+
+inline char* i32toa(int32_t value, char* buffer) {
+    uint32_t u = static_cast<uint32_t>(value);
+    if (value < 0) {
+        *buffer++ = '-';
+        u = ~u + 1;
+    }
+
+    return u32toa(u, buffer);
+}
+
+inline char* u64toa(uint64_t value, char* buffer) {
+    const char* cDigitsLut = GetDigitsLut();
+    const uint64_t  kTen8 = 100000000;
+    const uint64_t  kTen9 = kTen8 * 10;
+    const uint64_t kTen10 = kTen8 * 100;
+    const uint64_t kTen11 = kTen8 * 1000;
+    const uint64_t kTen12 = kTen8 * 10000;
+    const uint64_t kTen13 = kTen8 * 100000;
+    const uint64_t kTen14 = kTen8 * 1000000;
+    const uint64_t kTen15 = kTen8 * 10000000;
+    const uint64_t kTen16 = kTen8 * kTen8;
+    
+    if (value < kTen8) {
+        uint32_t v = static_cast<uint32_t>(value);
+        if (v < 10000) {
+            const uint32_t d1 = (v / 100) << 1;
+            const uint32_t d2 = (v % 100) << 1;
+            
+            if (v >= 1000)
+                *buffer++ = cDigitsLut[d1];
+            if (v >= 100)
+                *buffer++ = cDigitsLut[d1 + 1];
+            if (v >= 10)
+                *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+        }
+        else {
+            // value = bbbbcccc
+            const uint32_t b = v / 10000;
+            const uint32_t c = v % 10000;
+            
+            const uint32_t d1 = (b / 100) << 1;
+            const uint32_t d2 = (b % 100) << 1;
+            
+            const uint32_t d3 = (c / 100) << 1;
+            const uint32_t d4 = (c % 100) << 1;
+            
+            if (value >= 10000000)
+                *buffer++ = cDigitsLut[d1];
+            if (value >= 1000000)
+                *buffer++ = cDigitsLut[d1 + 1];
+            if (value >= 100000)
+                *buffer++ = cDigitsLut[d2];
+            *buffer++ = cDigitsLut[d2 + 1];
+            
+            *buffer++ = cDigitsLut[d3];
+            *buffer++ = cDigitsLut[d3 + 1];
+            *buffer++ = cDigitsLut[d4];
+            *buffer++ = cDigitsLut[d4 + 1];
+        }
+    }
+    else if (value < kTen16) {
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+        
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+        
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+        
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+        
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+        
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+
+        if (value >= kTen15)
+            *buffer++ = cDigitsLut[d1];
+        if (value >= kTen14)
+            *buffer++ = cDigitsLut[d1 + 1];
+        if (value >= kTen13)
+            *buffer++ = cDigitsLut[d2];
+        if (value >= kTen12)
+            *buffer++ = cDigitsLut[d2 + 1];
+        if (value >= kTen11)
+            *buffer++ = cDigitsLut[d3];
+        if (value >= kTen10)
+            *buffer++ = cDigitsLut[d3 + 1];
+        if (value >= kTen9)
+            *buffer++ = cDigitsLut[d4];
+        if (value >= kTen8)
+            *buffer++ = cDigitsLut[d4 + 1];
+        
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+    }
+    else {
+        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
+        value %= kTen16;
+        
+        if (a < 10)
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
+        else if (a < 100) {
+            const uint32_t i = a << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else if (a < 1000) {
+            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
+            
+            const uint32_t i = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+        }
+        else {
+            const uint32_t i = (a / 100) << 1;
+            const uint32_t j = (a % 100) << 1;
+            *buffer++ = cDigitsLut[i];
+            *buffer++ = cDigitsLut[i + 1];
+            *buffer++ = cDigitsLut[j];
+            *buffer++ = cDigitsLut[j + 1];
+        }
+        
+        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
+        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
+        
+        const uint32_t b0 = v0 / 10000;
+        const uint32_t c0 = v0 % 10000;
+        
+        const uint32_t d1 = (b0 / 100) << 1;
+        const uint32_t d2 = (b0 % 100) << 1;
+        
+        const uint32_t d3 = (c0 / 100) << 1;
+        const uint32_t d4 = (c0 % 100) << 1;
+        
+        const uint32_t b1 = v1 / 10000;
+        const uint32_t c1 = v1 % 10000;
+        
+        const uint32_t d5 = (b1 / 100) << 1;
+        const uint32_t d6 = (b1 % 100) << 1;
+        
+        const uint32_t d7 = (c1 / 100) << 1;
+        const uint32_t d8 = (c1 % 100) << 1;
+        
+        *buffer++ = cDigitsLut[d1];
+        *buffer++ = cDigitsLut[d1 + 1];
+        *buffer++ = cDigitsLut[d2];
+        *buffer++ = cDigitsLut[d2 + 1];
+        *buffer++ = cDigitsLut[d3];
+        *buffer++ = cDigitsLut[d3 + 1];
+        *buffer++ = cDigitsLut[d4];
+        *buffer++ = cDigitsLut[d4 + 1];
+        *buffer++ = cDigitsLut[d5];
+        *buffer++ = cDigitsLut[d5 + 1];
+        *buffer++ = cDigitsLut[d6];
+        *buffer++ = cDigitsLut[d6 + 1];
+        *buffer++ = cDigitsLut[d7];
+        *buffer++ = cDigitsLut[d7 + 1];
+        *buffer++ = cDigitsLut[d8];
+        *buffer++ = cDigitsLut[d8 + 1];
+    }
+    
+    return buffer;
+}
+
+inline char* i64toa(int64_t value, char* buffer) {
+    uint64_t u = static_cast<uint64_t>(value);
+    if (value < 0) {
+        *buffer++ = '-';
+        u = ~u + 1;
+    }
+
+    return u64toa(u, buffer);
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ITOA_

slsSupportLib/include/rapidjson/internal/meta.h

@@ -0,0 +1,181 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_META_H_
+#define RAPIDJSON_INTERNAL_META_H_
+
+#include "../rapidjson.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+#if defined(_MSC_VER)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(6334)
+#endif
+
+#if RAPIDJSON_HAS_CXX11_TYPETRAITS
+#include <type_traits>
+#endif
+
+//@cond RAPIDJSON_INTERNAL
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
+template <typename T> struct Void { typedef void Type; };
+
+///////////////////////////////////////////////////////////////////////////////
+// BoolType, TrueType, FalseType
+//
+template <bool Cond> struct BoolType {
+    static const bool Value = Cond;
+    typedef BoolType Type;
+};
+typedef BoolType<true> TrueType;
+typedef BoolType<false> FalseType;
+
+
+///////////////////////////////////////////////////////////////////////////////
+// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
+//
+
+template <bool C> struct SelectIfImpl { template <typename T1, typename T2> struct Apply { typedef T1 Type; }; };
+template <> struct SelectIfImpl<false> { template <typename T1, typename T2> struct Apply { typedef T2 Type; }; };
+template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
+template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};
+
+template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
+template <> struct AndExprCond<true, true> : TrueType {};
+template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
+template <> struct OrExprCond<false, false> : FalseType {};
+
+template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
+template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type {};
+template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
+template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type {};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// AddConst, MaybeAddConst, RemoveConst
+template <typename T> struct AddConst { typedef const T Type; };
+template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
+template <typename T> struct RemoveConst { typedef T Type; };
+template <typename T> struct RemoveConst<const T> { typedef T Type; };
+
+
+///////////////////////////////////////////////////////////////////////////////
+// IsSame, IsConst, IsMoreConst, IsPointer
+//
+template <typename T, typename U> struct IsSame : FalseType {};
+template <typename T> struct IsSame<T, T> : TrueType {};
+
+template <typename T> struct IsConst : FalseType {};
+template <typename T> struct IsConst<const T> : TrueType {};
+
+template <typename CT, typename T>
+struct IsMoreConst
+    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
+              BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};
+
+template <typename T> struct IsPointer : FalseType {};
+template <typename T> struct IsPointer<T*> : TrueType {};
+
+///////////////////////////////////////////////////////////////////////////////
+// IsBaseOf
+//
+#if RAPIDJSON_HAS_CXX11_TYPETRAITS
+
+template <typename B, typename D> struct IsBaseOf
+    : BoolType< ::std::is_base_of<B,D>::value> {};
+
+#else // simplified version adopted from Boost
+
+template<typename B, typename D> struct IsBaseOfImpl {
+    RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
+    RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
+
+    typedef char (&Yes)[1];
+    typedef char (&No) [2];
+
+    template <typename T>
+    static Yes Check(const D*, T);
+    static No  Check(const B*, int);
+
+    struct Host {
+        operator const B*() const;
+        operator const D*();
+    };
+
+    enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
+};
+
+template <typename B, typename D> struct IsBaseOf
+    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};
+
+#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
+
+
+//////////////////////////////////////////////////////////////////////////
+// EnableIf / DisableIf
+//
+template <bool Condition, typename T = void> struct EnableIfCond  { typedef T Type; };
+template <typename T> struct EnableIfCond<false, T> { /* empty */ };
+
+template <bool Condition, typename T = void> struct DisableIfCond { typedef T Type; };
+template <typename T> struct DisableIfCond<true, T> { /* empty */ };
+
+template <typename Condition, typename T = void>
+struct EnableIf : EnableIfCond<Condition::Value, T> {};
+
+template <typename Condition, typename T = void>
+struct DisableIf : DisableIfCond<Condition::Value, T> {};
+
+// SFINAE helpers
+struct SfinaeTag {};
+template <typename T> struct RemoveSfinaeTag;
+template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };
+
+#define RAPIDJSON_REMOVEFPTR_(type) \
+    typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
+        < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
+
+#define RAPIDJSON_ENABLEIF(cond) \
+    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
+
+#define RAPIDJSON_DISABLEIF(cond) \
+    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
+
+#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
+    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond), \
+         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
+
+#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
+    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
+        <RAPIDJSON_REMOVEFPTR_(cond), \
+         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+//@endcond
+
+#if defined(__GNUC__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_META_H_

slsSupportLib/include/rapidjson/internal/pow10.h

@@ -0,0 +1,55 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_POW10_
+#define RAPIDJSON_POW10_
+
+#include "../rapidjson.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+//! Computes integer powers of 10 in double (10.0^n).
+/*! This function uses lookup table for fast and accurate results.
+    \param n non-negative exponent. Must <= 308.
+    \return 10.0^n
+*/
+inline double Pow10(int n) {
+    static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
+        1e+0,  
+        1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
+        1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
+        1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
+        1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
+        1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
+        1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
+        1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
+        1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
+        1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
+        1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
+        1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
+        1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
+        1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
+        1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
+        1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
+        1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
+    };
+    RAPIDJSON_ASSERT(n >= 0 && n <= 308);
+    return e[n];
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_POW10_

slsSupportLib/include/rapidjson/internal/regex.h

@@ -0,0 +1,701 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_REGEX_H_
+#define RAPIDJSON_INTERNAL_REGEX_H_
+
+#include "../allocators.h"
+#include "../stream.h"
+#include "stack.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(switch-enum)
+RAPIDJSON_DIAG_OFF(implicit-fallthrough)
+#endif
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
+#endif
+
+#ifndef RAPIDJSON_REGEX_VERBOSE
+#define RAPIDJSON_REGEX_VERBOSE 0
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+///////////////////////////////////////////////////////////////////////////////
+// GenericRegex
+
+static const SizeType kRegexInvalidState = ~SizeType(0);  //!< Represents an invalid index in GenericRegex::State::out, out1
+static const SizeType kRegexInvalidRange = ~SizeType(0);
+
+//! Regular expression engine with subset of ECMAscript grammar.
+/*!
+    Supported regular expression syntax:
+    - \c ab     Concatenation
+    - \c a|b    Alternation
+    - \c a?     Zero or one
+    - \c a*     Zero or more
+    - \c a+     One or more
+    - \c a{3}   Exactly 3 times
+    - \c a{3,}  At least 3 times
+    - \c a{3,5} 3 to 5 times
+    - \c (ab)   Grouping
+    - \c ^a     At the beginning
+    - \c a$     At the end
+    - \c .      Any character
+    - \c [abc]  Character classes
+    - \c [a-c]  Character class range
+    - \c [a-z0-9_] Character class combination
+    - \c [^abc] Negated character classes
+    - \c [^a-c] Negated character class range
+    - \c [\b]   Backspace (U+0008)
+    - \c \\| \\\\ ...  Escape characters
+    - \c \\f Form feed (U+000C)
+    - \c \\n Line feed (U+000A)
+    - \c \\r Carriage return (U+000D)
+    - \c \\t Tab (U+0009)
+    - \c \\v Vertical tab (U+000B)
+
+    \note This is a Thompson NFA engine, implemented with reference to 
+        Cox, Russ. "Regular Expression Matching Can Be Simple And Fast (but is slow in Java, Perl, PHP, Python, Ruby,...).", 
+        https://swtch.com/~rsc/regexp/regexp1.html 
+*/
+template <typename Encoding, typename Allocator = CrtAllocator>
+class GenericRegex {
+public:
+    typedef typename Encoding::Ch Ch;
+
+    GenericRegex(const Ch* source, Allocator* allocator = 0) : 
+        states_(allocator, 256), ranges_(allocator, 256), root_(kRegexInvalidState), stateCount_(), rangeCount_(), 
+        stateSet_(), state0_(allocator, 0), state1_(allocator, 0), anchorBegin_(), anchorEnd_()
+    {
+        GenericStringStream<Encoding> ss(source);
+        DecodedStream<GenericStringStream<Encoding> > ds(ss);
+        Parse(ds);
+    }
+
+    ~GenericRegex() {
+        Allocator::Free(stateSet_);
+    }
+
+    bool IsValid() const {
+        return root_ != kRegexInvalidState;
+    }
+
+    template <typename InputStream>
+    bool Match(InputStream& is) const {
+        return SearchWithAnchoring(is, true, true);
+    }
+
+    bool Match(const Ch* s) const {
+        GenericStringStream<Encoding> is(s);
+        return Match(is);
+    }
+
+    template <typename InputStream>
+    bool Search(InputStream& is) const {
+        return SearchWithAnchoring(is, anchorBegin_, anchorEnd_);
+    }
+
+    bool Search(const Ch* s) const {
+        GenericStringStream<Encoding> is(s);
+        return Search(is);
+    }
+
+private:
+    enum Operator {
+        kZeroOrOne,
+        kZeroOrMore,
+        kOneOrMore,
+        kConcatenation,
+        kAlternation,
+        kLeftParenthesis
+    };
+
+    static const unsigned kAnyCharacterClass = 0xFFFFFFFF;   //!< For '.'
+    static const unsigned kRangeCharacterClass = 0xFFFFFFFE;
+    static const unsigned kRangeNegationFlag = 0x80000000;
+
+    struct Range {
+        unsigned start; // 
+        unsigned end;
+        SizeType next;
+    };
+
+    struct State {
+        SizeType out;     //!< Equals to kInvalid for matching state
+        SizeType out1;    //!< Equals to non-kInvalid for split
+        SizeType rangeStart;
+        unsigned codepoint;
+    };
+
+    struct Frag {
+        Frag(SizeType s, SizeType o, SizeType m) : start(s), out(o), minIndex(m) {}
+        SizeType start;
+        SizeType out; //!< link-list of all output states
+        SizeType minIndex;
+    };
+
+    template <typename SourceStream>
+    class DecodedStream {
+    public:
+        DecodedStream(SourceStream& ss) : ss_(ss), codepoint_() { Decode(); }
+        unsigned Peek() { return codepoint_; }
+        unsigned Take() {
+            unsigned c = codepoint_;
+            if (c) // No further decoding when '\0'
+                Decode();
+            return c;
+        }
+
+    private:
+        void Decode() {
+            if (!Encoding::Decode(ss_, &codepoint_))
+                codepoint_ = 0;
+        }
+
+        SourceStream& ss_;
+        unsigned codepoint_;
+    };
+
+    State& GetState(SizeType index) {
+        RAPIDJSON_ASSERT(index < stateCount_);
+        return states_.template Bottom<State>()[index];
+    }
+
+    const State& GetState(SizeType index) const {
+        RAPIDJSON_ASSERT(index < stateCount_);
+        return states_.template Bottom<State>()[index];
+    }
+
+    Range& GetRange(SizeType index) {
+        RAPIDJSON_ASSERT(index < rangeCount_);
+        return ranges_.template Bottom<Range>()[index];
+    }
+
+    const Range& GetRange(SizeType index) const {
+        RAPIDJSON_ASSERT(index < rangeCount_);
+        return ranges_.template Bottom<Range>()[index];
+    }
+
+    template <typename InputStream>
+    void Parse(DecodedStream<InputStream>& ds) {
+        Allocator allocator;
+        Stack<Allocator> operandStack(&allocator, 256);     // Frag
+        Stack<Allocator> operatorStack(&allocator, 256);    // Operator
+        Stack<Allocator> atomCountStack(&allocator, 256);   // unsigned (Atom per parenthesis)
+
+        *atomCountStack.template Push<unsigned>() = 0;
+
+        unsigned codepoint;
+        while (ds.Peek() != 0) {
+            switch (codepoint = ds.Take()) {
+                case '^':
+                    anchorBegin_ = true;
+                    break;
+
+                case '$':
+                    anchorEnd_ = true;
+                    break;
+
+                case '|':
+                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() < kAlternation)
+                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                            return;
+                    *operatorStack.template Push<Operator>() = kAlternation;
+                    *atomCountStack.template Top<unsigned>() = 0;
+                    break;
+
+                case '(':
+                    *operatorStack.template Push<Operator>() = kLeftParenthesis;
+                    *atomCountStack.template Push<unsigned>() = 0;
+                    break;
+
+                case ')':
+                    while (!operatorStack.Empty() && *operatorStack.template Top<Operator>() != kLeftParenthesis)
+                        if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                            return;
+                    if (operatorStack.Empty())
+                        return;
+                    operatorStack.template Pop<Operator>(1);
+                    atomCountStack.template Pop<unsigned>(1);
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+                    break;
+
+                case '?':
+                    if (!Eval(operandStack, kZeroOrOne))
+                        return;
+                    break;
+
+                case '*':
+                    if (!Eval(operandStack, kZeroOrMore))
+                        return;
+                    break;
+
+                case '+':
+                    if (!Eval(operandStack, kOneOrMore))
+                        return;
+                    break;
+
+                case '{':
+                    {
+                        unsigned n, m;
+                        if (!ParseUnsigned(ds, &n))
+                            return;
+
+                        if (ds.Peek() == ',') {
+                            ds.Take();
+                            if (ds.Peek() == '}')
+                                m = kInfinityQuantifier;
+                            else if (!ParseUnsigned(ds, &m) || m < n)
+                                return;
+                        }
+                        else
+                            m = n;
+
+                        if (!EvalQuantifier(operandStack, n, m) || ds.Peek() != '}')
+                            return;
+                        ds.Take();
+                    }
+                    break;
+
+                case '.':
+                    PushOperand(operandStack, kAnyCharacterClass);
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+                    break;
+
+                case '[':
+                    {
+                        SizeType range;
+                        if (!ParseRange(ds, &range))
+                            return;
+                        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, kRangeCharacterClass);
+                        GetState(s).rangeStart = range;
+                        *operandStack.template Push<Frag>() = Frag(s, s, s);
+                    }
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+                    break;
+
+                case '\\': // Escape character
+                    if (!CharacterEscape(ds, &codepoint))
+                        return; // Unsupported escape character
+                    // fall through to default
+
+                default: // Pattern character
+                    PushOperand(operandStack, codepoint);
+                    ImplicitConcatenation(atomCountStack, operatorStack);
+            }
+        }
+
+        while (!operatorStack.Empty())
+            if (!Eval(operandStack, *operatorStack.template Pop<Operator>(1)))
+                return;
+
+        // Link the operand to matching state.
+        if (operandStack.GetSize() == sizeof(Frag)) {
+            Frag* e = operandStack.template Pop<Frag>(1);
+            Patch(e->out, NewState(kRegexInvalidState, kRegexInvalidState, 0));
+            root_ = e->start;
+
+#if RAPIDJSON_REGEX_VERBOSE
+            printf("root: %d\n", root_);
+            for (SizeType i = 0; i < stateCount_ ; i++) {
+                State& s = GetState(i);
+                printf("[%2d] out: %2d out1: %2d c: '%c'\n", i, s.out, s.out1, (char)s.codepoint);
+            }
+            printf("\n");
+#endif
+        }
+
+        // Preallocate buffer for SearchWithAnchoring()
+        RAPIDJSON_ASSERT(stateSet_ == 0);
+        if (stateCount_ > 0) {
+            stateSet_ = static_cast<unsigned*>(states_.GetAllocator().Malloc(GetStateSetSize()));
+            state0_.template Reserve<SizeType>(stateCount_);
+            state1_.template Reserve<SizeType>(stateCount_);
+        }
+    }
+
+    SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) {
+        State* s = states_.template Push<State>();
+        s->out = out;
+        s->out1 = out1;
+        s->codepoint = codepoint;
+        s->rangeStart = kRegexInvalidRange;
+        return stateCount_++;
+    }
+
+    void PushOperand(Stack<Allocator>& operandStack, unsigned codepoint) {
+        SizeType s = NewState(kRegexInvalidState, kRegexInvalidState, codepoint);
+        *operandStack.template Push<Frag>() = Frag(s, s, s);
+    }
+
+    void ImplicitConcatenation(Stack<Allocator>& atomCountStack, Stack<Allocator>& operatorStack) {
+        if (*atomCountStack.template Top<unsigned>())
+            *operatorStack.template Push<Operator>() = kConcatenation;
+        (*atomCountStack.template Top<unsigned>())++;
+    }
+
+    SizeType Append(SizeType l1, SizeType l2) {
+        SizeType old = l1;
+        while (GetState(l1).out != kRegexInvalidState)
+            l1 = GetState(l1).out;
+        GetState(l1).out = l2;
+        return old;
+    }
+
+    void Patch(SizeType l, SizeType s) {
+        for (SizeType next; l != kRegexInvalidState; l = next) {
+            next = GetState(l).out;
+            GetState(l).out = s;
+        }
+    }
+
+    bool Eval(Stack<Allocator>& operandStack, Operator op) {
+        switch (op) {
+            case kConcatenation:
+                RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag) * 2);
+                {
+                    Frag e2 = *operandStack.template Pop<Frag>(1);
+                    Frag e1 = *operandStack.template Pop<Frag>(1);
+                    Patch(e1.out, e2.start);
+                    *operandStack.template Push<Frag>() = Frag(e1.start, e2.out, Min(e1.minIndex, e2.minIndex));
+                }
+                return true;
+
+            case kAlternation:
+                if (operandStack.GetSize() >= sizeof(Frag) * 2) {
+                    Frag e2 = *operandStack.template Pop<Frag>(1);
+                    Frag e1 = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(e1.start, e2.start, 0);
+                    *operandStack.template Push<Frag>() = Frag(s, Append(e1.out, e2.out), Min(e1.minIndex, e2.minIndex));
+                    return true;
+                }
+                return false;
+
+            case kZeroOrOne:
+                if (operandStack.GetSize() >= sizeof(Frag)) {
+                    Frag e = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                    *operandStack.template Push<Frag>() = Frag(s, Append(e.out, s), e.minIndex);
+                    return true;
+                }
+                return false;
+
+            case kZeroOrMore:
+                if (operandStack.GetSize() >= sizeof(Frag)) {
+                    Frag e = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                    Patch(e.out, s);
+                    *operandStack.template Push<Frag>() = Frag(s, s, e.minIndex);
+                    return true;
+                }
+                return false;
+
+            default: 
+                RAPIDJSON_ASSERT(op == kOneOrMore);
+                if (operandStack.GetSize() >= sizeof(Frag)) {
+                    Frag e = *operandStack.template Pop<Frag>(1);
+                    SizeType s = NewState(kRegexInvalidState, e.start, 0);
+                    Patch(e.out, s);
+                    *operandStack.template Push<Frag>() = Frag(e.start, s, e.minIndex);
+                    return true;
+                }
+                return false;
+        }
+    }
+
+    bool EvalQuantifier(Stack<Allocator>& operandStack, unsigned n, unsigned m) {
+        RAPIDJSON_ASSERT(n <= m);
+        RAPIDJSON_ASSERT(operandStack.GetSize() >= sizeof(Frag));
+
+        if (n == 0) {
+            if (m == 0)                             // a{0} not support
+                return false;
+            else if (m == kInfinityQuantifier)
+                Eval(operandStack, kZeroOrMore);    // a{0,} -> a*
+            else {
+                Eval(operandStack, kZeroOrOne);         // a{0,5} -> a?
+                for (unsigned i = 0; i < m - 1; i++)
+                    CloneTopOperand(operandStack);      // a{0,5} -> a? a? a? a? a?
+                for (unsigned i = 0; i < m - 1; i++)
+                    Eval(operandStack, kConcatenation); // a{0,5} -> a?a?a?a?a?
+            }
+            return true;
+        }
+
+        for (unsigned i = 0; i < n - 1; i++)        // a{3} -> a a a
+            CloneTopOperand(operandStack);
+
+        if (m == kInfinityQuantifier)
+            Eval(operandStack, kOneOrMore);         // a{3,} -> a a a+
+        else if (m > n) {
+            CloneTopOperand(operandStack);          // a{3,5} -> a a a a
+            Eval(operandStack, kZeroOrOne);         // a{3,5} -> a a a a?
+            for (unsigned i = n; i < m - 1; i++)
+                CloneTopOperand(operandStack);      // a{3,5} -> a a a a? a?
+            for (unsigned i = n; i < m; i++)
+                Eval(operandStack, kConcatenation); // a{3,5} -> a a aa?a?
+        }
+
+        for (unsigned i = 0; i < n - 1; i++)
+            Eval(operandStack, kConcatenation);     // a{3} -> aaa, a{3,} -> aaa+, a{3.5} -> aaaa?a?
+
+        return true;
+    }
+
+    static SizeType Min(SizeType a, SizeType b) { return a < b ? a : b; }
+
+    void CloneTopOperand(Stack<Allocator>& operandStack) {
+        const Frag src = *operandStack.template Top<Frag>(); // Copy constructor to prevent invalidation
+        SizeType count = stateCount_ - src.minIndex; // Assumes top operand contains states in [src->minIndex, stateCount_)
+        State* s = states_.template Push<State>(count);
+        memcpy(s, &GetState(src.minIndex), count * sizeof(State));
+        for (SizeType j = 0; j < count; j++) {
+            if (s[j].out != kRegexInvalidState)
+                s[j].out += count;
+            if (s[j].out1 != kRegexInvalidState)
+                s[j].out1 += count;
+        }
+        *operandStack.template Push<Frag>() = Frag(src.start + count, src.out + count, src.minIndex + count);
+        stateCount_ += count;
+    }
+
+    template <typename InputStream>
+    bool ParseUnsigned(DecodedStream<InputStream>& ds, unsigned* u) {
+        unsigned r = 0;
+        if (ds.Peek() < '0' || ds.Peek() > '9')
+            return false;
+        while (ds.Peek() >= '0' && ds.Peek() <= '9') {
+            if (r >= 429496729 && ds.Peek() > '5') // 2^32 - 1 = 4294967295
+                return false; // overflow
+            r = r * 10 + (ds.Take() - '0');
+        }
+        *u = r;
+        return true;
+    }
+
+    template <typename InputStream>
+    bool ParseRange(DecodedStream<InputStream>& ds, SizeType* range) {
+        bool isBegin = true;
+        bool negate = false;
+        int step = 0;
+        SizeType start = kRegexInvalidRange;
+        SizeType current = kRegexInvalidRange;
+        unsigned codepoint;
+        while ((codepoint = ds.Take()) != 0) {
+            if (isBegin) {
+                isBegin = false;
+                if (codepoint == '^') {
+                    negate = true;
+                    continue;
+                }
+            }
+
+            switch (codepoint) {
+            case ']':
+                if (start == kRegexInvalidRange)
+                    return false;   // Error: nothing inside []
+                if (step == 2) { // Add trailing '-'
+                    SizeType r = NewRange('-');
+                    RAPIDJSON_ASSERT(current != kRegexInvalidRange);
+                    GetRange(current).next = r;
+                }
+                if (negate)
+                    GetRange(start).start |= kRangeNegationFlag;
+                *range = start;
+                return true;
+
+            case '\\':
+                if (ds.Peek() == 'b') {
+                    ds.Take();
+                    codepoint = 0x0008; // Escape backspace character
+                }
+                else if (!CharacterEscape(ds, &codepoint))
+                    return false;
+                // fall through to default
+
+            default:
+                switch (step) {
+                case 1:
+                    if (codepoint == '-') {
+                        step++;
+                        break;
+                    }
+                    // fall through to step 0 for other characters
+
+                case 0:
+                    {
+                        SizeType r = NewRange(codepoint);
+                        if (current != kRegexInvalidRange)
+                            GetRange(current).next = r;
+                        if (start == kRegexInvalidRange)
+                            start = r;
+                        current = r;
+                    }
+                    step = 1;
+                    break;
+
+                default:
+                    RAPIDJSON_ASSERT(step == 2);
+                    GetRange(current).end = codepoint;
+                    step = 0;
+                }
+            }
+        }
+        return false;
+    }
+    
+    SizeType NewRange(unsigned codepoint) {
+        Range* r = ranges_.template Push<Range>();
+        r->start = r->end = codepoint;
+        r->next = kRegexInvalidRange;
+        return rangeCount_++;
+    }
+
+    template <typename InputStream>
+    bool CharacterEscape(DecodedStream<InputStream>& ds, unsigned* escapedCodepoint) {
+        unsigned codepoint;
+        switch (codepoint = ds.Take()) {
+            case '^':
+            case '$':
+            case '|':
+            case '(':
+            case ')':
+            case '?':
+            case '*':
+            case '+':
+            case '.':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case '\\':
+                *escapedCodepoint = codepoint; return true;
+            case 'f': *escapedCodepoint = 0x000C; return true;
+            case 'n': *escapedCodepoint = 0x000A; return true;
+            case 'r': *escapedCodepoint = 0x000D; return true;
+            case 't': *escapedCodepoint = 0x0009; return true;
+            case 'v': *escapedCodepoint = 0x000B; return true;
+            default:
+                return false; // Unsupported escape character
+        }
+    }
+
+    template <typename InputStream>
+    bool SearchWithAnchoring(InputStream& is, bool anchorBegin, bool anchorEnd) const {
+        RAPIDJSON_ASSERT(IsValid());
+        DecodedStream<InputStream> ds(is);
+
+        state0_.Clear();
+        Stack<Allocator> *current = &state0_, *next = &state1_;
+        const size_t stateSetSize = GetStateSetSize();
+        std::memset(stateSet_, 0, stateSetSize);
+
+        bool matched = AddState(*current, root_);
+        unsigned codepoint;
+        while (!current->Empty() && (codepoint = ds.Take()) != 0) {
+            std::memset(stateSet_, 0, stateSetSize);
+            next->Clear();
+            matched = false;
+            for (const SizeType* s = current->template Bottom<SizeType>(); s != current->template End<SizeType>(); ++s) {
+                const State& sr = GetState(*s);
+                if (sr.codepoint == codepoint ||
+                    sr.codepoint == kAnyCharacterClass || 
+                    (sr.codepoint == kRangeCharacterClass && MatchRange(sr.rangeStart, codepoint)))
+                {
+                    matched = AddState(*next, sr.out) || matched;
+                    if (!anchorEnd && matched)
+                        return true;
+                }
+                if (!anchorBegin)
+                    AddState(*next, root_);
+            }
+            internal::Swap(current, next);
+        }
+
+        return matched;
+    }
+
+    size_t GetStateSetSize() const {
+        return (stateCount_ + 31) / 32 * 4;
+    }
+
+    // Return whether the added states is a match state
+    bool AddState(Stack<Allocator>& l, SizeType index) const {
+        RAPIDJSON_ASSERT(index != kRegexInvalidState);
+
+        const State& s = GetState(index);
+        if (s.out1 != kRegexInvalidState) { // Split
+            bool matched = AddState(l, s.out);
+            return AddState(l, s.out1) || matched;
+        }
+        else if (!(stateSet_[index >> 5] & (1 << (index & 31)))) {
+            stateSet_[index >> 5] |= (1 << (index & 31));
+            *l.template PushUnsafe<SizeType>() = index;
+        }
+        return s.out == kRegexInvalidState; // by using PushUnsafe() above, we can ensure s is not validated due to reallocation.
+    }
+
+    bool MatchRange(SizeType rangeIndex, unsigned codepoint) const {
+        bool yes = (GetRange(rangeIndex).start & kRangeNegationFlag) == 0;
+        while (rangeIndex != kRegexInvalidRange) {
+            const Range& r = GetRange(rangeIndex);
+            if (codepoint >= (r.start & ~kRangeNegationFlag) && codepoint <= r.end)
+                return yes;
+            rangeIndex = r.next;
+        }
+        return !yes;
+    }
+
+    Stack<Allocator> states_;
+    Stack<Allocator> ranges_;
+    SizeType root_;
+    SizeType stateCount_;
+    SizeType rangeCount_;
+
+    static const unsigned kInfinityQuantifier = ~0u;
+
+    // For SearchWithAnchoring()
+    uint32_t* stateSet_;        // allocated by states_.GetAllocator()
+    mutable Stack<Allocator> state0_;
+    mutable Stack<Allocator> state1_;
+    bool anchorBegin_;
+    bool anchorEnd_;
+};
+
+typedef GenericRegex<UTF8<> > Regex;
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_REGEX_H_

slsSupportLib/include/rapidjson/internal/stack.h

@@ -0,0 +1,230 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_STACK_H_
+#define RAPIDJSON_INTERNAL_STACK_H_
+
+#include "../allocators.h"
+#include "swap.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+///////////////////////////////////////////////////////////////////////////////
+// Stack
+
+//! A type-unsafe stack for storing different types of data.
+/*! \tparam Allocator Allocator for allocating stack memory.
+*/
+template <typename Allocator>
+class Stack {
+public:
+    // Optimization note: Do not allocate memory for stack_ in constructor.
+    // Do it lazily when first Push() -> Expand() -> Resize().
+    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    Stack(Stack&& rhs)
+        : allocator_(rhs.allocator_),
+          ownAllocator_(rhs.ownAllocator_),
+          stack_(rhs.stack_),
+          stackTop_(rhs.stackTop_),
+          stackEnd_(rhs.stackEnd_),
+          initialCapacity_(rhs.initialCapacity_)
+    {
+        rhs.allocator_ = 0;
+        rhs.ownAllocator_ = 0;
+        rhs.stack_ = 0;
+        rhs.stackTop_ = 0;
+        rhs.stackEnd_ = 0;
+        rhs.initialCapacity_ = 0;
+    }
+#endif
+
+    ~Stack() {
+        Destroy();
+    }
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    Stack& operator=(Stack&& rhs) {
+        if (&rhs != this)
+        {
+            Destroy();
+
+            allocator_ = rhs.allocator_;
+            ownAllocator_ = rhs.ownAllocator_;
+            stack_ = rhs.stack_;
+            stackTop_ = rhs.stackTop_;
+            stackEnd_ = rhs.stackEnd_;
+            initialCapacity_ = rhs.initialCapacity_;
+
+            rhs.allocator_ = 0;
+            rhs.ownAllocator_ = 0;
+            rhs.stack_ = 0;
+            rhs.stackTop_ = 0;
+            rhs.stackEnd_ = 0;
+            rhs.initialCapacity_ = 0;
+        }
+        return *this;
+    }
+#endif
+
+    void Swap(Stack& rhs) RAPIDJSON_NOEXCEPT {
+        internal::Swap(allocator_, rhs.allocator_);
+        internal::Swap(ownAllocator_, rhs.ownAllocator_);
+        internal::Swap(stack_, rhs.stack_);
+        internal::Swap(stackTop_, rhs.stackTop_);
+        internal::Swap(stackEnd_, rhs.stackEnd_);
+        internal::Swap(initialCapacity_, rhs.initialCapacity_);
+    }
+
+    void Clear() { stackTop_ = stack_; }
+
+    void ShrinkToFit() { 
+        if (Empty()) {
+            // If the stack is empty, completely deallocate the memory.
+            Allocator::Free(stack_);
+            stack_ = 0;
+            stackTop_ = 0;
+            stackEnd_ = 0;
+        }
+        else
+            Resize(GetSize());
+    }
+
+    // Optimization note: try to minimize the size of this function for force inline.
+    // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
+    template<typename T>
+    RAPIDJSON_FORCEINLINE void Reserve(size_t count = 1) {
+         // Expand the stack if needed
+        if (RAPIDJSON_UNLIKELY(stackTop_ + sizeof(T) * count > stackEnd_))
+            Expand<T>(count);
+    }
+
+    template<typename T>
+    RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
+        Reserve<T>(count);
+        return PushUnsafe<T>(count);
+    }
+
+    template<typename T>
+    RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
+        RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
+        T* ret = reinterpret_cast<T*>(stackTop_);
+        stackTop_ += sizeof(T) * count;
+        return ret;
+    }
+
+    template<typename T>
+    T* Pop(size_t count) {
+        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
+        stackTop_ -= count * sizeof(T);
+        return reinterpret_cast<T*>(stackTop_);
+    }
+
+    template<typename T>
+    T* Top() { 
+        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
+        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
+    }
+
+    template<typename T>
+    const T* Top() const {
+        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
+        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
+    }
+
+    template<typename T>
+    T* End() { return reinterpret_cast<T*>(stackTop_); }
+
+    template<typename T>
+    const T* End() const { return reinterpret_cast<T*>(stackTop_); }
+
+    template<typename T>
+    T* Bottom() { return reinterpret_cast<T*>(stack_); }
+
+    template<typename T>
+    const T* Bottom() const { return reinterpret_cast<T*>(stack_); }
+
+    bool HasAllocator() const {
+        return allocator_ != 0;
+    }
+
+    Allocator& GetAllocator() {
+        RAPIDJSON_ASSERT(allocator_);
+        return *allocator_;
+    }
+
+    bool Empty() const { return stackTop_ == stack_; }
+    size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
+    size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }
+
+private:
+    template<typename T>
+    void Expand(size_t count) {
+        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
+        size_t newCapacity;
+        if (stack_ == 0) {
+            if (!allocator_)
+                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
+            newCapacity = initialCapacity_;
+        } else {
+            newCapacity = GetCapacity();
+            newCapacity += (newCapacity + 1) / 2;
+        }
+        size_t newSize = GetSize() + sizeof(T) * count;
+        if (newCapacity < newSize)
+            newCapacity = newSize;
+
+        Resize(newCapacity);
+    }
+
+    void Resize(size_t newCapacity) {
+        const size_t size = GetSize();  // Backup the current size
+        stack_ = static_cast<char*>(allocator_->Realloc(stack_, GetCapacity(), newCapacity));
+        stackTop_ = stack_ + size;
+        stackEnd_ = stack_ + newCapacity;
+    }
+
+    void Destroy() {
+        Allocator::Free(stack_);
+        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
+    }
+
+    // Prohibit copy constructor & assignment operator.
+    Stack(const Stack&);
+    Stack& operator=(const Stack&);
+
+    Allocator* allocator_;
+    Allocator* ownAllocator_;
+    char *stack_;
+    char *stackTop_;
+    char *stackEnd_;
+    size_t initialCapacity_;
+};
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_STACK_H_

slsSupportLib/include/rapidjson/internal/strfunc.h

@@ -0,0 +1,55 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
+#define RAPIDJSON_INTERNAL_STRFUNC_H_
+
+#include "../stream.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+//! Custom strlen() which works on different character types.
+/*! \tparam Ch Character type (e.g. char, wchar_t, short)
+    \param s Null-terminated input string.
+    \return Number of characters in the string. 
+    \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
+*/
+template <typename Ch>
+inline SizeType StrLen(const Ch* s) {
+    const Ch* p = s;
+    while (*p) ++p;
+    return SizeType(p - s);
+}
+
+//! Returns number of code points in a encoded string.
+template<typename Encoding>
+bool CountStringCodePoint(const typename Encoding::Ch* s, SizeType length, SizeType* outCount) {
+    GenericStringStream<Encoding> is(s);
+    const typename Encoding::Ch* end = s + length;
+    SizeType count = 0;
+    while (is.src_ < end) {
+        unsigned codepoint;
+        if (!Encoding::Decode(is, &codepoint))
+            return false;
+        count++;
+    }
+    *outCount = count;
+    return true;
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_INTERNAL_STRFUNC_H_

slsSupportLib/include/rapidjson/internal/strtod.h

@@ -0,0 +1,269 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_STRTOD_
+#define RAPIDJSON_STRTOD_
+
+#include "ieee754.h"
+#include "biginteger.h"
+#include "diyfp.h"
+#include "pow10.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+inline double FastPath(double significand, int exp) {
+    if (exp < -308)
+        return 0.0;
+    else if (exp >= 0)
+        return significand * internal::Pow10(exp);
+    else
+        return significand / internal::Pow10(-exp);
+}
+
+inline double StrtodNormalPrecision(double d, int p) {
+    if (p < -308) {
+        // Prevent expSum < -308, making Pow10(p) = 0
+        d = FastPath(d, -308);
+        d = FastPath(d, p + 308);
+    }
+    else
+        d = FastPath(d, p);
+    return d;
+}
+
+template <typename T>
+inline T Min3(T a, T b, T c) {
+    T m = a;
+    if (m > b) m = b;
+    if (m > c) m = c;
+    return m;
+}
+
+inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp) {
+    const Double db(b);
+    const uint64_t bInt = db.IntegerSignificand();
+    const int bExp = db.IntegerExponent();
+    const int hExp = bExp - 1;
+
+    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
+
+    // Adjust for decimal exponent
+    if (dExp >= 0) {
+        dS_Exp2 += dExp;
+        dS_Exp5 += dExp;
+    }
+    else {
+        bS_Exp2 -= dExp;
+        bS_Exp5 -= dExp;
+        hS_Exp2 -= dExp;
+        hS_Exp5 -= dExp;
+    }
+
+    // Adjust for binary exponent
+    if (bExp >= 0)
+        bS_Exp2 += bExp;
+    else {
+        dS_Exp2 -= bExp;
+        hS_Exp2 -= bExp;
+    }
+
+    // Adjust for half ulp exponent
+    if (hExp >= 0)
+        hS_Exp2 += hExp;
+    else {
+        dS_Exp2 -= hExp;
+        bS_Exp2 -= hExp;
+    }
+
+    // Remove common power of two factor from all three scaled values
+    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
+    dS_Exp2 -= common_Exp2;
+    bS_Exp2 -= common_Exp2;
+    hS_Exp2 -= common_Exp2;
+
+    BigInteger dS = d;
+    dS.MultiplyPow5(static_cast<unsigned>(dS_Exp5)) <<= static_cast<unsigned>(dS_Exp2);
+
+    BigInteger bS(bInt);
+    bS.MultiplyPow5(static_cast<unsigned>(bS_Exp5)) <<= static_cast<unsigned>(bS_Exp2);
+
+    BigInteger hS(1);
+    hS.MultiplyPow5(static_cast<unsigned>(hS_Exp5)) <<= static_cast<unsigned>(hS_Exp2);
+
+    BigInteger delta(0);
+    dS.Difference(bS, &delta);
+
+    return delta.Compare(hS);
+}
+
+inline bool StrtodFast(double d, int p, double* result) {
+    // Use fast path for string-to-double conversion if possible
+    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
+    if (p > 22  && p < 22 + 16) {
+        // Fast Path Cases In Disguise
+        d *= internal::Pow10(p - 22);
+        p = 22;
+    }
+
+    if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
+        *result = FastPath(d, p);
+        return true;
+    }
+    else
+        return false;
+}
+
+// Compute an approximation and see if it is within 1/2 ULP
+inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
+    uint64_t significand = 0;
+    size_t i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
+    for (; i < length; i++) {
+        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
+            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
+            break;
+        significand = significand * 10u + static_cast<unsigned>(decimals[i] - '0');
+    }
+    
+    if (i < length && decimals[i] >= '5') // Rounding
+        significand++;
+
+    size_t remaining = length - i;
+    const unsigned kUlpShift = 3;
+    const unsigned kUlp = 1 << kUlpShift;
+    int64_t error = (remaining == 0) ? 0 : kUlp / 2;
+
+    DiyFp v(significand, 0);
+    v = v.Normalize();
+    error <<= -v.e;
+
+    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(i) + exp;
+
+    int actualExp;
+    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
+    if (actualExp != dExp) {
+        static const DiyFp kPow10[] = {
+            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60),  // 10^1
+            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57),  // 10^2
+            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54),  // 10^3
+            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50),  // 10^4
+            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47),  // 10^5
+            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44),  // 10^6
+            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40)   // 10^7
+        };
+        int  adjustment = dExp - actualExp - 1;
+        RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
+        v = v * kPow10[adjustment];
+        if (length + static_cast<unsigned>(adjustment)> 19u) // has more digits than decimal digits in 64-bit
+            error += kUlp / 2;
+    }
+
+    v = v * cachedPower;
+
+    error += kUlp + (error == 0 ? 0 : 1);
+
+    const int oldExp = v.e;
+    v = v.Normalize();
+    error <<= oldExp - v.e;
+
+    const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
+    unsigned precisionSize = 64 - effectiveSignificandSize;
+    if (precisionSize + kUlpShift >= 64) {
+        unsigned scaleExp = (precisionSize + kUlpShift) - 63;
+        v.f >>= scaleExp;
+        v.e += scaleExp; 
+        error = (error >> scaleExp) + 1 + static_cast<int>(kUlp);
+        precisionSize -= scaleExp;
+    }
+
+    DiyFp rounded(v.f >> precisionSize, v.e + static_cast<int>(precisionSize));
+    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
+    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
+    if (precisionBits >= halfWay + static_cast<unsigned>(error)) {
+        rounded.f++;
+        if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
+            rounded.f >>= 1;
+            rounded.e++;
+        }
+    }
+
+    *result = rounded.ToDouble();
+
+    return halfWay - static_cast<unsigned>(error) >= precisionBits || precisionBits >= halfWay + static_cast<unsigned>(error);
+}
+
+inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
+    const BigInteger dInt(decimals, length);
+    const int dExp = static_cast<int>(decimalPosition) - static_cast<int>(length) + exp;
+    Double a(approx);
+    int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
+    if (cmp < 0)
+        return a.Value();  // within half ULP
+    else if (cmp == 0) {
+        // Round towards even
+        if (a.Significand() & 1)
+            return a.NextPositiveDouble();
+        else
+            return a.Value();
+    }
+    else // adjustment
+        return a.NextPositiveDouble();
+}
+
+inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
+    RAPIDJSON_ASSERT(d >= 0.0);
+    RAPIDJSON_ASSERT(length >= 1);
+
+    double result;
+    if (StrtodFast(d, p, &result))
+        return result;
+
+    // Trim leading zeros
+    while (*decimals == '0' && length > 1) {
+        length--;
+        decimals++;
+        decimalPosition--;
+    }
+
+    // Trim trailing zeros
+    while (decimals[length - 1] == '0' && length > 1) {
+        length--;
+        decimalPosition--;
+        exp++;
+    }
+
+    // Trim right-most digits
+    const int kMaxDecimalDigit = 780;
+    if (static_cast<int>(length) > kMaxDecimalDigit) {
+        int delta = (static_cast<int>(length) - kMaxDecimalDigit);
+        exp += delta;
+        decimalPosition -= static_cast<unsigned>(delta);
+        length = kMaxDecimalDigit;
+    }
+
+    // If too small, underflow to zero
+    if (int(length) + exp < -324)
+        return 0.0;
+
+    if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
+        return result;
+
+    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
+    return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_STRTOD_

slsSupportLib/include/rapidjson/internal/swap.h

@@ -0,0 +1,46 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+//
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_INTERNAL_SWAP_H_
+#define RAPIDJSON_INTERNAL_SWAP_H_
+
+#include "../rapidjson.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+namespace internal {
+
+//! Custom swap() to avoid dependency on C++ <algorithm> header
+/*! \tparam T Type of the arguments to swap, should be instantiated with primitive C++ types only.
+    \note This has the same semantics as std::swap().
+*/
+template <typename T>
+inline void Swap(T& a, T& b) RAPIDJSON_NOEXCEPT {
+    T tmp = a;
+        a = b;
+        b = tmp;
+}
+
+} // namespace internal
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_INTERNAL_SWAP_H_

slsSupportLib/include/rapidjson/istreamwrapper.h

@@ -0,0 +1,115 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_ISTREAMWRAPPER_H_
+#define RAPIDJSON_ISTREAMWRAPPER_H_
+
+#include "stream.h"
+#include <iosfwd>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4351) // new behavior: elements of array 'array' will be default initialized
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of \c std::basic_istream into RapidJSON's Stream concept.
+/*!
+    The classes can be wrapped including but not limited to:
+
+    - \c std::istringstream
+    - \c std::stringstream
+    - \c std::wistringstream
+    - \c std::wstringstream
+    - \c std::ifstream
+    - \c std::fstream
+    - \c std::wifstream
+    - \c std::wfstream
+
+    \tparam StreamType Class derived from \c std::basic_istream.
+*/
+   
+template <typename StreamType>
+class BasicIStreamWrapper {
+public:
+    typedef typename StreamType::char_type Ch;
+    BasicIStreamWrapper(StreamType& stream) : stream_(stream), count_(), peekBuffer_() {}
+
+    Ch Peek() const { 
+        typename StreamType::int_type c = stream_.peek();
+        return RAPIDJSON_LIKELY(c != StreamType::traits_type::eof()) ? static_cast<Ch>(c) : '\0';
+    }
+
+    Ch Take() { 
+        typename StreamType::int_type c = stream_.get();
+        if (RAPIDJSON_LIKELY(c != StreamType::traits_type::eof())) {
+            count_++;
+            return static_cast<Ch>(c);
+        }
+        else
+            return '\0';
+    }
+
+    // tellg() may return -1 when failed. So we count by ourself.
+    size_t Tell() const { return count_; }
+
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    // For encoding detection only.
+    const Ch* Peek4() const {
+        RAPIDJSON_ASSERT(sizeof(Ch) == 1); // Only usable for byte stream.
+        int i;
+        bool hasError = false;
+        for (i = 0; i < 4; ++i) {
+            typename StreamType::int_type c = stream_.get();
+            if (c == StreamType::traits_type::eof()) {
+                hasError = true;
+                stream_.clear();
+                break;
+            }
+            peekBuffer_[i] = static_cast<Ch>(c);
+        }
+        for (--i; i >= 0; --i)
+            stream_.putback(peekBuffer_[i]);
+        return !hasError ? peekBuffer_ : 0;
+    }
+
+private:
+    BasicIStreamWrapper(const BasicIStreamWrapper&);
+    BasicIStreamWrapper& operator=(const BasicIStreamWrapper&);
+
+    StreamType& stream_;
+    size_t count_;  //!< Number of characters read. Note:
+    mutable Ch peekBuffer_[4];
+};
+
+typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
+typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;
+
+#if defined(__clang__) || defined(_MSC_VER)
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_ISTREAMWRAPPER_H_

slsSupportLib/include/rapidjson/memorybuffer.h

@@ -0,0 +1,70 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_MEMORYBUFFER_H_
+#define RAPIDJSON_MEMORYBUFFER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory output byte stream.
+/*!
+    This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
+
+    It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
+
+    Differences between MemoryBuffer and StringBuffer:
+    1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. 
+    2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
+
+    \tparam Allocator type for allocating memory buffer.
+    \note implements Stream concept
+*/
+template <typename Allocator = CrtAllocator>
+struct GenericMemoryBuffer {
+    typedef char Ch; // byte
+
+    GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
+
+    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
+    void Flush() {}
+
+    void Clear() { stack_.Clear(); }
+    void ShrinkToFit() { stack_.ShrinkToFit(); }
+    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
+    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
+
+    const Ch* GetBuffer() const {
+        return stack_.template Bottom<Ch>();
+    }
+
+    size_t GetSize() const { return stack_.GetSize(); }
+
+    static const size_t kDefaultCapacity = 256;
+    mutable internal::Stack<Allocator> stack_;
+};
+
+typedef GenericMemoryBuffer<> MemoryBuffer;
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
+    std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_MEMORYBUFFER_H_

slsSupportLib/include/rapidjson/memorystream.h

@@ -0,0 +1,71 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_MEMORYSTREAM_H_
+#define RAPIDJSON_MEMORYSTREAM_H_
+
+#include "stream.h"
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(unreachable-code)
+RAPIDJSON_DIAG_OFF(missing-noreturn)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory input byte stream.
+/*!
+    This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
+
+    It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
+
+    Differences between MemoryStream and StringStream:
+    1. StringStream has encoding but MemoryStream is a byte stream.
+    2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
+    3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
+    \note implements Stream concept
+*/
+struct MemoryStream {
+    typedef char Ch; // byte
+
+    MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
+
+    Ch Peek() const { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_; }
+    Ch Take() { return RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src_++; }
+    size_t Tell() const { return static_cast<size_t>(src_ - begin_); }
+
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    // For encoding detection only.
+    const Ch* Peek4() const {
+        return Tell() + 4 <= size_ ? src_ : 0;
+    }
+
+    const Ch* src_;     //!< Current read position.
+    const Ch* begin_;   //!< Original head of the string.
+    const Ch* end_;     //!< End of stream.
+    size_t size_;       //!< Size of the stream.
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_MEMORYBUFFER_H_

slsSupportLib/include/rapidjson/msinttypes/inttypes.h

@@ -0,0 +1,316 @@
+// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2013 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+// The above software in this distribution may have been modified by 
+// THL A29 Limited ("Tencent Modifications"). 
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_INTTYPES_H_ // [
+#define _MSC_INTTYPES_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include "stdint.h"
+
+// miloyip: VC supports inttypes.h since VC2013
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+
+// 7.8 Format conversion of integer types
+
+typedef struct {
+   intmax_t quot;
+   intmax_t rem;
+} imaxdiv_t;
+
+// 7.8.1 Macros for format specifiers
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
+
+// The fprintf macros for signed integers are:
+#define PRId8       "d"
+#define PRIi8       "i"
+#define PRIdLEAST8  "d"
+#define PRIiLEAST8  "i"
+#define PRIdFAST8   "d"
+#define PRIiFAST8   "i"
+
+#define PRId16       "hd"
+#define PRIi16       "hi"
+#define PRIdLEAST16  "hd"
+#define PRIiLEAST16  "hi"
+#define PRIdFAST16   "hd"
+#define PRIiFAST16   "hi"
+
+#define PRId32       "I32d"
+#define PRIi32       "I32i"
+#define PRIdLEAST32  "I32d"
+#define PRIiLEAST32  "I32i"
+#define PRIdFAST32   "I32d"
+#define PRIiFAST32   "I32i"
+
+#define PRId64       "I64d"
+#define PRIi64       "I64i"
+#define PRIdLEAST64  "I64d"
+#define PRIiLEAST64  "I64i"
+#define PRIdFAST64   "I64d"
+#define PRIiFAST64   "I64i"
+
+#define PRIdMAX     "I64d"
+#define PRIiMAX     "I64i"
+
+#define PRIdPTR     "Id"
+#define PRIiPTR     "Ii"
+
+// The fprintf macros for unsigned integers are:
+#define PRIo8       "o"
+#define PRIu8       "u"
+#define PRIx8       "x"
+#define PRIX8       "X"
+#define PRIoLEAST8  "o"
+#define PRIuLEAST8  "u"
+#define PRIxLEAST8  "x"
+#define PRIXLEAST8  "X"
+#define PRIoFAST8   "o"
+#define PRIuFAST8   "u"
+#define PRIxFAST8   "x"
+#define PRIXFAST8   "X"
+
+#define PRIo16       "ho"
+#define PRIu16       "hu"
+#define PRIx16       "hx"
+#define PRIX16       "hX"
+#define PRIoLEAST16  "ho"
+#define PRIuLEAST16  "hu"
+#define PRIxLEAST16  "hx"
+#define PRIXLEAST16  "hX"
+#define PRIoFAST16   "ho"
+#define PRIuFAST16   "hu"
+#define PRIxFAST16   "hx"
+#define PRIXFAST16   "hX"
+
+#define PRIo32       "I32o"
+#define PRIu32       "I32u"
+#define PRIx32       "I32x"
+#define PRIX32       "I32X"
+#define PRIoLEAST32  "I32o"
+#define PRIuLEAST32  "I32u"
+#define PRIxLEAST32  "I32x"
+#define PRIXLEAST32  "I32X"
+#define PRIoFAST32   "I32o"
+#define PRIuFAST32   "I32u"
+#define PRIxFAST32   "I32x"
+#define PRIXFAST32   "I32X"
+
+#define PRIo64       "I64o"
+#define PRIu64       "I64u"
+#define PRIx64       "I64x"
+#define PRIX64       "I64X"
+#define PRIoLEAST64  "I64o"
+#define PRIuLEAST64  "I64u"
+#define PRIxLEAST64  "I64x"
+#define PRIXLEAST64  "I64X"
+#define PRIoFAST64   "I64o"
+#define PRIuFAST64   "I64u"
+#define PRIxFAST64   "I64x"
+#define PRIXFAST64   "I64X"
+
+#define PRIoMAX     "I64o"
+#define PRIuMAX     "I64u"
+#define PRIxMAX     "I64x"
+#define PRIXMAX     "I64X"
+
+#define PRIoPTR     "Io"
+#define PRIuPTR     "Iu"
+#define PRIxPTR     "Ix"
+#define PRIXPTR     "IX"
+
+// The fscanf macros for signed integers are:
+#define SCNd8       "d"
+#define SCNi8       "i"
+#define SCNdLEAST8  "d"
+#define SCNiLEAST8  "i"
+#define SCNdFAST8   "d"
+#define SCNiFAST8   "i"
+
+#define SCNd16       "hd"
+#define SCNi16       "hi"
+#define SCNdLEAST16  "hd"
+#define SCNiLEAST16  "hi"
+#define SCNdFAST16   "hd"
+#define SCNiFAST16   "hi"
+
+#define SCNd32       "ld"
+#define SCNi32       "li"
+#define SCNdLEAST32  "ld"
+#define SCNiLEAST32  "li"
+#define SCNdFAST32   "ld"
+#define SCNiFAST32   "li"
+
+#define SCNd64       "I64d"
+#define SCNi64       "I64i"
+#define SCNdLEAST64  "I64d"
+#define SCNiLEAST64  "I64i"
+#define SCNdFAST64   "I64d"
+#define SCNiFAST64   "I64i"
+
+#define SCNdMAX     "I64d"
+#define SCNiMAX     "I64i"
+
+#ifdef _WIN64 // [
+#  define SCNdPTR     "I64d"
+#  define SCNiPTR     "I64i"
+#else  // _WIN64 ][
+#  define SCNdPTR     "ld"
+#  define SCNiPTR     "li"
+#endif  // _WIN64 ]
+
+// The fscanf macros for unsigned integers are:
+#define SCNo8       "o"
+#define SCNu8       "u"
+#define SCNx8       "x"
+#define SCNX8       "X"
+#define SCNoLEAST8  "o"
+#define SCNuLEAST8  "u"
+#define SCNxLEAST8  "x"
+#define SCNXLEAST8  "X"
+#define SCNoFAST8   "o"
+#define SCNuFAST8   "u"
+#define SCNxFAST8   "x"
+#define SCNXFAST8   "X"
+
+#define SCNo16       "ho"
+#define SCNu16       "hu"
+#define SCNx16       "hx"
+#define SCNX16       "hX"
+#define SCNoLEAST16  "ho"
+#define SCNuLEAST16  "hu"
+#define SCNxLEAST16  "hx"
+#define SCNXLEAST16  "hX"
+#define SCNoFAST16   "ho"
+#define SCNuFAST16   "hu"
+#define SCNxFAST16   "hx"
+#define SCNXFAST16   "hX"
+
+#define SCNo32       "lo"
+#define SCNu32       "lu"
+#define SCNx32       "lx"
+#define SCNX32       "lX"
+#define SCNoLEAST32  "lo"
+#define SCNuLEAST32  "lu"
+#define SCNxLEAST32  "lx"
+#define SCNXLEAST32  "lX"
+#define SCNoFAST32   "lo"
+#define SCNuFAST32   "lu"
+#define SCNxFAST32   "lx"
+#define SCNXFAST32   "lX"
+
+#define SCNo64       "I64o"
+#define SCNu64       "I64u"
+#define SCNx64       "I64x"
+#define SCNX64       "I64X"
+#define SCNoLEAST64  "I64o"
+#define SCNuLEAST64  "I64u"
+#define SCNxLEAST64  "I64x"
+#define SCNXLEAST64  "I64X"
+#define SCNoFAST64   "I64o"
+#define SCNuFAST64   "I64u"
+#define SCNxFAST64   "I64x"
+#define SCNXFAST64   "I64X"
+
+#define SCNoMAX     "I64o"
+#define SCNuMAX     "I64u"
+#define SCNxMAX     "I64x"
+#define SCNXMAX     "I64X"
+
+#ifdef _WIN64 // [
+#  define SCNoPTR     "I64o"
+#  define SCNuPTR     "I64u"
+#  define SCNxPTR     "I64x"
+#  define SCNXPTR     "I64X"
+#else  // _WIN64 ][
+#  define SCNoPTR     "lo"
+#  define SCNuPTR     "lu"
+#  define SCNxPTR     "lx"
+#  define SCNXPTR     "lX"
+#endif  // _WIN64 ]
+
+#endif // __STDC_FORMAT_MACROS ]
+
+// 7.8.2 Functions for greatest-width integer types
+
+// 7.8.2.1 The imaxabs function
+#define imaxabs _abs64
+
+// 7.8.2.2 The imaxdiv function
+
+// This is modified version of div() function from Microsoft's div.c found
+// in %MSVC.NET%\crt\src\div.c
+#ifdef STATIC_IMAXDIV // [
+static
+#else // STATIC_IMAXDIV ][
+_inline
+#endif // STATIC_IMAXDIV ]
+imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
+{
+   imaxdiv_t result;
+
+   result.quot = numer / denom;
+   result.rem = numer % denom;
+
+   if (numer < 0 && result.rem > 0) {
+      // did division wrong; must fix up
+      ++result.quot;
+      result.rem -= denom;
+   }
+
+   return result;
+}
+
+// 7.8.2.3 The strtoimax and strtoumax functions
+#define strtoimax _strtoi64
+#define strtoumax _strtoui64
+
+// 7.8.2.4 The wcstoimax and wcstoumax functions
+#define wcstoimax _wcstoi64
+#define wcstoumax _wcstoui64
+
+#endif // _MSC_VER >= 1800
+
+#endif // _MSC_INTTYPES_H_ ]

slsSupportLib/include/rapidjson/msinttypes/stdint.h

@@ -0,0 +1,300 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2013 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+// The above software in this distribution may have been modified by 
+// THL A29 Limited ("Tencent Modifications"). 
+// All Tencent Modifications are Copyright (C) 2015 THL A29 Limited.
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010.
+#if _MSC_VER >= 1600 // [
+#include <stdint.h>
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+#undef INT8_C
+#undef INT16_C
+#undef INT32_C
+#undef INT64_C
+#undef UINT8_C
+#undef UINT16_C
+#undef UINT32_C
+#undef UINT64_C
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
+// Check out Issue 9 for the details.
+#ifndef INTMAX_C //   [
+#  define INTMAX_C   INT64_C
+#endif // INTMAX_C    ]
+#ifndef UINTMAX_C //  [
+#  define UINTMAX_C  UINT64_C
+#endif // UINTMAX_C   ]
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#else // ] _MSC_VER >= 1700 [
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we have to wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler would give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#if defined(__cplusplus) && !defined(_M_ARM)
+extern "C" {
+#endif
+#  include <wchar.h>
+#if defined(__cplusplus) && !defined(_M_ARM)
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+   typedef signed char       int8_t;
+   typedef signed short      int16_t;
+   typedef signed int        int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed __int8     int8_t;
+   typedef signed __int16    int16_t;
+   typedef signed __int32    int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+   typedef signed __int64    intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+   typedef _W64 signed int   intptr_t;
+   typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
+// Check out Issue 9 for the details.
+#ifndef INTMAX_C //   [
+#  define INTMAX_C   INT64_C
+#endif // INTMAX_C    ]
+#ifndef UINTMAX_C //  [
+#  define UINTMAX_C  UINT64_C
+#endif // UINTMAX_C   ]
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#endif // _MSC_VER >= 1600 ]
+
+#endif // _MSC_STDINT_H_ ]

slsSupportLib/include/rapidjson/ostreamwrapper.h

@@ -0,0 +1,81 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_OSTREAMWRAPPER_H_
+#define RAPIDJSON_OSTREAMWRAPPER_H_
+
+#include "stream.h"
+#include <iosfwd>
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Wrapper of \c std::basic_ostream into RapidJSON's Stream concept.
+/*!
+    The classes can be wrapped including but not limited to:
+
+    - \c std::ostringstream
+    - \c std::stringstream
+    - \c std::wpstringstream
+    - \c std::wstringstream
+    - \c std::ifstream
+    - \c std::fstream
+    - \c std::wofstream
+    - \c std::wfstream
+
+    \tparam StreamType Class derived from \c std::basic_ostream.
+*/
+   
+template <typename StreamType>
+class BasicOStreamWrapper {
+public:
+    typedef typename StreamType::char_type Ch;
+    BasicOStreamWrapper(StreamType& stream) : stream_(stream) {}
+
+    void Put(Ch c) {
+        stream_.put(c);
+    }
+
+    void Flush() {
+        stream_.flush();
+    }
+
+    // Not implemented
+    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
+    char Take() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
+    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
+
+private:
+    BasicOStreamWrapper(const BasicOStreamWrapper&);
+    BasicOStreamWrapper& operator=(const BasicOStreamWrapper&);
+
+    StreamType& stream_;
+};
+
+typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
+typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_OSTREAMWRAPPER_H_

slsSupportLib/include/rapidjson/prettywriter.h

@@ -0,0 +1,255 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_PRETTYWRITER_H_
+#define RAPIDJSON_PRETTYWRITER_H_
+
+#include "writer.h"
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(effc++)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Combination of PrettyWriter format flags.
+/*! \see PrettyWriter::SetFormatOptions
+ */
+enum PrettyFormatOptions {
+    kFormatDefault = 0,         //!< Default pretty formatting.
+    kFormatSingleLineArray = 1  //!< Format arrays on a single line.
+};
+
+//! Writer with indentation and spacing.
+/*!
+    \tparam OutputStream Type of ouptut os.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> {
+public:
+    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator> Base;
+    typedef typename Base::Ch Ch;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param allocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
+        Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}
+
+
+    explicit PrettyWriter(StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
+        Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
+
+    //! Set custom indentation.
+    /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
+        \param indentCharCount  Number of indent characters for each indentation level.
+        \note The default indentation is 4 spaces.
+    */
+    PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
+        RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
+        indentChar_ = indentChar;
+        indentCharCount_ = indentCharCount;
+        return *this;
+    }
+
+    //! Set pretty writer formatting options.
+    /*! \param options Formatting options.
+    */
+    PrettyWriter& SetFormatOptions(PrettyFormatOptions options) {
+        formatOptions_ = options;
+        return *this;
+    }
+
+    /*! @name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()                 { PrettyPrefix(kNullType);   return Base::WriteNull(); }
+    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
+    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
+    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
+    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
+    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::WriteUint64(u64);  }
+    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
+
+    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        PrettyPrefix(kNumberType);
+        return Base::WriteString(str, length);
+    }
+
+    bool String(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        PrettyPrefix(kStringType);
+        return Base::WriteString(str, length);
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch>& str) {
+        return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject() {
+        PrettyPrefix(kObjectType);
+        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
+        return Base::WriteStartObject();
+    }
+
+    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool Key(const std::basic_string<Ch>& str) {
+        return Key(str.data(), SizeType(str.size()));
+    }
+#endif
+	
+    bool EndObject(SizeType memberCount = 0) {
+        (void)memberCount;
+        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
+        RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray);
+        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
+
+        if (!empty) {
+            Base::os_->Put('\n');
+            WriteIndent();
+        }
+        bool ret = Base::WriteEndObject();
+        (void)ret;
+        RAPIDJSON_ASSERT(ret == true);
+        if (Base::level_stack_.Empty()) // end of json text
+            Base::os_->Flush();
+        return true;
+    }
+
+    bool StartArray() {
+        PrettyPrefix(kArrayType);
+        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
+        return Base::WriteStartArray();
+    }
+
+    bool EndArray(SizeType memberCount = 0) {
+        (void)memberCount;
+        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
+        RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
+        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
+
+        if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
+            Base::os_->Put('\n');
+            WriteIndent();
+        }
+        bool ret = Base::WriteEndArray();
+        (void)ret;
+        RAPIDJSON_ASSERT(ret == true);
+        if (Base::level_stack_.Empty()) // end of json text
+            Base::os_->Flush();
+        return true;
+    }
+
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
+    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+        \note When using PrettyWriter::RawValue(), the result json may not be indented correctly.
+    */
+    bool RawValue(const Ch* json, size_t length, Type type) { PrettyPrefix(type); return Base::WriteRawValue(json, length); }
+
+protected:
+    void PrettyPrefix(Type type) {
+        (void)type;
+        if (Base::level_stack_.GetSize() != 0) { // this value is not at root
+            typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();
+
+            if (level->inArray) {
+                if (level->valueCount > 0) {
+                    Base::os_->Put(','); // add comma if it is not the first element in array
+                    if (formatOptions_ & kFormatSingleLineArray)
+                        Base::os_->Put(' ');
+                }
+
+                if (!(formatOptions_ & kFormatSingleLineArray)) {
+                    Base::os_->Put('\n');
+                    WriteIndent();
+                }
+            }
+            else {  // in object
+                if (level->valueCount > 0) {
+                    if (level->valueCount % 2 == 0) {
+                        Base::os_->Put(',');
+                        Base::os_->Put('\n');
+                    }
+                    else {
+                        Base::os_->Put(':');
+                        Base::os_->Put(' ');
+                    }
+                }
+                else
+                    Base::os_->Put('\n');
+
+                if (level->valueCount % 2 == 0)
+                    WriteIndent();
+            }
+            if (!level->inArray && level->valueCount % 2 == 0)
+                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
+            level->valueCount++;
+        }
+        else {
+            RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
+            Base::hasRoot_ = true;
+        }
+    }
+
+    void WriteIndent()  {
+        size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
+        PutN(*Base::os_, static_cast<typename TargetEncoding::Ch>(indentChar_), count);
+    }
+
+    Ch indentChar_;
+    unsigned indentCharCount_;
+    PrettyFormatOptions formatOptions_;
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    PrettyWriter(const PrettyWriter&);
+    PrettyWriter& operator=(const PrettyWriter&);
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef __GNUC__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_

slsSupportLib/include/rapidjson/rapidjson.h

@@ -0,0 +1,615 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_RAPIDJSON_H_
+#define RAPIDJSON_RAPIDJSON_H_
+
+/*!\file rapidjson.h
+    \brief common definitions and configuration
+    
+    \see RAPIDJSON_CONFIG
+ */
+
+/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration
+    \brief Configuration macros for library features
+
+    Some RapidJSON features are configurable to adapt the library to a wide
+    variety of platforms, environments and usage scenarios.  Most of the
+    features can be configured in terms of overriden or predefined
+    preprocessor macros at compile-time.
+
+    Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
+
+    \note These macros should be given on the compiler command-line
+          (where applicable)  to avoid inconsistent values when compiling
+          different translation units of a single application.
+ */
+
+#include <cstdlib>  // malloc(), realloc(), free(), size_t
+#include <cstring>  // memset(), memcpy(), memmove(), memcmp()
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_VERSION_STRING
+//
+// ALWAYS synchronize the following 3 macros with corresponding variables in /CMakeLists.txt.
+//
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+// token stringification
+#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)
+#define RAPIDJSON_DO_STRINGIFY(x) #x
+//!@endcond
+
+/*! \def RAPIDJSON_MAJOR_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Major version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_MINOR_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Minor version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_PATCH_VERSION
+    \ingroup RAPIDJSON_CONFIG
+    \brief Patch version of RapidJSON in integer.
+*/
+/*! \def RAPIDJSON_VERSION_STRING
+    \ingroup RAPIDJSON_CONFIG
+    \brief Version of RapidJSON in "<major>.<minor>.<patch>" string format.
+*/
+#define RAPIDJSON_MAJOR_VERSION 1
+#define RAPIDJSON_MINOR_VERSION 1
+#define RAPIDJSON_PATCH_VERSION 0
+#define RAPIDJSON_VERSION_STRING \
+    RAPIDJSON_STRINGIFY(RAPIDJSON_MAJOR_VERSION.RAPIDJSON_MINOR_VERSION.RAPIDJSON_PATCH_VERSION)
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NAMESPACE_(BEGIN|END)
+/*! \def RAPIDJSON_NAMESPACE
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace
+
+    In order to avoid symbol clashes and/or "One Definition Rule" errors
+    between multiple inclusions of (different versions of) RapidJSON in
+    a single binary, users can customize the name of the main RapidJSON
+    namespace.
+
+    In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE
+    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
+    levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref
+    RAPIDJSON_NAMESPACE_END need to be defined as well:
+
+    \code
+    // in some .cpp file
+    #define RAPIDJSON_NAMESPACE my::rapidjson
+    #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
+    #define RAPIDJSON_NAMESPACE_END   } }
+    #include "rapidjson/..."
+    \endcode
+
+    \see rapidjson
+ */
+/*! \def RAPIDJSON_NAMESPACE_BEGIN
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace (opening expression)
+    \see RAPIDJSON_NAMESPACE
+*/
+/*! \def RAPIDJSON_NAMESPACE_END
+    \ingroup RAPIDJSON_CONFIG
+    \brief   provide custom rapidjson namespace (closing expression)
+    \see RAPIDJSON_NAMESPACE
+*/
+#ifndef RAPIDJSON_NAMESPACE
+#define RAPIDJSON_NAMESPACE rapidjson
+#endif
+#ifndef RAPIDJSON_NAMESPACE_BEGIN
+#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {
+#endif
+#ifndef RAPIDJSON_NAMESPACE_END
+#define RAPIDJSON_NAMESPACE_END }
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_HAS_STDSTRING
+
+#ifndef RAPIDJSON_HAS_STDSTRING
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
+#else
+#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
+#endif
+/*! \def RAPIDJSON_HAS_STDSTRING
+    \ingroup RAPIDJSON_CONFIG
+    \brief Enable RapidJSON support for \c std::string
+
+    By defining this preprocessor symbol to \c 1, several convenience functions for using
+    \ref rapidjson::GenericValue with \c std::string are enabled, especially
+    for construction and comparison.
+
+    \hideinitializer
+*/
+#endif // !defined(RAPIDJSON_HAS_STDSTRING)
+
+#if RAPIDJSON_HAS_STDSTRING
+#include <string>
+#endif // RAPIDJSON_HAS_STDSTRING
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NO_INT64DEFINE
+
+/*! \def RAPIDJSON_NO_INT64DEFINE
+    \ingroup RAPIDJSON_CONFIG
+    \brief Use external 64-bit integer types.
+
+    RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
+    to be available at global scope.
+
+    If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to
+    prevent RapidJSON from defining its own types.
+*/
+#ifndef RAPIDJSON_NO_INT64DEFINE
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#if defined(_MSC_VER) && (_MSC_VER < 1800)	// Visual Studio 2013
+#include "msinttypes/stdint.h"
+#include "msinttypes/inttypes.h"
+#else
+// Other compilers should have this.
+#include <stdint.h>
+#include <inttypes.h>
+#endif
+//!@endcond
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_NO_INT64DEFINE
+#endif
+#endif // RAPIDJSON_NO_INT64TYPEDEF
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_FORCEINLINE
+
+#ifndef RAPIDJSON_FORCEINLINE
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#if defined(_MSC_VER) && defined(NDEBUG)
+#define RAPIDJSON_FORCEINLINE __forceinline
+#elif defined(__GNUC__) && __GNUC__ >= 4 && defined(NDEBUG)
+#define RAPIDJSON_FORCEINLINE __attribute__((always_inline))
+#else
+#define RAPIDJSON_FORCEINLINE
+#endif
+//!@endcond
+#endif // RAPIDJSON_FORCEINLINE
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ENDIAN
+#define RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
+#define RAPIDJSON_BIGENDIAN     1   //!< Big endian machine
+
+//! Endianness of the machine.
+/*!
+    \def RAPIDJSON_ENDIAN
+    \ingroup RAPIDJSON_CONFIG
+
+    GCC 4.6 provided macro for detecting endianness of the target machine. But other
+    compilers may not have this. User can define RAPIDJSON_ENDIAN to either
+    \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN.
+
+    Default detection implemented with reference to
+    \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
+    \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
+*/
+#ifndef RAPIDJSON_ENDIAN
+// Detect with GCC 4.6's macro
+#  ifdef __BYTE_ORDER__
+#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#    else
+#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+#    endif // __BYTE_ORDER__
+// Detect with GLIBC's endian.h
+#  elif defined(__GLIBC__)
+#    include <endian.h>
+#    if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#    elif (__BYTE_ORDER == __BIG_ENDIAN)
+#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#    else
+#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
+#   endif // __GLIBC__
+// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
+#  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+// Detect with architecture macros
+#  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
+#  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(_MSC_VER) && defined(_M_ARM)
+#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
+#  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
+#    define RAPIDJSON_ENDIAN
+#  else
+#    error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.   
+#  endif
+#endif // RAPIDJSON_ENDIAN
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_64BIT
+
+//! Whether using 64-bit architecture
+#ifndef RAPIDJSON_64BIT
+#if defined(__LP64__) || (defined(__x86_64__) && defined(__ILP32__)) || defined(_WIN64) || defined(__EMSCRIPTEN__)
+#define RAPIDJSON_64BIT 1
+#else
+#define RAPIDJSON_64BIT 0
+#endif
+#endif // RAPIDJSON_64BIT
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ALIGN
+
+//! Data alignment of the machine.
+/*! \ingroup RAPIDJSON_CONFIG
+    \param x pointer to align
+
+    Some machines require strict data alignment. Currently the default uses 4 bytes
+    alignment on 32-bit platforms and 8 bytes alignment for 64-bit platforms.
+    User can customize by defining the RAPIDJSON_ALIGN function macro.
+*/
+#ifndef RAPIDJSON_ALIGN
+#if RAPIDJSON_64BIT == 1
+#define RAPIDJSON_ALIGN(x) (((x) + static_cast<uint64_t>(7u)) & ~static_cast<uint64_t>(7u))
+#else
+#define RAPIDJSON_ALIGN(x) (((x) + 3u) & ~3u)
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_UINT64_C2
+
+//! Construct a 64-bit literal by a pair of 32-bit integer.
+/*!
+    64-bit literal with or without ULL suffix is prone to compiler warnings.
+    UINT64_C() is C macro which cause compilation problems.
+    Use this macro to define 64-bit constants by a pair of 32-bit integer.
+*/
+#ifndef RAPIDJSON_UINT64_C2
+#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+//! Use only lower 48-bit address for some pointers.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+
+    This optimization uses the fact that current X86-64 architecture only implement lower 48-bit virtual address.
+    The higher 16-bit can be used for storing other data.
+    \c GenericValue uses this optimization to reduce its size form 24 bytes to 16 bytes in 64-bit architecture.
+*/
+#ifndef RAPIDJSON_48BITPOINTER_OPTIMIZATION
+#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_X64) || defined(_M_AMD64)
+#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 1
+#else
+#define RAPIDJSON_48BITPOINTER_OPTIMIZATION 0
+#endif
+#endif // RAPIDJSON_48BITPOINTER_OPTIMIZATION
+
+#if RAPIDJSON_48BITPOINTER_OPTIMIZATION == 1
+#if RAPIDJSON_64BIT != 1
+#error RAPIDJSON_48BITPOINTER_OPTIMIZATION can only be set to 1 when RAPIDJSON_64BIT=1
+#endif
+#define RAPIDJSON_SETPOINTER(type, p, x) (p = reinterpret_cast<type *>((reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0xFFFF0000, 0x00000000))) | reinterpret_cast<uintptr_t>(reinterpret_cast<const void*>(x))))
+#define RAPIDJSON_GETPOINTER(type, p) (reinterpret_cast<type *>(reinterpret_cast<uintptr_t>(p) & static_cast<uintptr_t>(RAPIDJSON_UINT64_C2(0x0000FFFF, 0xFFFFFFFF))))
+#else
+#define RAPIDJSON_SETPOINTER(type, p, x) (p = (x))
+#define RAPIDJSON_GETPOINTER(type, p) (p)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_SIMD
+
+/*! \def RAPIDJSON_SIMD
+    \ingroup RAPIDJSON_CONFIG
+    \brief Enable SSE2/SSE4.2 optimization.
+
+    RapidJSON supports optimized implementations for some parsing operations
+    based on the SSE2 or SSE4.2 SIMD extensions on modern Intel-compatible
+    processors.
+
+    To enable these optimizations, two different symbols can be defined;
+    \code
+    // Enable SSE2 optimization.
+    #define RAPIDJSON_SSE2
+
+    // Enable SSE4.2 optimization.
+    #define RAPIDJSON_SSE42
+    \endcode
+
+    \c RAPIDJSON_SSE42 takes precedence, if both are defined.
+
+    If any of these symbols is defined, RapidJSON defines the macro
+    \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
+*/
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
+    || defined(RAPIDJSON_DOXYGEN_RUNNING)
+#define RAPIDJSON_SIMD
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_NO_SIZETYPEDEFINE
+
+#ifndef RAPIDJSON_NO_SIZETYPEDEFINE
+/*! \def RAPIDJSON_NO_SIZETYPEDEFINE
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-provided \c SizeType definition.
+
+    In order to avoid using 32-bit size types for indexing strings and arrays,
+    define this preprocessor symbol and provide the type rapidjson::SizeType
+    before including RapidJSON:
+    \code
+    #define RAPIDJSON_NO_SIZETYPEDEFINE
+    namespace rapidjson { typedef ::std::size_t SizeType; }
+    #include "rapidjson/..."
+    \endcode
+
+    \see rapidjson::SizeType
+*/
+#ifdef RAPIDJSON_DOXYGEN_RUNNING
+#define RAPIDJSON_NO_SIZETYPEDEFINE
+#endif
+RAPIDJSON_NAMESPACE_BEGIN
+//! Size type (for string lengths, array sizes, etc.)
+/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
+    instead of using \c size_t. Users may override the SizeType by defining
+    \ref RAPIDJSON_NO_SIZETYPEDEFINE.
+*/
+typedef unsigned SizeType;
+RAPIDJSON_NAMESPACE_END
+#endif
+
+// always import std::size_t to rapidjson namespace
+RAPIDJSON_NAMESPACE_BEGIN
+using std::size_t;
+RAPIDJSON_NAMESPACE_END
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_ASSERT
+
+//! Assertion.
+/*! \ingroup RAPIDJSON_CONFIG
+    By default, rapidjson uses C \c assert() for internal assertions.
+    User can override it by defining RAPIDJSON_ASSERT(x) macro.
+
+    \note Parsing errors are handled and can be customized by the
+          \ref RAPIDJSON_ERRORS APIs.
+*/
+#ifndef RAPIDJSON_ASSERT
+#include <cassert>
+#define RAPIDJSON_ASSERT(x) assert(x)
+#endif // RAPIDJSON_ASSERT
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_STATIC_ASSERT
+
+// Adopt from boost
+#ifndef RAPIDJSON_STATIC_ASSERT
+#ifndef __clang__
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+#endif
+RAPIDJSON_NAMESPACE_BEGIN
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
+template<int x> struct StaticAssertTest {};
+RAPIDJSON_NAMESPACE_END
+
+#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)
+#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)
+#define RAPIDJSON_DO_JOIN2(X, Y) X##Y
+
+#if defined(__GNUC__)
+#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
+#else
+#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 
+#endif
+#ifndef __clang__
+//!@endcond
+#endif
+
+/*! \def RAPIDJSON_STATIC_ASSERT
+    \brief (Internal) macro to check for conditions at compile-time
+    \param x compile-time condition
+    \hideinitializer
+ */
+#define RAPIDJSON_STATIC_ASSERT(x) \
+    typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
+      sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
+    RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_LIKELY, RAPIDJSON_UNLIKELY
+
+//! Compiler branching hint for expression with high probability to be true.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+    \param x Boolean expression likely to be true.
+*/
+#ifndef RAPIDJSON_LIKELY
+#if defined(__GNUC__) || defined(__clang__)
+#define RAPIDJSON_LIKELY(x) __builtin_expect(!!(x), 1)
+#else
+#define RAPIDJSON_LIKELY(x) (x)
+#endif
+#endif
+
+//! Compiler branching hint for expression with low probability to be true.
+/*!
+    \ingroup RAPIDJSON_CONFIG
+    \param x Boolean expression unlikely to be true.
+*/
+#ifndef RAPIDJSON_UNLIKELY
+#if defined(__GNUC__) || defined(__clang__)
+#define RAPIDJSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define RAPIDJSON_UNLIKELY(x) (x)
+#endif
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Helpers
+
+//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
+
+#define RAPIDJSON_MULTILINEMACRO_BEGIN do {  
+#define RAPIDJSON_MULTILINEMACRO_END \
+} while((void)0, 0)
+
+// adopted from Boost
+#define RAPIDJSON_VERSION_CODE(x,y,z) \
+  (((x)*100000) + ((y)*100) + (z))
+
+///////////////////////////////////////////////////////////////////////////////
+// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
+
+#if defined(__GNUC__)
+#define RAPIDJSON_GNUC \
+    RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
+#endif
+
+#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
+
+#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
+#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
+#define RAPIDJSON_DIAG_OFF(x) \
+    RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
+
+// push/pop support in Clang and GCC>=4.6
+#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
+#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
+#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
+#else // GCC >= 4.2, < 4.6
+#define RAPIDJSON_DIAG_PUSH /* ignored */
+#define RAPIDJSON_DIAG_POP /* ignored */
+#endif
+
+#elif defined(_MSC_VER)
+
+// pragma (MSVC specific)
+#define RAPIDJSON_PRAGMA(x) __pragma(x)
+#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
+
+#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
+#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
+#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
+
+#else
+
+#define RAPIDJSON_DIAG_OFF(x) /* ignored */
+#define RAPIDJSON_DIAG_PUSH   /* ignored */
+#define RAPIDJSON_DIAG_POP    /* ignored */
+
+#endif // RAPIDJSON_DIAG_*
+
+///////////////////////////////////////////////////////////////////////////////
+// C++11 features
+
+#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#if defined(__clang__)
+#if __has_feature(cxx_rvalue_references) && \
+    (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
+#else
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
+#endif
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+      (defined(_MSC_VER) && _MSC_VER >= 1600)
+
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
+#else
+#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
+#endif
+#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
+
+#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
+#if defined(__clang__)
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
+//    (defined(_MSC_VER) && _MSC_VER >= ????) // not yet supported
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
+#else
+#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
+#endif
+#endif
+#if RAPIDJSON_HAS_CXX11_NOEXCEPT
+#define RAPIDJSON_NOEXCEPT noexcept
+#else
+#define RAPIDJSON_NOEXCEPT /* noexcept */
+#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
+
+// no automatic detection, yet
+#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
+#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
+#endif
+
+#ifndef RAPIDJSON_HAS_CXX11_RANGE_FOR
+#if defined(__clang__)
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR __has_feature(cxx_range_for)
+#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
+      (defined(_MSC_VER) && _MSC_VER >= 1700)
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR 1
+#else
+#define RAPIDJSON_HAS_CXX11_RANGE_FOR 0
+#endif
+#endif // RAPIDJSON_HAS_CXX11_RANGE_FOR
+
+//!@endcond
+
+///////////////////////////////////////////////////////////////////////////////
+// new/delete
+
+#ifndef RAPIDJSON_NEW
+///! customization point for global \c new
+#define RAPIDJSON_NEW(x) new x
+#endif
+#ifndef RAPIDJSON_DELETE
+///! customization point for global \c delete
+#define RAPIDJSON_DELETE(x) delete x
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Type
+
+/*! \namespace rapidjson
+    \brief main RapidJSON namespace
+    \see RAPIDJSON_NAMESPACE
+*/
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Type of JSON value
+enum Type {
+    kNullType = 0,      //!< null
+    kFalseType = 1,     //!< false
+    kTrueType = 2,      //!< true
+    kObjectType = 3,    //!< object
+    kArrayType = 4,     //!< array 
+    kStringType = 5,    //!< string
+    kNumberType = 6     //!< number
+};
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_RAPIDJSON_H_

slsSupportLib/include/rapidjson/stream.h

@@ -0,0 +1,179 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#include "rapidjson.h"
+
+#ifndef RAPIDJSON_STREAM_H_
+#define RAPIDJSON_STREAM_H_
+
+#include "encodings.h"
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//  Stream
+
+/*! \class rapidjson::Stream
+    \brief Concept for reading and writing characters.
+
+    For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
+
+    For write-only stream, only need to implement Put() and Flush().
+
+\code
+concept Stream {
+    typename Ch;    //!< Character type of the stream.
+
+    //! Read the current character from stream without moving the read cursor.
+    Ch Peek() const;
+
+    //! Read the current character from stream and moving the read cursor to next character.
+    Ch Take();
+
+    //! Get the current read cursor.
+    //! \return Number of characters read from start.
+    size_t Tell();
+
+    //! Begin writing operation at the current read pointer.
+    //! \return The begin writer pointer.
+    Ch* PutBegin();
+
+    //! Write a character.
+    void Put(Ch c);
+
+    //! Flush the buffer.
+    void Flush();
+
+    //! End the writing operation.
+    //! \param begin The begin write pointer returned by PutBegin().
+    //! \return Number of characters written.
+    size_t PutEnd(Ch* begin);
+}
+\endcode
+*/
+
+//! Provides additional information for stream.
+/*!
+    By using traits pattern, this type provides a default configuration for stream.
+    For custom stream, this type can be specialized for other configuration.
+    See TEST(Reader, CustomStringStream) in readertest.cpp for example.
+*/
+template<typename Stream>
+struct StreamTraits {
+    //! Whether to make local copy of stream for optimization during parsing.
+    /*!
+        By default, for safety, streams do not use local copy optimization.
+        Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
+    */
+    enum { copyOptimization = 0 };
+};
+
+//! Reserve n characters for writing to a stream.
+template<typename Stream>
+inline void PutReserve(Stream& stream, size_t count) {
+    (void)stream;
+    (void)count;
+}
+
+//! Write character to a stream, presuming buffer is reserved.
+template<typename Stream>
+inline void PutUnsafe(Stream& stream, typename Stream::Ch c) {
+    stream.Put(c);
+}
+
+//! Put N copies of a character to a stream.
+template<typename Stream, typename Ch>
+inline void PutN(Stream& stream, Ch c, size_t n) {
+    PutReserve(stream, n);
+    for (size_t i = 0; i < n; i++)
+        PutUnsafe(stream, c);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// StringStream
+
+//! Read-only string stream.
+/*! \note implements Stream concept
+*/
+template <typename Encoding>
+struct GenericStringStream {
+    typedef typename Encoding::Ch Ch;
+
+    GenericStringStream(const Ch *src) : src_(src), head_(src) {}
+
+    Ch Peek() const { return *src_; }
+    Ch Take() { return *src_++; }
+    size_t Tell() const { return static_cast<size_t>(src_ - head_); }
+
+    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
+    void Put(Ch) { RAPIDJSON_ASSERT(false); }
+    void Flush() { RAPIDJSON_ASSERT(false); }
+    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
+
+    const Ch* src_;     //!< Current read position.
+    const Ch* head_;    //!< Original head of the string.
+};
+
+template <typename Encoding>
+struct StreamTraits<GenericStringStream<Encoding> > {
+    enum { copyOptimization = 1 };
+};
+
+//! String stream with UTF8 encoding.
+typedef GenericStringStream<UTF8<> > StringStream;
+
+///////////////////////////////////////////////////////////////////////////////
+// InsituStringStream
+
+//! A read-write string stream.
+/*! This string stream is particularly designed for in-situ parsing.
+    \note implements Stream concept
+*/
+template <typename Encoding>
+struct GenericInsituStringStream {
+    typedef typename Encoding::Ch Ch;
+
+    GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
+
+    // Read
+    Ch Peek() { return *src_; }
+    Ch Take() { return *src_++; }
+    size_t Tell() { return static_cast<size_t>(src_ - head_); }
+
+    // Write
+    void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
+
+    Ch* PutBegin() { return dst_ = src_; }
+    size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
+    void Flush() {}
+
+    Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
+    void Pop(size_t count) { dst_ -= count; }
+
+    Ch* src_;
+    Ch* dst_;
+    Ch* head_;
+};
+
+template <typename Encoding>
+struct StreamTraits<GenericInsituStringStream<Encoding> > {
+    enum { copyOptimization = 1 };
+};
+
+//! Insitu string stream with UTF8 encoding.
+typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
+
+RAPIDJSON_NAMESPACE_END
+
+#endif // RAPIDJSON_STREAM_H_

slsSupportLib/include/rapidjson/stringbuffer.h

@@ -0,0 +1,117 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_STRINGBUFFER_H_
+#define RAPIDJSON_STRINGBUFFER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+#include <utility> // std::move
+#endif
+
+#include "internal/stack.h"
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(c++98-compat)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+//! Represents an in-memory output stream.
+/*!
+    \tparam Encoding Encoding of the stream.
+    \tparam Allocator type for allocating memory buffer.
+    \note implements Stream concept
+*/
+template <typename Encoding, typename Allocator = CrtAllocator>
+class GenericStringBuffer {
+public:
+    typedef typename Encoding::Ch Ch;
+
+    GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
+
+#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
+    GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
+    GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {
+        if (&rhs != this)
+            stack_ = std::move(rhs.stack_);
+        return *this;
+    }
+#endif
+
+    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
+    void PutUnsafe(Ch c) { *stack_.template PushUnsafe<Ch>() = c; }
+    void Flush() {}
+
+    void Clear() { stack_.Clear(); }
+    void ShrinkToFit() {
+        // Push and pop a null terminator. This is safe.
+        *stack_.template Push<Ch>() = '\0';
+        stack_.ShrinkToFit();
+        stack_.template Pop<Ch>(1);
+    }
+
+    void Reserve(size_t count) { stack_.template Reserve<Ch>(count); }
+    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
+    Ch* PushUnsafe(size_t count) { return stack_.template PushUnsafe<Ch>(count); }
+    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
+
+    const Ch* GetString() const {
+        // Push and pop a null terminator. This is safe.
+        *stack_.template Push<Ch>() = '\0';
+        stack_.template Pop<Ch>(1);
+
+        return stack_.template Bottom<Ch>();
+    }
+
+    size_t GetSize() const { return stack_.GetSize(); }
+
+    static const size_t kDefaultCapacity = 256;
+    mutable internal::Stack<Allocator> stack_;
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    GenericStringBuffer(const GenericStringBuffer&);
+    GenericStringBuffer& operator=(const GenericStringBuffer&);
+};
+
+//! String buffer with UTF8 encoding
+typedef GenericStringBuffer<UTF8<> > StringBuffer;
+
+template<typename Encoding, typename Allocator>
+inline void PutReserve(GenericStringBuffer<Encoding, Allocator>& stream, size_t count) {
+    stream.Reserve(count);
+}
+
+template<typename Encoding, typename Allocator>
+inline void PutUnsafe(GenericStringBuffer<Encoding, Allocator>& stream, typename Encoding::Ch c) {
+    stream.PutUnsafe(c);
+}
+
+//! Implement specialized version of PutN() with memset() for better performance.
+template<>
+inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
+    std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
+}
+
+RAPIDJSON_NAMESPACE_END
+
+#if defined(__clang__)
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_STRINGBUFFER_H_

slsSupportLib/include/rapidjson/writer.h

@@ -0,0 +1,610 @@
+// Tencent is pleased to support the open source community by making RapidJSON available.
+// 
+// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved.
+//
+// Licensed under the MIT License (the "License"); you may not use this file except
+// in compliance with the License. You may obtain a copy of the License at
+//
+// http://opensource.org/licenses/MIT
+//
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+
+#ifndef RAPIDJSON_WRITER_H_
+#define RAPIDJSON_WRITER_H_
+
+#include "stream.h"
+#include "internal/stack.h"
+#include "internal/strfunc.h"
+#include "internal/dtoa.h"
+#include "internal/itoa.h"
+#include "stringbuffer.h"
+#include <new>      // placement new
+
+#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
+#include <intrin.h>
+#pragma intrinsic(_BitScanForward)
+#endif
+#ifdef RAPIDJSON_SSE42
+#include <nmmintrin.h>
+#elif defined(RAPIDJSON_SSE2)
+#include <emmintrin.h>
+#endif
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_PUSH
+RAPIDJSON_DIAG_OFF(padded)
+RAPIDJSON_DIAG_OFF(unreachable-code)
+#endif
+
+RAPIDJSON_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+// WriteFlag
+
+/*! \def RAPIDJSON_WRITE_DEFAULT_FLAGS 
+    \ingroup RAPIDJSON_CONFIG
+    \brief User-defined kWriteDefaultFlags definition.
+
+    User can define this as any \c WriteFlag combinations.
+*/
+#ifndef RAPIDJSON_WRITE_DEFAULT_FLAGS
+#define RAPIDJSON_WRITE_DEFAULT_FLAGS kWriteNoFlags
+#endif
+
+//! Combination of writeFlags
+enum WriteFlag {
+    kWriteNoFlags = 0,              //!< No flags are set.
+    kWriteValidateEncodingFlag = 1, //!< Validate encoding of JSON strings.
+    kWriteNanAndInfFlag = 2,        //!< Allow writing of Infinity, -Infinity and NaN.
+    kWriteDefaultFlags = RAPIDJSON_WRITE_DEFAULT_FLAGS  //!< Default write flags. Can be customized by defining RAPIDJSON_WRITE_DEFAULT_FLAGS
+};
+
+//! JSON writer
+/*! Writer implements the concept Handler.
+    It generates JSON text by events to an output os.
+
+    User may programmatically calls the functions of a writer to generate JSON text.
+
+    On the other side, a writer can also be passed to objects that generates events, 
+
+    for example Reader::Parse() and Document::Accept().
+
+    \tparam OutputStream Type of output stream.
+    \tparam SourceEncoding Encoding of source string.
+    \tparam TargetEncoding Encoding of output stream.
+    \tparam StackAllocator Type of allocator for allocating memory of stack.
+    \note implements Handler concept
+*/
+template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
+class Writer {
+public:
+    typedef typename SourceEncoding::Ch Ch;
+
+    static const int kDefaultMaxDecimalPlaces = 324;
+
+    //! Constructor
+    /*! \param os Output stream.
+        \param stackAllocator User supplied allocator. If it is null, it will create a private one.
+        \param levelDepth Initial capacity of stack.
+    */
+    explicit
+    Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : 
+        os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
+
+    explicit
+    Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
+        os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), maxDecimalPlaces_(kDefaultMaxDecimalPlaces), hasRoot_(false) {}
+
+    //! Reset the writer with a new stream.
+    /*!
+        This function reset the writer with a new stream and default settings,
+        in order to make a Writer object reusable for output multiple JSONs.
+
+        \param os New output stream.
+        \code
+        Writer<OutputStream> writer(os1);
+        writer.StartObject();
+        // ...
+        writer.EndObject();
+
+        writer.Reset(os2);
+        writer.StartObject();
+        // ...
+        writer.EndObject();
+        \endcode
+    */
+    void Reset(OutputStream& os) {
+        os_ = &os;
+        hasRoot_ = false;
+        level_stack_.Clear();
+    }
+
+    //! Checks whether the output is a complete JSON.
+    /*!
+        A complete JSON has a complete root object or array.
+    */
+    bool IsComplete() const {
+        return hasRoot_ && level_stack_.Empty();
+    }
+
+    int GetMaxDecimalPlaces() const {
+        return maxDecimalPlaces_;
+    }
+
+    //! Sets the maximum number of decimal places for double output.
+    /*!
+        This setting truncates the output with specified number of decimal places.
+
+        For example, 
+
+        \code
+        writer.SetMaxDecimalPlaces(3);
+        writer.StartArray();
+        writer.Double(0.12345);                 // "0.123"
+        writer.Double(0.0001);                  // "0.0"
+        writer.Double(1.234567890123456e30);    // "1.234567890123456e30" (do not truncate significand for positive exponent)
+        writer.Double(1.23e-4);                 // "0.0"                  (do truncate significand for negative exponent)
+        writer.EndArray();
+        \endcode
+
+        The default setting does not truncate any decimal places. You can restore to this setting by calling
+        \code
+        writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);
+        \endcode
+    */
+    void SetMaxDecimalPlaces(int maxDecimalPlaces) {
+        maxDecimalPlaces_ = maxDecimalPlaces;
+    }
+
+    /*!@name Implementation of Handler
+        \see Handler
+    */
+    //@{
+
+    bool Null()                 { Prefix(kNullType);   return EndValue(WriteNull()); }
+    bool Bool(bool b)           { Prefix(b ? kTrueType : kFalseType); return EndValue(WriteBool(b)); }
+    bool Int(int i)             { Prefix(kNumberType); return EndValue(WriteInt(i)); }
+    bool Uint(unsigned u)       { Prefix(kNumberType); return EndValue(WriteUint(u)); }
+    bool Int64(int64_t i64)     { Prefix(kNumberType); return EndValue(WriteInt64(i64)); }
+    bool Uint64(uint64_t u64)   { Prefix(kNumberType); return EndValue(WriteUint64(u64)); }
+
+    //! Writes the given \c double value to the stream
+    /*!
+        \param d The value to be written.
+        \return Whether it is succeed.
+    */
+    bool Double(double d)       { Prefix(kNumberType); return EndValue(WriteDouble(d)); }
+
+    bool RawNumber(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        Prefix(kNumberType);
+        return EndValue(WriteString(str, length));
+    }
+
+    bool String(const Ch* str, SizeType length, bool copy = false) {
+        (void)copy;
+        Prefix(kStringType);
+        return EndValue(WriteString(str, length));
+    }
+
+#if RAPIDJSON_HAS_STDSTRING
+    bool String(const std::basic_string<Ch>& str) {
+        return String(str.data(), SizeType(str.size()));
+    }
+#endif
+
+    bool StartObject() {
+        Prefix(kObjectType);
+        new (level_stack_.template Push<Level>()) Level(false);
+        return WriteStartObject();
+    }
+
+    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
+
+    bool EndObject(SizeType memberCount = 0) {
+        (void)memberCount;
+        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
+        RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray);
+        level_stack_.template Pop<Level>(1);
+        return EndValue(WriteEndObject());
+    }
+
+    bool StartArray() {
+        Prefix(kArrayType);
+        new (level_stack_.template Push<Level>()) Level(true);
+        return WriteStartArray();
+    }
+
+    bool EndArray(SizeType elementCount = 0) {
+        (void)elementCount;
+        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
+        RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
+        level_stack_.template Pop<Level>(1);
+        return EndValue(WriteEndArray());
+    }
+    //@}
+
+    /*! @name Convenience extensions */
+    //@{
+
+    //! Simpler but slower overload.
+    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
+    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
+
+    //@}
+
+    //! Write a raw JSON value.
+    /*!
+        For user to write a stringified JSON as a value.
+
+        \param json A well-formed JSON value. It should not contain null character within [0, length - 1] range.
+        \param length Length of the json.
+        \param type Type of the root of json.
+    */
+    bool RawValue(const Ch* json, size_t length, Type type) { Prefix(type); return EndValue(WriteRawValue(json, length)); }
+
+protected:
+    //! Information for each nested level
+    struct Level {
+        Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
+        size_t valueCount;  //!< number of values in this level
+        bool inArray;       //!< true if in array, otherwise in object
+    };
+
+    static const size_t kDefaultLevelDepth = 32;
+
+    bool WriteNull()  {
+        PutReserve(*os_, 4);
+        PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
+    }
+
+    bool WriteBool(bool b)  {
+        if (b) {
+            PutReserve(*os_, 4);
+            PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
+        }
+        else {
+            PutReserve(*os_, 5);
+            PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
+        }
+        return true;
+    }
+
+    bool WriteInt(int i) {
+        char buffer[11];
+        const char* end = internal::i32toa(i, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (const char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteUint(unsigned u) {
+        char buffer[10];
+        const char* end = internal::u32toa(u, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (const char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteInt64(int64_t i64) {
+        char buffer[21];
+        const char* end = internal::i64toa(i64, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (const char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteUint64(uint64_t u64) {
+        char buffer[20];
+        char* end = internal::u64toa(u64, buffer);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteDouble(double d) {
+        if (internal::Double(d).IsNanOrInf()) {
+            if (!(writeFlags & kWriteNanAndInfFlag))
+                return false;
+            if (internal::Double(d).IsNan()) {
+                PutReserve(*os_, 3);
+                PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
+                return true;
+            }
+            if (internal::Double(d).Sign()) {
+                PutReserve(*os_, 9);
+                PutUnsafe(*os_, '-');
+            }
+            else
+                PutReserve(*os_, 8);
+            PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
+            PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
+            return true;
+        }
+
+        char buffer[25];
+        char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
+        PutReserve(*os_, static_cast<size_t>(end - buffer));
+        for (char* p = buffer; p != end; ++p)
+            PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(*p));
+        return true;
+    }
+
+    bool WriteString(const Ch* str, SizeType length)  {
+        static const typename TargetEncoding::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+        static const char escape[256] = {
+#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+            //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
+            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
+            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
+              0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
+            Z16, Z16,                                                                       // 30~4F
+              0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
+            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
+#undef Z16
+        };
+
+        if (TargetEncoding::supportUnicode)
+            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
+        else
+            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."
+
+        PutUnsafe(*os_, '\"');
+        GenericStringStream<SourceEncoding> is(str);
+        while (ScanWriteUnescapedString(is, length)) {
+            const Ch c = is.Peek();
+            if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {
+                // Unicode escaping
+                unsigned codepoint;
+                if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
+                    return false;
+                PutUnsafe(*os_, '\\');
+                PutUnsafe(*os_, 'u');
+                if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
+                    PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
+                    PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
+                    PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
+                    PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
+                }
+                else {
+                    RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
+                    // Surrogate pair
+                    unsigned s = codepoint - 0x010000;
+                    unsigned lead = (s >> 10) + 0xD800;
+                    unsigned trail = (s & 0x3FF) + 0xDC00;
+                    PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
+                    PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
+                    PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
+                    PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
+                    PutUnsafe(*os_, '\\');
+                    PutUnsafe(*os_, 'u');
+                    PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
+                    PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
+                    PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
+                    PutUnsafe(*os_, hexDigits[(trail      ) & 15]);                    
+                }
+            }
+            else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))  {
+                is.Take();
+                PutUnsafe(*os_, '\\');
+                PutUnsafe(*os_, static_cast<typename TargetEncoding::Ch>(escape[static_cast<unsigned char>(c)]));
+                if (escape[static_cast<unsigned char>(c)] == 'u') {
+                    PutUnsafe(*os_, '0');
+                    PutUnsafe(*os_, '0');
+                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
+                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
+                }
+            }
+            else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
+                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
+                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
+                return false;
+        }
+        PutUnsafe(*os_, '\"');
+        return true;
+    }
+
+    bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, size_t length) {
+        return RAPIDJSON_LIKELY(is.Tell() < length);
+    }
+
+    bool WriteStartObject() { os_->Put('{'); return true; }
+    bool WriteEndObject()   { os_->Put('}'); return true; }
+    bool WriteStartArray()  { os_->Put('['); return true; }
+    bool WriteEndArray()    { os_->Put(']'); return true; }
+
+    bool WriteRawValue(const Ch* json, size_t length) {
+        PutReserve(*os_, length);
+        for (size_t i = 0; i < length; i++) {
+            RAPIDJSON_ASSERT(json[i] != '\0');
+            PutUnsafe(*os_, json[i]);
+        }
+        return true;
+    }
+
+    void Prefix(Type type) {
+        (void)type;
+        if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root
+            Level* level = level_stack_.template Top<Level>();
+            if (level->valueCount > 0) {
+                if (level->inArray) 
+                    os_->Put(','); // add comma if it is not the first element in array
+                else  // in object
+                    os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
+            }
+            if (!level->inArray && level->valueCount % 2 == 0)
+                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
+            level->valueCount++;
+        }
+        else {
+            RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
+            hasRoot_ = true;
+        }
+    }
+
+    // Flush the value if it is the top level one.
+    bool EndValue(bool ret) {
+        if (RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
+            os_->Flush();
+        return ret;
+    }
+
+    OutputStream* os_;
+    internal::Stack<StackAllocator> level_stack_;
+    int maxDecimalPlaces_;
+    bool hasRoot_;
+
+private:
+    // Prohibit copy constructor & assignment operator.
+    Writer(const Writer&);
+    Writer& operator=(const Writer&);
+};
+
+// Full specialization for StringStream to prevent memory copying
+
+template<>
+inline bool Writer<StringBuffer>::WriteInt(int i) {
+    char *buffer = os_->Push(11);
+    const char* end = internal::i32toa(i, buffer);
+    os_->Pop(static_cast<size_t>(11 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
+    char *buffer = os_->Push(10);
+    const char* end = internal::u32toa(u, buffer);
+    os_->Pop(static_cast<size_t>(10 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
+    char *buffer = os_->Push(21);
+    const char* end = internal::i64toa(i64, buffer);
+    os_->Pop(static_cast<size_t>(21 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
+    char *buffer = os_->Push(20);
+    const char* end = internal::u64toa(u, buffer);
+    os_->Pop(static_cast<size_t>(20 - (end - buffer)));
+    return true;
+}
+
+template<>
+inline bool Writer<StringBuffer>::WriteDouble(double d) {
+    if (internal::Double(d).IsNanOrInf()) {
+        // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
+        if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
+            return false;
+        if (internal::Double(d).IsNan()) {
+            PutReserve(*os_, 3);
+            PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
+            return true;
+        }
+        if (internal::Double(d).Sign()) {
+            PutReserve(*os_, 9);
+            PutUnsafe(*os_, '-');
+        }
+        else
+            PutReserve(*os_, 8);
+        PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
+        PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
+        return true;
+    }
+    
+    char *buffer = os_->Push(25);
+    char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
+    os_->Pop(static_cast<size_t>(25 - (end - buffer)));
+    return true;
+}
+
+#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
+template<>
+inline bool Writer<StringBuffer>::ScanWriteUnescapedString(StringStream& is, size_t length) {
+    if (length < 16)
+        return RAPIDJSON_LIKELY(is.Tell() < length);
+
+    if (!RAPIDJSON_LIKELY(is.Tell() < length))
+        return false;
+
+    const char* p = is.src_;
+    const char* end = is.head_ + length;
+    const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & static_cast<size_t>(~15));
+    const char* endAligned = reinterpret_cast<const char*>(reinterpret_cast<size_t>(end) & static_cast<size_t>(~15));
+    if (nextAligned > end)
+        return true;
+
+    while (p != nextAligned)
+        if (*p < 0x20 || *p == '\"' || *p == '\\') {
+            is.src_ = p;
+            return RAPIDJSON_LIKELY(is.Tell() < length);
+        }
+        else
+            os_->PutUnsafe(*p++);
+
+    // The rest of string using SIMD
+    static const char dquote[16] = { '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"', '\"' };
+    static const char bslash[16] = { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' };
+    static const char space[16]  = { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 };
+    const __m128i dq = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&dquote[0]));
+    const __m128i bs = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&bslash[0]));
+    const __m128i sp = _mm_loadu_si128(reinterpret_cast<const __m128i *>(&space[0]));
+
+    for (; p != endAligned; p += 16) {
+        const __m128i s = _mm_load_si128(reinterpret_cast<const __m128i *>(p));
+        const __m128i t1 = _mm_cmpeq_epi8(s, dq);
+        const __m128i t2 = _mm_cmpeq_epi8(s, bs);
+        const __m128i t3 = _mm_cmpeq_epi8(_mm_max_epu8(s, sp), sp); // s < 0x20 <=> max(s, 0x19) == 0x19
+        const __m128i x = _mm_or_si128(_mm_or_si128(t1, t2), t3);
+        unsigned short r = static_cast<unsigned short>(_mm_movemask_epi8(x));
+        if (RAPIDJSON_UNLIKELY(r != 0)) {   // some of characters is escaped
+            SizeType len;
+#ifdef _MSC_VER         // Find the index of first escaped
+            unsigned long offset;
+            _BitScanForward(&offset, r);
+            len = offset;
+#else
+            len = static_cast<SizeType>(__builtin_ffs(r) - 1);
+#endif
+            char* q = reinterpret_cast<char*>(os_->PushUnsafe(len));
+            for (size_t i = 0; i < len; i++)
+                q[i] = p[i];
+
+            p += len;
+            break;
+        }
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(os_->PushUnsafe(16)), s);
+    }
+
+    is.src_ = p;
+    return RAPIDJSON_LIKELY(is.Tell() < length);
+}
+#endif // defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42)
+
+RAPIDJSON_NAMESPACE_END
+
+#ifdef _MSC_VER
+RAPIDJSON_DIAG_POP
+#endif
+
+#ifdef __clang__
+RAPIDJSON_DIAG_POP
+#endif
+
+#endif // RAPIDJSON_RAPIDJSON_H_

slsSupportLib/include/sls_detector_defs.h

@@ -0,0 +1,961 @@
+#pragma once
+/************************************************
+ * @file sls_detector_defs.h
+ * @short contains all the constants, enum definitions and enum-string conversions
+ ***********************************************/
+/**
+ *@short contains all the constants, enum definitions and enum-string conversions
+ */
+
+
+#ifdef __CINT__
+#define MYROOT
+#define __cplusplus
+#endif
+
+#include <stdint.h> 
+#ifdef __cplusplus
+#include <bitset>
+#include <string>
+#endif
+#include "ansi.h"
+
+
+/** default ports */
+#define DEFAULT_PORTNO    		1952
+#define DEFAULT_UDP_PORTNO 		50001
+#define DEFAULT_GUI_PORTNO 		65001
+#define DEFAULT_ZMQ_CL_PORTNO 	30001
+#define DEFAULT_ZMQ_RX_PORTNO 	30001
+
+#define SLS_DETECTOR_HEADER_VERSION         0x2
+#define SLS_DETECTOR_JSON_HEADER_VERSION    0x3
+
+// ctb/ moench 1g udp (read from fifo)
+#define UDP_PACKET_DATA_BYTES		(1344)
+
+/** maximum rois */
+#define MAX_ROIS 100
+
+/** maximum trim en */
+#define MAX_TRIMEN 100
+
+/** maximum unit size of program sent to detector */
+#define MAX_FPGAPROGRAMSIZE (2 * 1024 *1024)
+
+/** get flag form most functions */
+#define GET_FLAG -1
+
+#define DEFAULT_DET_MAC         "00:aa:bb:cc:dd:ee"
+#define DEFAULT_DET_IP          "129.129.202.45"
+#define DEFAULT_DET_MAC2        "00:aa:bb:cc:dd:ff"
+#define DEFAULT_DET_IP2         "129.129.202.46"
+
+/** default maximum string length */
+#define MAX_STR_LENGTH 1000
+#define MAX_FRAMES_PER_FILE			20000
+#define SHORT_MAX_FRAMES_PER_FILE	100000
+#define MOENCH_MAX_FRAMES_PER_FILE	100000
+#define EIGER_MAX_FRAMES_PER_FILE	10000
+#define JFRAU_MAX_FRAMES_PER_FILE 	10000
+#define CTB_MAX_FRAMES_PER_FILE   20000
+
+#define DEFAULT_STREAMING_TIMER_IN_MS 200
+
+
+
+typedef char mystring[MAX_STR_LENGTH];
+
+
+#ifdef __cplusplus
+class slsDetectorDefs {
+public:
+	slsDetectorDefs(){};
+#endif
+
+	/**
+       Type of the detector
+	 */
+	enum detectorType {
+		GET_DETECTOR_TYPE=-1,   /**< the detector will return its type */
+		GENERIC,  /**< generic sls detector */
+		EIGER, /**< eiger */
+		GOTTHARD, /**< gotthard */
+		JUNGFRAU, /**< jungfrau */
+		CHIPTESTBOARD, /**< CTB */
+		MOENCH /**< moench */
+	};
+
+
+	/**
+      return values
+	 */
+	enum  {
+		OK, /**< function succeeded */
+		FAIL, /**< function failed */
+		FORCE_UPDATE
+	};
+
+
+	/**
+     indexes for the acquisition timers
+	 */
+	enum timerIndex {
+		FRAME_NUMBER, /**< number of real time frames: total number of acquisitions is number or frames*number of cycles */
+		ACQUISITION_TIME, /**< exposure time */
+		FRAME_PERIOD, /**< period between exposures */
+		DELAY_AFTER_TRIGGER, /**< delay between trigger and start of exposure or readout (in triggered mode) */
+		GATES_NUMBER, /**< number of gates per frame (in gated mode) */
+		CYCLES_NUMBER, /**< number of cycles: total number of acquisitions is number or frames*number of cycles */
+		ACTUAL_TIME, /**< Actual time of the detector's internal timer */
+		MEASUREMENT_TIME,  /**< Time of the measurement from the detector (fifo) */
+
+		PROGRESS, /**< fraction of measurement elapsed - only get! */
+		MEASUREMENTS_NUMBER,
+		FRAMES_FROM_START,
+		FRAMES_FROM_START_PG,
+		SAMPLES,
+		SUBFRAME_ACQUISITION_TIME, /**< subframe exposure time */
+		STORAGE_CELL_NUMBER, /**<number of storage cells */
+		SUBFRAME_DEADTIME, /**< subframe deadtime */
+		MEASURED_PERIOD,	/**< measured period */
+		MEASURED_SUBPERIOD,	/**< measured subperiod */
+		STORAGE_CELL_DELAY, /**< storage cell delay */
+		MAX_TIMERS
+	};
+
+
+	/**
+    staus mask
+	 */
+	enum runStatus {
+		IDLE, /**< detector ready to start acquisition - no data in memory */
+		ERROR, /**< error i.e. normally fifo full */
+		WAITING, /**< waiting for trigger or gate signal */
+		RUN_FINISHED, /**< acquisition not running but data in memory */
+		TRANSMITTING, /**< acquisition running and data in memory */
+		RUNNING, /**< acquisition  running, no data in memory */
+		STOPPED /**< acquisition stopped externally */
+	};
+
+
+
+	/**
+	    @short  structure for a Detector Packet or Image Header
+	    @li frameNumber is the frame number
+	    @li expLength is the subframe number (32 bit eiger) or real time exposure time in 100ns (others)
+	    @li packetNumber is the packet number
+	    @li bunchId is the bunch id from beamline
+	    @li timestamp is the time stamp with 10 MHz clock
+	    @li modId is the unique module id (unique even for left, right, top, bottom)
+	    @li row is the row index in the complete detector system
+	    @li column is the column index in the complete detector system
+	    @li reserved is reserved
+	    @li debug is for debugging purposes
+	    @li roundRNumber is the round robin set number
+	    @li detType is the detector type see :: detectorType
+	    @li version is the version number of this structure format
+	*/
+
+	typedef struct {
+		uint64_t frameNumber;			/**< is the frame number */
+		uint32_t expLength;				/**< is the subframe number (32 bit eiger) or real time exposure time in 100ns (others) */
+		uint32_t packetNumber;			/**< is the packet number */
+		uint64_t bunchId;				/**< is the bunch id from beamline */
+		uint64_t timestamp;				/**< is the time stamp with 10 MHz clock */
+		uint16_t modId;					/**< is the unique module id (unique even for left, right, top, bottom) */
+		uint16_t row;					/**< is the row index in the complete detector system */
+		uint16_t column;				/**< is the column index in the complete detector system */
+		uint16_t reserved;				/**< is reserved */
+		uint32_t debug;					/**< is for debugging purposes */
+		uint16_t roundRNumber;			/**< is the round robin set number */
+		uint8_t detType;				/**< is the detector type see :: detectorType */
+		uint8_t version;				/**< is the version number of this structure format */
+	} sls_detector_header;
+
+#ifdef __cplusplus
+#define MAX_NUM_PACKETS	512
+
+	typedef std::bitset<MAX_NUM_PACKETS> sls_bitset;
+
+	typedef struct {
+		sls_detector_header detHeader;	/**< is the detector header */
+		sls_bitset packetsMask;			/**< is the packets caught bit mask */
+	} sls_receiver_header;
+
+	typedef uint8_t bitset_storage[MAX_NUM_PACKETS/8];
+
+#endif
+	/**
+	 * frameDiscardPolicy
+	 */
+	enum frameDiscardPolicy {
+		GET_FRAME_DISCARD_POLICY = -1,	/**< to get the missing packet mode */
+		NO_DISCARD,						/**< pad incomplete packets with -1, default mode */
+		DISCARD_EMPTY_FRAMES,			/**< discard incomplete frames, fastest mode, save space, not suitable for multiple modules */
+		DISCARD_PARTIAL_FRAMES,			/**< ignore missing packets, must check with packetsMask for data integrity, fast mode and suitable for multiple modules */
+		NUM_DISCARD_POLICIES
+	};
+
+
+	/**
+    format
+     */
+	enum fileFormat {
+		GET_FILE_FORMAT=-1,/**< the receiver will return its file format */
+		BINARY, /**< binary format */
+		HDF5, /**< hdf5 format */
+		NUM_FILE_FORMATS
+	};
+
+
+	/**
+	    @short structure for a region of interest
+	    xmin,xmax,ymin,ymax define the limits of the region
+	*/
+	typedef struct {
+	  int xmin;  /**< is the roi xmin (in channel number) */
+	  int xmax;  /**< is the roi xmax  (in channel number)*/
+	  int ymin;  /**< is the roi ymin  (in channel number)*/
+	  int ymax;   /**< is the roi ymax  (in channel number)*/
+	} ROI ;
+
+	/**
+	    @short  structure for a detector module
+
+	    should not be used by unexperienced users
+
+	    \see  :: moduleRegisterBit ::chipRegisterBit :channelRegisterBit
+
+	    @li reg is the module register (e.g. dynamic range? see moduleRegisterBit)
+	    @li dacs is the pointer to the array of dac values (in V)
+	    @li adcs is the pointer to the array of adc values (in V)
+	    @li chipregs is the pointer to the array of chip registers
+	    @li chanregs is the pointer to the array of channel registers
+	    @li gain is the module gain
+	    @li offset is the module offset
+	*/
+	typedef struct {
+	  int serialnumber;  /**< is the module serial number */
+	  int nchan; /**< is the number of channels on the module*/
+	  int nchip; /**< is the number of chips on the module */
+	  int ndac; /**< is the number of dacs on the module */
+	  int reg; /**< is the module register settings (gain level) */
+	  int iodelay;	/**< iodelay */
+	  int tau;	/**< tau */
+	  int eV;	/**< threshold energy */
+	  int *dacs; /**< is the pointer to the array of the dac values (in V) */
+	  int *chanregs; /**< is the pointer to the array of the channel registers */
+	} sls_detector_module;
+
+
+	/**
+	     network parameters
+	*/
+
+	enum networkParameter {
+	  DETECTOR_MAC, 	    	/**< detector MAC */
+	  DETECTOR_IP,	 	    	/**< detector IP */
+	  RECEIVER_HOSTNAME,  		/**< receiver IP/hostname */
+	  RECEIVER_UDP_IP,			/**< receiever UDP IP */
+	  RECEIVER_UDP_PORT,		/**< receiever UDP Port */
+	  RECEIVER_UDP_MAC,			/**< receiever UDP MAC */
+	  RECEIVER_UDP_PORT2,		/**< receiever UDP Port of second half module for eiger */
+	  DETECTOR_TXN_DELAY_LEFT, 	/**< transmission delay on the (left) port for next frame */
+	  DETECTOR_TXN_DELAY_RIGHT,	/**< transmission delay on the right port for next frame  */
+	  DETECTOR_TXN_DELAY_FRAME, /**< transmission delay of a whole frame for all the ports */
+	  FLOW_CONTROL_10G,			/**< flow control for 10GbE */
+	  FLOW_CONTROL_WR_PTR,		/**< memory write pointer for flow control */
+	  FLOW_CONTROL_RD_PTR,		/**< memory read pointer for flow control */
+	  RECEIVER_STREAMING_PORT,	/**< receiever streaming TCP(ZMQ) port */
+	  CLIENT_STREAMING_PORT,	/**< client streaming TCP(ZMQ) port */
+	  RECEIVER_STREAMING_SRC_IP,/**< receiever streaming TCP(ZMQ) ip */
+	  CLIENT_STREAMING_SRC_IP,	/**< client streaming TCP(ZMQ) ip */
+	  ADDITIONAL_JSON_HEADER,    /**< additional json header (ZMQ) */
+	  RECEIVER_UDP_SCKT_BUF_SIZE, /**< UDP socket buffer size */
+	  RECEIVER_REAL_UDP_SCKT_BUF_SIZE /**< real UDP socket buffer size */
+	};
+
+	/**
+	    type of action performed (for text client)
+	*/
+	enum {GET_ACTION, PUT_ACTION, READOUT_ACTION, HELP_ACTION};
+
+	/** online flags enum \sa setOnline*/
+	enum {GET_ONLINE_FLAG=-1, /**< returns wether the detector is in online or offline state */
+	      OFFLINE_FLAG=0, /**< detector in offline state (i.e. no communication to the detector - using only local structure - no data acquisition possible!) */
+	      ONLINE_FLAG =1/**< detector in online state (i.e. communication to the detector updating the local structure) */
+	};
+
+	/**
+	     flags to get (or set) the size of the detector
+	*/
+	enum numberOf {
+	  MAXMODX, /**<maximum number of module in X direction */
+	  MAXMODY, /**<maximum number of module in Y direction */
+	  NMODX, /**<installed number of module in X direction */
+	  NMODY, /**<installed number of module in Y direction */
+	  NCHANSX, /**<number of channels in X direction */
+	  NCHANSY, /**<number of channels in Y direction */
+	  NCHIPSX, /**<number of chips in X direction */
+	  NCHIPSY /**<number of chips in Y direction */
+	};
+
+	/**
+	    dimension indexes
+	*/
+	enum dimension {
+	  X=0, /**< X dimension */
+	  Y=1 /**< Y dimension */
+	};
+
+	/**
+	   enable/disable flags
+	*/
+	enum {
+	  DISABLED, /**<flag disabled */
+	  ENABLED /**<flag enabled */
+	};
+
+
+	/**
+	  use of the external signals
+	*/
+	enum externalSignalFlag {
+	  GET_EXTERNAL_SIGNAL_FLAG=-1,  /**<return flag for signal */
+	  SIGNAL_OFF, /**<signal unused - tristate*/
+	  GATE_IN_ACTIVE_HIGH,  /**<input gate active high*/
+	  GATE_IN_ACTIVE_LOW,  /**<input gate active low */
+	  TRIGGER_IN_RISING_EDGE,  /**<input exposure trigger on rising edge */
+	  TRIGGER_IN_FALLING_EDGE, /**<input exposure trigger on falling edge */
+	  RO_TRIGGER_IN_RISING_EDGE,  /**<input raedout trigger on rising edge */
+	  RO_TRIGGER_IN_FALLING_EDGE, /**<input readout trigger on falling edge */
+	  GATE_OUT_ACTIVE_HIGH, /**<output active high when detector is exposing*/
+	  GATE_OUT_ACTIVE_LOW,  /**<output active low when detector is exposing*/
+	  TRIGGER_OUT_RISING_EDGE,  /**<output trigger rising edge at start of exposure */
+	  TRIGGER_OUT_FALLING_EDGE, /**<output trigger falling edge at start of exposure */
+	  RO_TRIGGER_OUT_RISING_EDGE,   /**<output trigger rising edge at start of readout */
+	  RO_TRIGGER_OUT_FALLING_EDGE,  /**<output trigger falling edge at start of readout */
+	  OUTPUT_LOW, /**< output always low */
+	  OUTPUT_HIGH, /**< output always high */
+	  MASTER_SLAVE_SYNCHRONIZATION /**< reserved for master/slave synchronization in multi detector systems */
+	};
+
+	/**
+	  communication mode using external signals
+	*/
+	enum externalCommunicationMode{
+	  GET_EXTERNAL_COMMUNICATION_MODE=-1,/**<return flag for communication mode */
+	  AUTO_TIMING, /**< internal timing */
+	  TRIGGER_EXPOSURE, /**< trigger mode i.e. exposure is triggered */
+	  GATED, /**< gated  */
+	  BURST_TRIGGER	/**< trigger a burst of frames */
+	};
+	/**
+	    detector IDs/versions
+	*/
+	enum idMode{
+	  DETECTOR_SERIAL_NUMBER,  /**<return detector system serial number */
+	  DETECTOR_FIRMWARE_VERSION,  /**<return detector system firmware version */
+	  DETECTOR_SOFTWARE_VERSION,   /**<return detector system software version */
+	  THIS_SOFTWARE_VERSION,  /**<return this software version */
+	  RECEIVER_VERSION,		 /**<return receiver software version */
+	  SOFTWARE_FIRMWARE_API_VERSION,		/** return software firmware API version **/
+	  CLIENT_SOFTWARE_API_VERSION,	/** return detector software and client api version */
+	  CLIENT_RECEIVER_API_VERSION /** return client and  receiver api version */
+	};
+	/**
+	    detector digital test modes
+	*/
+	enum digitalTestMode {
+	  DETECTOR_FIRMWARE_TEST,  /**< test detector system firmware */
+	  DETECTOR_BUS_TEST,  /**< test detector system CPU-FPGA bus */
+	  DIGITAL_BIT_TEST			/**< gotthard digital bit test */
+	};
+
+
+	/**
+	   detector dacs indexes
+	*/
+	enum dacIndex {
+	  THRESHOLD,    /**< comparator threshold level */
+	  CALIBRATION_PULSE,  /**< calibration input pulse height */
+	  TRIMBIT_SIZE, /**< voltage to determine the trimbits LSB */
+	  PREAMP,       /**< preamp feedback */
+	  SHAPER1,      /**< shaper1 feedback */
+	  SHAPER2,      /**< shaper2 feedback */
+	  TEMPERATURE_ADC,   /**< temperature sensor (adc) */
+	  TEMPERATURE_FPGA,  /**< temperature sensor (fpga) */
+	  HUMIDITY,     /**< humidity sensor (adc) */
+	  DETECTOR_BIAS,/**< detector bias */
+	  VA_POT,       /**< power supply va */
+	  VDD_POT,      /**< chiptest board power supply vdd */
+	  VSH_POT,      /**< chiptest board power supply vsh */
+	  VIO_POT,      /**< chiptest board power supply va */
+	  G_VREF_DS,    /**< gotthard */
+	  G_VCASCN_PB,  /**< gotthard */
+	  G_VCASCP_PB,  /**< gotthard */
+	  G_VOUT_CM,    /**< gotthard */
+	  G_VCASC_OUT,  /**< gotthard */
+	  G_VIN_CM,     /**< gotthard */
+	  G_VREF_COMP,  /**< gotthard */
+	  G_IB_TESTC,   /**< gotthard */
+	  E_SvP,		/**< eiger */
+	  E_SvN,		/**< eiger */
+	  E_Vtr,		/**< eiger */
+	  E_Vrf,		/**< eiger */
+	  E_Vrs,		/**< eiger */
+	  E_Vtgstv ,	/**< eiger */
+	  E_Vcmp_ll,	/**< eiger */
+	  E_Vcmp_lr,	/**< eiger */
+	  E_cal,		/**< eiger */
+	  E_Vcmp_rl,	/**< eiger */
+	  E_Vcmp_rr,	/**< eiger */
+	  E_rxb_rb ,	/**< eiger */
+	  E_rxb_lb,		/**< eiger */
+	  E_Vcp,		/**< eiger */
+	  E_Vcn,		/**< eiger */
+	  E_Vis,		/**< eiger */
+	  IO_DELAY,		/**< eiger io delay */
+	  ADC_VPP,		/**< adc vpp for jctb */
+	  HIGH_VOLTAGE,             /**< high voltage */
+	  TEMPERATURE_FPGAEXT,	/**< temperature sensor (close to fpga) */
+	  TEMPERATURE_10GE,		/**< temperature sensor (close to 10GE) */
+	  TEMPERATURE_DCDC,		/**< temperature sensor (close to DCDC) */
+	  TEMPERATURE_SODL,		/**< temperature sensor (close to SODL) */
+	  TEMPERATURE_SODR,		/**< temperature sensor (close to SODR) */
+	  TEMPERATURE_FPGA2, /**< temperature sensor (fpga2 (eiger:febl) */
+	  TEMPERATURE_FPGA3, /**< temperature sensor (fpga3 (eiger:febr) */
+	  M_vIpre,      /**< mythen 3 >*/
+	  M_vIbias,     /**< mythen 3 >*/
+	  M_vIinSh,     /**< mythen 3 >*/
+	  M_VdcSh,      /**< mythen 3 >*/
+	  M_Vth2,       /**< mythen 3 >*/
+	  M_VPL,        /**< mythen 3 >*/
+	  M_Vth3,       /**< mythen 3 >*/
+	  M_casSh,      /**< mythen 3 >*/
+	  M_cas,        /**< mythen 3 >*/
+	  M_vIbiasSh,   /**< mythen 3 >*/
+	  M_vIcin,      /**< mythen 3 >*/
+	  M_vIpreOut,    /**< mythen 3 >*/
+	  V_POWER_A = 100, /**new chiptest board */
+	  V_POWER_B = 101, /**new chiptest board */
+	  V_POWER_C = 102, /**new chiptest board */
+	  V_POWER_D = 103, /**new chiptest board */
+	  V_POWER_IO =104, /**new chiptest board */
+	  V_POWER_CHIP=105 ,/**new chiptest board */
+	  I_POWER_A=106 , /**new chiptest board */
+	  I_POWER_B=107 , /**new chiptest board */
+	  I_POWER_C=108 , /**new chiptest board */
+	  I_POWER_D=109 , /**new chiptest board */
+	  I_POWER_IO=110 , /**new chiptest board */
+	  V_LIMIT=111, /**new chiptest board */
+	  SLOW_ADC0=1000,
+	  SLOW_ADC1,
+	  SLOW_ADC2,
+	  SLOW_ADC3,
+	  SLOW_ADC4,
+	  SLOW_ADC5,
+	  SLOW_ADC6,
+	  SLOW_ADC7,
+	  SLOW_ADC_TEMP
+	};
+
+	/**
+	   detector settings indexes
+	*/
+	enum detectorSettings{
+	  GET_SETTINGS=-1,  /**< return current detector settings */
+	  STANDARD,         /**< standard settings */
+	  FAST,             /**< fast settings */
+	  HIGHGAIN,         /**< highgain  settings */
+	  DYNAMICGAIN,      /**< dynamic gain  settings */
+	  LOWGAIN,          /**< low gain  settings */
+	  MEDIUMGAIN,       /**< medium gain  settings */
+	  VERYHIGHGAIN,     /**< very high gain  settings */
+	  LOWNOISE,	    	/**< low noise settings */
+	  DYNAMICHG0,		/**< dynamic high gain 0 */
+	  FIXGAIN1,			/**< fix gain 1 */
+	  FIXGAIN2,			/**< fix gain 2 */
+	  FORCESWITCHG1,	/**< force switch gain 1 */
+	  FORCESWITCHG2,	/**< force switch gain 2 */
+	  VERYLOWGAIN,		/**< very low gain settings */
+	  UNDEFINED=200,    /**< undefined or custom  settings */
+	  UNINITIALIZED     /**< uninitialiazed (status at startup) */
+	};
+
+
+	#define TRIMBITMASK 0x3f
+
+
+	/**
+	  important speed parameters
+	*/
+	enum speedVariable {
+	  CLOCK_DIVIDER, /**< readout clock divider */
+	  ADC_CLOCK, /**< adc clock divider */
+	  ADC_PHASE, /**< adc clock phase */
+	  ADC_PIPELINE, /**< adc pipeline */
+	  DBIT_CLOCK, /**< adc clock divider */
+	  DBIT_PHASE, /**< adc clock phase */
+	  DBIT_PIPELINE, /**< adc pipeline */
+	  MAX_ADC_PHASE_SHIFT, /** max adc phase shift */
+	  MAX_DBIT_PHASE_SHIFT, /** max adc phase shift */
+	};
+
+
+	/**
+	   readout flags
+	*/
+	enum readOutFlags {
+	  GET_READOUT_FLAGS=-1, /**< return readout flags */
+	  NORMAL_READOUT=0, /**< no flag */
+	  STORE_IN_RAM=0x1, /**< data are stored in ram and sent only after end of acquisition for faster frame rate */
+	  READ_HITS=0x2, /**< return only the number of the channel which counted ate least one */
+	  ZERO_COMPRESSION=0x4,/**< returned data are 0-compressed */
+	  PUMP_PROBE_MODE=0x8,/**<pump-probe mode */
+	  BACKGROUND_CORRECTIONS=0x1000, /**<background corrections */
+	  TOT_MODE=0x2000,/**< pump-probe mode */
+	  CONTINOUS_RO=0x4000,/**< pump-probe mode */
+	  PARALLEL=0x10000,/**< eiger parallel mode */
+	  NONPARALLEL=0x20000,/**< eiger serial mode */
+	  SAFE=0x40000/**< eiger safe mode */,
+	  DIGITAL_ONLY=0x80000, /** chiptest board read only digital bits (not adc values)*/
+	  ANALOG_AND_DIGITAL=0x100000, /** chiptest board read adc values and digital bits digital bits */
+	  DUT_CLK=0x200000, /** chiptest board fifo clock comes from device under test */
+	  SHOW_OVERFLOW=0x400000, /** eiger 32 bit mode, show saturated for overflow of single subframes */
+	  NOOVERFLOW=0x800000 /** eiger 32 bit mode, do not show saturated for overflow of single subframes */
+	};
+
+
+	/** port type */
+	enum portType {
+	  CONTROL_PORT, /**< control port */
+	  STOP_PORT, /**<stop port */
+	  DATA_PORT /**< receiver tcp port with client*/
+	};
+
+	/** hierarchy in multi-detector structure, if any */
+	enum masterFlags {
+	  GET_MASTER=-1, /**< return master flag */
+	  NO_MASTER, /**< no master/slave hierarchy defined */
+	  IS_MASTER, /**<is master */
+	  IS_SLAVE /**< is slave */
+	};
+
+
+	enum imageType {
+	  DARK_IMAGE,   /**< dark image */
+	  GAIN_IMAGE   /**< gain image */
+	};
+
+
+	/**
+	 * frame mode for processor
+	 */
+	enum frameModeType {
+	    GET_FRAME_MODE = -1,
+	    PEDESTAL,       /** < pedestal */
+	    NEW_PEDESTAL,   /** < new pedestal */
+	    FLATFIELD,      /** < flatfield */
+	    NEW_FLATFIELD   /** < new flatfield */
+	};
+
+    /**
+     * detector mode for processor
+     */
+    enum detectorModeType {
+        GET_DETECTOR_MODE = -1,
+        COUNTING,       /** < counting */
+        INTERPOLATING,  /** < interpolating */
+        ANALOG          /** < analog */
+    };
+
+
+#ifdef __cplusplus
+	  /** returns string from enabled/disabled
+	      \param b true or false
+	      \returns string enabled, disabled
+	  */
+	  static std::string stringEnable(bool b){\
+		if(b) return std::string("enabled"); \
+		else return std::string("disabled"); \
+	  };
+
+	  /** returns detector type string from detector type index
+	      \param t string can be EIGER, GOTTHARD, JUNGFRAU, CHIPTESTBOARD
+	      \returns Eiger, Gotthard, Jungfrau, JungfrauCTB, Unknown
+	  */
+	  static std::string detectorTypeToString(detectorType t){	\
+	    switch (t) {										\
+	    case EIGER:    		return std::string("Eiger");	\
+	    case GOTTHARD:    	return std::string("Gotthard");	\
+	    case JUNGFRAU:    	return std::string("Jungfrau");	\
+	    case CHIPTESTBOARD:   return std::string("JungfrauCTB");	\
+	    case MOENCH:   		return std::string("Moench");	\
+	    default:    		return std::string("Unknown");	\
+	    }};
+
+	  /** returns detector type index from detector type string
+	      \param type can be Eiger, Gotthard, Jungfrau, JungfrauCTB
+	      \returns  EIGER, GOTTHARD, JUNGFRAU, CHIPTESTBOARD, GENERIC
+	  */
+	  static detectorType detectorTypeToEnum(const std::string& type){\
+	    if (type=="Eiger")    		return EIGER;		\
+	    if (type=="Gotthard")    	return GOTTHARD;	\
+	    if (type=="Jungfrau")    	return JUNGFRAU;	\
+	    if (type=="JungfrauCTB") 	return CHIPTESTBOARD;	\
+	    if (type=="Moench") 		return MOENCH;	\
+	    							return GENERIC;		\
+	  };
+
+
+	  /** returns string from run status index
+	      \param s can be ERROR, WAITING, RUNNING, TRANSMITTING, RUN_FINISHED, STOPPED
+	      \returns string error, waiting, running, data, finished, stopped, idle
+	  */
+	  static std::string runStatusType(runStatus s){\
+	    switch (s) {				\
+	    case ERROR:       	return std::string("error");	\
+	    case WAITING:      	return std::string("waiting");	\
+	    case RUNNING:      	return std::string("running");	\
+	    case TRANSMITTING:  return std::string("data");		\
+	    case RUN_FINISHED: 	return std::string("finished");	\
+	    case STOPPED: 		return std::string("stopped");	\
+	    default:       		return std::string("idle");		\
+	    }};
+
+
+	  /** returns string from file format index
+	      \param s can be BINARY, ASCII, HDF5
+	      \returns string binary, ascii, hdf5
+	  */
+	  static std::string getFileFormatType(fileFormat f){\
+	    switch (f) {				\
+	    case HDF5:      return std::string("hdf5");	\
+	    case BINARY:    return std::string("binary");	\
+	    default:       		return std::string("unknown");		\
+	    }};
+
+	  /**
+	   * Returns string of frame discard policy index
+	   * @param f can be NO_DISCARD, DISCARD_EMPTY_FRAMES, DISCARD_PARTIAL_FRAMES
+	   * @returns No Discard, Discard Empty Frames, Discard Partial Frames, unknown
+	   */
+	  static std::string getFrameDiscardPolicyType(frameDiscardPolicy f) {						\
+		  switch (f) {																		\
+		  case NO_DISCARD: 				return std::string("No Discard");					\
+		  case DISCARD_EMPTY_FRAMES: 	return std::string("Discard Empty Frames");			\
+		  case DISCARD_PARTIAL_FRAMES: 	return std::string("Discard Partial Frames");		\
+		  default:       				return std::string("unknown");						\
+		  }};																				\
+
+
+
+		  /** returns std::string from external signal type index
+		      \param f can be SIGNAL_OFF, GATE_IN_ACTIVE_HIGH, GATE_IN_ACTIVE_LOW, TRIGGER_IN_RISING_EDGE, TRIGGER_IN_FALLING_EDGE, RO_TRIGGER_IN_RISING_EDGE, RO_TRIGGER_IN_FALLING_EDGE, GATE_OUT_ACTIVE_HIGH, GATE_OUT_ACTIVE_LOW, =TRIGGER_OUT_RISING_EDGE, TRIGGER_OUT_FALLING_EDGE, RO_TRIGGER_OUT_RISING_EDGE, RO_TRIGGER_OUT_FALLING_EDGE, OUTPUT_LOW, OUTPUT_HIGH, MASTER_SLAVE_SYNCHRONIZATION,  GET_EXTERNAL_SIGNAL_FLAG
+		      \returns std::string  off, gate_in_active_high, gate_in_active_low, trigger_in_rising_edge, trigger_in_falling_edge, ro_trigger_in_rising_edge, ro_trigger_in_falling_edge, gate_out_active_high, gate_out_active_low, trigger_out_rising_edge, trigger_out_falling_edge, ro_trigger_out_rising_edge, ro_trigger_out_falling_edge, gnd, vcc, sync, unknown
+		  */
+		  static std::string externalSignalType(externalSignalFlag f){\
+		    switch(f) {						 \
+		    case SIGNAL_OFF:      return std::string( "off");			\
+		    case GATE_IN_ACTIVE_HIGH:    return std::string( "gate_in_active_high");	\
+		    case GATE_IN_ACTIVE_LOW:    return std::string( "gate_in_active_low");	\
+		    case TRIGGER_IN_RISING_EDGE:    return std::string( "trigger_in_rising_edge"); \
+		    case TRIGGER_IN_FALLING_EDGE:    return std::string( "trigger_in_falling_edge");	\
+		    case RO_TRIGGER_IN_RISING_EDGE:    return std::string( "ro_trigger_in_rising_edge"); \
+		    case RO_TRIGGER_IN_FALLING_EDGE:    return std::string( "ro_trigger_in_falling_edge"); \
+		    case GATE_OUT_ACTIVE_HIGH:    return std::string( "gate_out_active_high"); \
+		    case GATE_OUT_ACTIVE_LOW:    return std::string( "gate_out_active_low");	\
+		    case TRIGGER_OUT_RISING_EDGE:    return std::string( "trigger_out_rising_edge");	\
+		    case TRIGGER_OUT_FALLING_EDGE:    return std::string( "trigger_out_falling_edge"); \
+		    case RO_TRIGGER_OUT_RISING_EDGE:      return std::string( "ro_trigger_out_rising_edge");	\
+		    case RO_TRIGGER_OUT_FALLING_EDGE:    return std::string( "ro_trigger_out_falling_edge");	\
+		    case MASTER_SLAVE_SYNCHRONIZATION: return std::string("sync");		\
+		    case OUTPUT_LOW: return std::string("gnd");		\
+		    case OUTPUT_HIGH: return std::string("vcc");		\
+		    default:    return std::string( "unknown");				\
+		    }    };
+
+
+
+
+		  /** returns external signal type index from std::string
+		      \param sval  off, gate_in_active_high, gate_in_active_low, trigger_in_rising_edge, trigger_in_falling_edge, ro_trigger_in_rising_edge, ro_trigger_in_falling_edge, gate_out_active_high, gate_out_active_low, trigger_out_rising_edge, trigger_out_falling_edge, ro_trigger_out_rising_edge, ro_trigger_out_falling_edge, gnd, vcc, sync, unknown
+		      \returns can be SIGNAL_OFF, GATE_IN_ACTIVE_HIGH, GATE_IN_ACTIVE_LOW, TRIGGER_IN_RISING_EDGE, TRIGGER_IN_FALLING_EDGE, RO_TRIGGER_IN_RISING_EDGE, RO_TRIGGER_IN_FALLING_EDGE, GATE_OUT_ACTIVE_HIGH, GATE_OUT_ACTIVE_LOW, TRIGGER_OUT_RISING_EDGE, TRIGGER_OUT_FALLING_EDGE, RO_TRIGGER_OUT_RISING_EDGE, RO_TRIGGER_OUT_FALLING_EDGE, OUTPUT_LOW, OUTPUT_HIGH, MASTER_SLAVE_SYNCHRONIZATION,  GET_EXTERNAL_SIGNAL_FLAG (if unknown)
+		  */
+
+		  static externalSignalFlag externalSignalType(std::string sval){\
+		    if (sval=="off")      return SIGNAL_OFF;\
+		    if (sval=="gate_in_active_high")      return GATE_IN_ACTIVE_HIGH;	\
+		    if  (sval=="gate_in_active_low") return GATE_IN_ACTIVE_LOW;\
+		    if  (sval=="trigger_in_rising_edge")  return TRIGGER_IN_RISING_EDGE;\
+		    if  (sval=="trigger_in_falling_edge") return TRIGGER_IN_FALLING_EDGE;\
+		    if  (sval=="ro_trigger_in_rising_edge") return RO_TRIGGER_IN_RISING_EDGE;\
+		    if  (sval=="ro_trigger_in_falling_edge") return RO_TRIGGER_IN_FALLING_EDGE;\
+		    if (sval=="gate_out_active_high")      return GATE_OUT_ACTIVE_HIGH;\
+		    if  (sval=="gate_out_active_low") return GATE_OUT_ACTIVE_LOW;\
+		    if  (sval=="trigger_out_rising_edge") return TRIGGER_OUT_RISING_EDGE;\
+		    if  (sval=="trigger_out_falling_edge") return TRIGGER_OUT_FALLING_EDGE;\
+		    if  (sval=="ro_trigger_out_rising_edge") return RO_TRIGGER_OUT_RISING_EDGE;\
+		    if  (sval=="ro_trigger_out_falling_edge") return RO_TRIGGER_OUT_FALLING_EDGE;\
+		    if  (sval=="sync") return MASTER_SLAVE_SYNCHRONIZATION;\
+		    if  (sval=="gnd") return OUTPUT_LOW;\
+		    if  (sval=="vcc") return OUTPUT_HIGH;\
+		    return GET_EXTERNAL_SIGNAL_FLAG ;};
+
+		  /** returns detector settings std::string from index
+		      \param s can be STANDARD, FAST, HIGHGAIN, DYNAMICGAIN, LOWGAIN, MEDIUMGAIN, VERYHIGHGAIN, LOWNOISE,
+		       DYNAMICHG0, FIXGAIN1, FIXGAIN2, FORCESWITCHG1, FORCESWITCHG2, GET_SETTINGS
+		      \returns standard, fast, highgain, dynamicgain, lowgain, mediumgain, veryhighgain, lownoise,
+		      dynamichg0, fixgain1, fixgain2, forceswitchg1, forceswitchg2, verylowgain, undefined
+		  */
+		  static std::string getDetectorSettings(detectorSettings s){\
+		    switch(s) {											\
+		    case STANDARD:      return std::string("standard");		\
+		    case FAST:      	return std::string("fast");			\
+		    case HIGHGAIN:      return std::string("highgain");		\
+		    case DYNAMICGAIN:   return std::string("dynamicgain");	\
+		    case LOWGAIN:    	return std::string("lowgain");		\
+		    case MEDIUMGAIN:    return std::string("mediumgain");	\
+		    case VERYHIGHGAIN:  return std::string("veryhighgain");	\
+		    case LOWNOISE:      return  std::string("lownoise");		\
+		    case DYNAMICHG0:    return  std::string("dynamichg0");	\
+		    case FIXGAIN1:      return  std::string("fixgain1");		\
+		    case FIXGAIN2:      return  std::string("fixgain2");		\
+		    case FORCESWITCHG1: return  std::string("forceswitchg1");\
+		    case FORCESWITCHG2: return  std::string("forceswitchg2");\
+		    case VERYLOWGAIN: return  std::string("verylowgain");\
+		    case UNINITIALIZED:	return std::string("uninitialized"); \
+		    default:    		return std::string("undefined");		\
+		    }};
+
+		  /** returns detector settings std::string from index
+		      \param s can be standard, fast, highgain, dynamicgain, lowgain, mediumgain, veryhighgain, lownoise,
+		      dynamichg0, fixgain1, fixgain2, forceswitchg1, forceswitchg2, undefined
+		      \returns   setting index STANDARD, FAST, HIGHGAIN, DYNAMICGAIN, LOWGAIN, MEDIUMGAIN, VERYHIGHGAIN,LOWNOISE,
+		      DYNAMICHG0, FIXGAIN1, FIXGAIN2, FORCESWITCHG1, FORCESWITCHG2, VERYLOWGAIN, GET_SETTINGS
+		  */
+
+		  static detectorSettings getDetectorSettings(std::string s){	\
+		    if (s=="standard") 		return STANDARD;				\
+		    if (s=="fast") 			return FAST;					\
+		    if (s=="highgain") 		return HIGHGAIN;				\
+		    if (s=="dynamicgain") 	return DYNAMICGAIN;				\
+		    if (s=="lowgain") 		return LOWGAIN;					\
+		    if (s=="mediumgain") 	return MEDIUMGAIN;				\
+		    if (s=="veryhighgain") 	return VERYHIGHGAIN;			\
+		    if (s=="lownoise") 		return LOWNOISE;				\
+		    if (s=="dynamichg0") 	return DYNAMICHG0;				\
+		    if (s=="fixgain1") 		return FIXGAIN1;				\
+		    if (s=="fixgain2") 		return FIXGAIN2;				\
+		    if (s=="forceswitchg1") return FORCESWITCHG1;			\
+		    if (s=="forceswitchg2")	return FORCESWITCHG2;			\
+		    if (s=="verylowgain")	return VERYLOWGAIN;				\
+		    return GET_SETTINGS;									\
+		  };
+
+
+		  /**
+		     returns external communication mode std::string from index
+		     \param f can be AUTO_TIMING, TRIGGER_EXPOSURE, GATED, BURST_TRIGGER, GET_EXTERNAL_COMMUNICATION_MODE
+		     \returns  auto, trigger, gating, burst_trigger, unknown
+		  */
+
+		  static std::string externalCommunicationType(externalCommunicationMode f){	\
+		    switch(f) {						 \
+		    case AUTO_TIMING:      return std::string( "auto");			\
+		    case TRIGGER_EXPOSURE: return std::string("trigger");			\
+		    case GATED: return std::string("gating");			\
+		    case BURST_TRIGGER: return std::string("burst_trigger");	\
+		    default:    return std::string( "unknown");				\
+		    }    };
+
+
+
+		  /**
+		     returns external communication mode index from std::string
+		     \param sval can be auto, trigger,  gating, burst_trigger
+		     \returns AUTO_TIMING, TRIGGER_EXPOSURE, GATED, BURST_TRIGGER, GET_EXTERNAL_COMMUNICATION_MODE
+		  */
+
+		  static externalCommunicationMode externalCommunicationType(std::string sval){\
+		    if (sval=="auto")      return AUTO_TIMING;\
+		    if (sval=="trigger")     return TRIGGER_EXPOSURE;	\
+		    if  (sval=="gating") return GATED;\
+		    if  (sval=="burst_trigger") return BURST_TRIGGER;\
+		    return GET_EXTERNAL_COMMUNICATION_MODE;			\
+		  };
+
+		  /** returns std::string from file format index
+		      \param s can be RAW, HDF5
+		      \returns std::string raw, hdf5
+		  */
+		  static std::string fileFormats(fileFormat f){\
+		    switch (f) {				\
+		    case BINARY:       return std::string("binary");		\
+		    case HDF5:      return  std::string("hdf5");	\
+		    default:       return std::string("unknown");		\
+		    }};
+
+		  /** returns std::string from timer index
+		      \param s can be FRAME_NUMBER,ACQUISITION_TIME,FRAME_PERIOD, DELAY_AFTER_TRIGGER,GATES_NUMBER, CYCLES_NUMBER, ACTUAL_TIME,MEASUREMENT_TIME, PROGRESS,MEASUREMENTS_NUMBER,FRAMES_FROM_START,FRAMES_FROM_START_PG,SAMPLES,SUBFRAME_ACQUISITION_TIME,STORAGE_CELL_NUMBER, SUBFRAME_DEADTIME
+		      \returns std::string frame_number,acquisition_time,frame_period, delay_after_trigger,gates_number, cycles_number, actual_time,measurement_time, progress,measurements_number,frames_from_start,frames_from_start_pg,samples,subframe_acquisition_time,storage_cell_number, SUBFRAME_DEADTIME
+		  */
+		  static std::string getTimerType(timerIndex t){										\
+		    switch (t) {																\
+		    case FRAME_NUMBER: 				return std::string("frame_number"); 				\
+		    case ACQUISITION_TIME: 			return std::string("acquisition_time"); 			\
+		    case FRAME_PERIOD: 				return std::string("frame_period"); 				\
+		    case DELAY_AFTER_TRIGGER: 		return std::string("delay_after_trigger"); 		\
+		    case GATES_NUMBER: 				return std::string("gates_number"); 				\
+		    case CYCLES_NUMBER: 			return std::string("cycles_number"); 			\
+		    case ACTUAL_TIME: 				return std::string("actual_time"); 				\
+		    case MEASUREMENT_TIME: 			return std::string("measurement_time"); 			\
+		    case PROGRESS: 					return std::string("progress"); 					\
+		    case MEASUREMENTS_NUMBER: 		return std::string("measurements_number"); 		\
+		    case FRAMES_FROM_START: 		return std::string("frames_from_start"); 		\
+		    case FRAMES_FROM_START_PG: 		return std::string("frames_from_start_pg"); 		\
+		    case SAMPLES: 				return std::string("samples"); 				\
+		    case SUBFRAME_ACQUISITION_TIME:	return std::string("subframe_acquisition_time");	\
+		    case SUBFRAME_DEADTIME:			return std::string("subframe_deadtime");			\
+		    case STORAGE_CELL_NUMBER:       return std::string("storage_cell_number");       \
+		    default:       					return std::string("unknown");					\
+		    }};
+
+
+		  /**
+		     @short returns adc index from std::string
+		     \param s can be temp_fpga, temp_fpgaext, temp_10ge, temp_dcdc, temp_sodl, temp_sodr, temp_fpgafl, temp_fpgafr
+		     \returns  TEMPERATURE_FPGA, TEMPERATURE_FPGAEXT, TEMPERATURE_10GE, TEMPERATURE_DCDC, TEMPERATURE_SODL,
+		     TEMPERATURE_SODR, TEMPERATURE_FPGA2, TEMPERATURE_FPGA3, -1 when unknown mode
+		  */
+		  static int getADCIndex(std::string s){					\
+			  if (s=="temp_fpga")	  	return TEMPERATURE_FPGA;	\
+			  if (s=="temp_fpgaext")	return TEMPERATURE_FPGAEXT;	\
+			  if (s=="temp_10ge")	  	return TEMPERATURE_10GE;	\
+			  if (s=="temp_dcdc")	  	return TEMPERATURE_DCDC;	\
+			  if (s=="temp_sodl")	  	return TEMPERATURE_SODL;	\
+			  if (s=="temp_sodr")	  	return TEMPERATURE_SODR;	\
+			  if (s=="temp_fpgafl")		return TEMPERATURE_FPGA2;	\
+			  if (s=="temp_fpgafr")		return TEMPERATURE_FPGA3;	\
+			  return -1;											\
+		  };														\
+
+
+		  /**
+		     @short returns dac index from std::string
+		     \param s can be vcmp_ll, vcmp_lr, vcmp_rl, vcmp_rr, vthreshold, vrf, vrs, vtr, vcall, vcp
+		     \returns E_Vcmp_ll, E_Vcmp_lr, E_Vcmp_rl, E_Vcmp_rr, THRESHOLD, E_Vrf, E_Vrs, E_Vtr, E_cal, E_Vcp , -1 when unknown mode
+		  */
+		  static int getDACIndex(std::string s){		\
+			  if (s=="vcmp_ll")	  	return E_Vcmp_ll;	\
+			  if (s=="vcmp_lr")	  	return E_Vcmp_lr;	\
+			  if (s=="vcmp_rl")		return E_Vcmp_rl;	\
+			  if (s=="vcmp_rr")	  	return E_Vcmp_rr;	\
+			  if (s=="vthreshold")	return THRESHOLD;	\
+			  if (s=="vrf")	  		return E_Vrf;		\
+			  if (s=="vrs")	  		return E_Vrs;		\
+			  if (s=="vtr")			return E_Vtr;		\
+			  if (s=="vcall")		return E_cal;		\
+			  if (s=="vcp")			return E_Vcp;		\
+			  return -1;								\
+		  };											\
+
+		  /**
+		     @short returns receiver frame discard policy from std::string
+		     \param s can be nodiscard, discardempty, discardpartial
+		     \returns NO_DISCARD, DISCARD_EMPTY_FRAMES, DISCARD_PARTIAL_FRAMES, GET_FRAME_DISCARD_POLICY when unknown mode
+		  */
+		  static frameDiscardPolicy getReceiverFrameDiscardPolicy(std::string s){		\
+			  if (s=="nodiscard")	  	return NO_DISCARD;				\
+			  if (s=="discardempty")	return DISCARD_EMPTY_FRAMES;	\
+			  if (s=="discardpartial")	return DISCARD_PARTIAL_FRAMES;	\
+			  return GET_FRAME_DISCARD_POLICY;							\
+		  };															\
+
+		  /** returns std::string from frame discard policy
+		      \param f can be NO_DISCARD, DISCARD_EMPTY_FRAMES, DISCARD_PARTIAL_FRAMES
+		      \returns std::string nodiscard, discardempty, discardpartial, unknown
+		  */
+		  static std::string getReceiverFrameDiscardPolicy(frameDiscardPolicy f){	\
+		    switch (f) {															\
+		    case NO_DISCARD: 				return std::string("nodiscard"); 		\
+		    case DISCARD_EMPTY_FRAMES: 		return std::string("discardempty"); 	\
+		    case DISCARD_PARTIAL_FRAMES: 	return std::string("discardpartial"); 	\
+		    default:       					return std::string("unknown");			\
+		    }};																		\
+
+
+		    /**
+		     * returns frameModeType as enum
+		     * @param s pedestal, newpedestal, flatfield, newflatfield
+		     * @returns PEDESTAL, NEW_PEDESTAL, FLATFIELD, NEW_FLATFIELD, GET_FRAME_MODE (if unknown)
+		     */
+		    static frameModeType getFrameModeType(std::string s) {  \
+		        for (auto &c: s)                                    \
+		            c = std::tolower(c);                           \
+		        if (s == "pedestal")    return PEDESTAL;            \
+		        if (s == "newpedestal") return NEW_PEDESTAL;        \
+		        if (s == "flatfield")   return FLATFIELD;           \
+		        if (s == "newflatfield")return NEW_FLATFIELD;       \
+		        return GET_FRAME_MODE;                              \
+		    }                                                       \
+
+            /**
+             * returns frameModeType as string
+             * @param f PEDESTAL, NEW_PEDESTAL, FLATFIELD, NEW_FLATFIELD
+             * @return string pedestal, newpedestal, flatfield, newflatfield, unknown
+             */
+		    static std::string getFrameModeType(frameModeType f) {      \
+		        switch(f) {                                             \
+		        case PEDESTAL:      return std::string("pedestal");     \
+		        case NEW_PEDESTAL:  return std::string("newPedestal");  \
+		        case FLATFIELD:     return std::string("flatfield");    \
+		        case NEW_FLATFIELD: return std::string("newFlatfield"); \
+		        default:            return std::string("unknown");      \
+		        }                                                       \
+		    }                                                           \
+
+            /**
+             * returns detectorModeType as enum
+             * @param s counting, interpolating, analog
+             * @returns COUNTING, INTERPOLATING, ANALOG, GET_DETECTOR_MODE (if unknown)
+             */
+            static detectorModeType getDetectorModeType(std::string s) {    \
+                for (auto &c: s)                                            \
+                    c = std::tolower(c);                                   \
+                if (s == "counting")        return COUNTING;                \
+                if (s == "interpolating")   return INTERPOLATING;           \
+                if (s == "analog")          return ANALOG;                  \
+                return GET_DETECTOR_MODE;                                   \
+            }                                                               \
+
+            /**
+             * returns frameModeType as string
+             * @param f COUNTING, INTERPOLATING, ANALOG
+             * @return string counting, interpolating, analog, unknown
+             */
+            static std::string getDetectorModeType(detectorModeType f) {    \
+                switch(f) {                                                 \
+                case COUNTING:      return std::string("counting");         \
+                case INTERPOLATING: return std::string("interpolating");    \
+                case ANALOG:        return std::string("analog");           \
+                default:            return std::string("unknown");          \
+                }                                                           \
+            }                                                               \
+
+#endif
+
+#ifdef __cplusplus
+protected:
+#endif
+
+#ifndef MYROOT
+#include "sls_detector_funcs.h"
+#endif
+
+#ifdef __cplusplus
+};
+#endif
+;

slsSupportLib/include/sls_detector_exceptions.h

@@ -0,0 +1,78 @@
+#pragma once
+/************************************************
+ * @file sls_detector_exceptions.h
+ * @short exceptions defined
+ ***********************************************/
+/**
+ *@short exceptions defined
+ */
+
+#include "logger.h"
+
+#include <iostream>
+#include <stdexcept>
+
+namespace sls{
+
+struct RuntimeError : public std::runtime_error {
+public:
+	RuntimeError(): runtime_error("SLS Detector Package Failed") {
+		FILE_LOG(logERROR) << "SLS Detector Package Failed";
+	}
+	RuntimeError(std::string msg): runtime_error(msg) {
+		FILE_LOG(logERROR) << msg;
+	}
+	RuntimeError(const char* msg): runtime_error(msg) {
+		FILE_LOG(logERROR) << msg;
+	}
+};
+
+struct CriticalError : public RuntimeError {
+public:
+    CriticalError(std::string msg):RuntimeError(msg) {}
+};
+
+struct SharedMemoryError : public CriticalError {
+public:
+    SharedMemoryError(std::string msg):CriticalError(msg) {}
+};
+
+struct SocketError : public CriticalError {
+public:
+	SocketError(std::string msg):CriticalError(msg) {}
+};
+
+struct ZmqSocketError : public CriticalError {
+public:
+	ZmqSocketError(std::string msg):CriticalError(msg) {}
+};
+
+struct NonCriticalError : public RuntimeError {
+public:
+    NonCriticalError(std::string msg):RuntimeError(msg) {}
+};
+
+struct NotImplementedError : public NonCriticalError {
+public:
+	NotImplementedError(std::string msg):NonCriticalError(msg) {}
+};
+
+struct DetectorError : public NonCriticalError {
+public:
+	DetectorError(std::string msg):NonCriticalError(msg) {}
+};
+
+struct ReceiverError : public NonCriticalError {
+public:
+	ReceiverError(std::string msg):NonCriticalError(msg) {}
+};
+
+struct GuiError : public NonCriticalError {
+public:
+	GuiError(std::string msg):NonCriticalError(msg) {}
+};
+
+}
+
+
+

slsSupportLib/include/sls_detector_funcs.h

@@ -0,0 +1,258 @@
+#pragma once
+
+/************************************************
+ * @file sls_detector_funcs.h
+ * @short functions indices to call on server (detector/receiver)
+ ***********************************************/
+/**
+ *@short functions indices to call on server (detector/receiver)
+ */
+
+
+enum detFuncs{
+	F_EXEC_COMMAND=0, /**< command is executed */
+	F_GET_DETECTOR_TYPE, /**< return detector type */
+	F_SET_EXTERNAL_SIGNAL_FLAG, /**< set/get flag for external signal */
+	F_SET_EXTERNAL_COMMUNICATION_MODE, /**< set/get  external communication mode (obsolete) */
+	F_GET_ID, /**< get detector id of version */
+	F_DIGITAL_TEST, /**< digital test of the detector */
+	F_SET_DAC, /**< set DAC value */
+	F_GET_ADC, /**< get ADC value */
+	F_WRITE_REGISTER, /**< write to register */
+	F_READ_REGISTER, /**< read register */
+	F_SET_MODULE, /**< initialize module */
+	F_GET_MODULE, /**< get module status */
+	F_SET_SETTINGS, /**< set detector settings */
+	F_GET_THRESHOLD_ENERGY, /**< get detector threshold (in eV) */
+	F_START_ACQUISITION, /**< start acquisition */
+	F_STOP_ACQUISITION, /**< stop acquisition */
+	F_START_READOUT, /**< start readout */
+	F_GET_RUN_STATUS, /**< get acquisition status */
+	F_START_AND_READ_ALL, /**< start acquisition and read all frames*/
+	F_READ_ALL, /**< read alla frames */
+	F_SET_TIMER, /**< set/get timer value */
+	F_GET_TIME_LEFT, /**< get current value of the timer (time left) */
+	F_SET_DYNAMIC_RANGE, /**< set/get detector dynamic range */
+	F_SET_READOUT_FLAGS, /**< set/get readout flags */
+	F_SET_ROI, /**< set/get region of interest */
+	F_SET_SPEED, /**< set/get readout speed parameters */
+	F_EXIT_SERVER, /**< turn off detector server */
+	F_LOCK_SERVER, /**< Locks/Unlocks server communication to the given client */
+	F_GET_LAST_CLIENT_IP, /**< returns the IP of the client last connected to the detector */
+	F_SET_PORT, /**< Changes communication port of the server */
+	F_UPDATE_CLIENT, /**< Returns all the important parameters to update the shared memory of the client */
+	F_CONFIGURE_MAC, /**< Configures MAC for Gotthard readout */
+	F_LOAD_IMAGE, /**< Loads Dark/Gain image to the Gotthard detector */
+	F_READ_COUNTER_BLOCK, /**< reads the counter block memory for gotthard */
+	F_RESET_COUNTER_BLOCK, /**< resets the counter block memory for gotthard */
+	F_ENABLE_TEN_GIGA, /**< enable 10Gbe */
+	F_SET_ALL_TRIMBITS, /** < set all trimbits to this value */
+	F_SET_PATTERN, /** < loads a pattern  */
+	F_SET_PATTERN_MASK, /** < loads a pattern mask  */
+	F_GET_PATTERN_MASK, /** < retrieves pattern mask  */
+	F_SET_PATTERN_BIT_MASK, /** < loads bitmask for the pattern  */
+	F_GET_PATTERN_BIT_MASK, /** < retrieves bitmask for the pattern  */
+	F_WRITE_ADC_REG, /** < writes an ADC register */
+	F_SET_COUNTER_BIT, /** < set/reset counter bit in detector for eiger */
+	F_PULSE_PIXEL,/** < pulse pixel n number of times in eiger at (x,y)  */
+	F_PULSE_PIXEL_AND_MOVE,/** < pulse pixel n number of times and move relatively by x and y */
+	F_PULSE_CHIP, /** < pulse chip n number of times */
+	F_SET_RATE_CORRECT,/** < set/reset rate correction tau */
+	F_GET_RATE_CORRECT,/** < get rate correction tau */
+	F_SET_NETWORK_PARAMETER,/**< set network parameters such as transmission delay, flow control */
+	F_PROGRAM_FPGA,/**< program FPGA */
+	F_RESET_FPGA, /**< reset FPGA */
+	F_POWER_CHIP, /**< power chip */
+	F_ACTIVATE,/** < activate */
+	F_PREPARE_ACQUISITION,/** < prepare acquisition */
+	F_THRESHOLD_TEMP, /** < set threshold temperature */
+	F_TEMP_CONTROL, /** < set temperature control */
+	F_TEMP_EVENT, /** < set temperature event */
+	F_AUTO_COMP_DISABLE, /** < auto comp disable mode */
+	F_STORAGE_CELL_START, /** < storage cell start */
+	F_CHECK_VERSION,/** < check version compatibility */
+	F_SOFTWARE_TRIGGER,/** < software trigger */
+	F_LED,	/** < switch on/off led */
+	F_DIGITAL_IO_DELAY,  /** < digital IO delay */
+	F_COPY_DET_SERVER,	/** < copy detector server & respawn */
+	F_REBOOT_CONTROLLER, /** < reboot detector controller (blackfin/ powerpc) */
+	NUM_DET_FUNCTIONS,
+
+	RECEIVER_ENUM_START = 128, /**< detector function should not exceed this (detector server should not compile anyway) */
+	F_EXEC_RECEIVER_COMMAND,/**< command is executed */
+	F_EXIT_RECEIVER,/**< turn off receiver server */
+	F_LOCK_RECEIVER,/**< Locks/Unlocks server communication to the given client */
+	F_GET_LAST_RECEIVER_CLIENT_IP,/**< returns the IP of the client last connected to the receiver */
+	F_SET_RECEIVER_PORT, /**< Changes communication port of the receiver */
+	F_UPDATE_RECEIVER_CLIENT, /**< Returns all the important parameters to update the shared memory of the client */
+	F_GET_RECEIVER_ID, /**< get receiver id of version */
+	F_GET_RECEIVER_TYPE, /**< return receiver type */
+	F_SEND_RECEIVER_DETHOSTNAME, /**< set detector hostname to receiver */
+	F_RECEIVER_SET_ROI, /**< Sets receiver ROI */
+	F_SETUP_RECEIVER_UDP, /**< sets the receiver udp connection and returns receiver mac address */
+	F_SET_RECEIVER_TIMER, /**< set/get timer value */
+	F_SET_RECEIVER_DYNAMIC_RANGE, /**< set/get detector dynamic range */
+	F_RECEIVER_STREAMING_FREQUENCY, /**< sets the frequency of receiver sending frames to gui */
+	F_GET_RECEIVER_STATUS, /**< gets the status of receiver listening mode */
+	F_START_RECEIVER, /**< starts the receiver listening mode */
+	F_STOP_RECEIVER, /**< stops the receiver listening mode */
+	F_SET_RECEIVER_FILE_PATH, /**< sets receiver file directory */
+	F_SET_RECEIVER_FILE_NAME, /**< sets receiver file name */
+	F_SET_RECEIVER_FILE_INDEX, /**< sets receiver file index */
+	F_GET_RECEIVER_FRAME_INDEX, /**< gets the receiver frame index */
+	F_GET_RECEIVER_FRAMES_CAUGHT, /**< gets the number of frames caught by receiver */
+	F_RESET_RECEIVER_FRAMES_CAUGHT, /**< resets the frames caught by receiver */
+	F_ENABLE_RECEIVER_FILE_WRITE, /**< sets the receiver file write */
+	F_ENABLE_RECEIVER_OVERWRITE, /**< set overwrite flag in receiver */
+	F_ENABLE_RECEIVER_TEN_GIGA, /**< enable 10Gbe in receiver */
+	F_SET_RECEIVER_FIFO_DEPTH, /**< set receiver fifo depth */
+	F_RECEIVER_ACTIVATE, /** < activate/deactivate readout */
+	F_STREAM_DATA_FROM_RECEIVER, /**< stream data from receiver to client */
+	F_RECEIVER_STREAMING_TIMER, /** < sets the timer between each data stream in receiver */
+	F_SET_FLIPPED_DATA_RECEIVER, /** < sets the enable to flip data across x/y axis (bottom/top) */
+	F_SET_RECEIVER_FILE_FORMAT, /** < sets the receiver file format */
+	F_SEND_RECEIVER_DETPOSID, /** < sets the detector position id in the reveiver */
+	F_SEND_RECEIVER_MULTIDETSIZE, /** < sets the multi detector size to the receiver */
+	F_SET_RECEIVER_STREAMING_PORT, /** < sets the receiver streaming port */
+	F_RECEIVER_STREAMING_SRC_IP, /** < sets the receiver streaming source IP */
+	F_SET_RECEIVER_SILENT_MODE, /** < sets the receiver silent mode */
+	F_ENABLE_GAPPIXELS_IN_RECEIVER, /** < sets gap pixels in the receiver */
+	F_RESTREAM_STOP_FROM_RECEIVER, /** < restream stop from receiver */
+	F_ADDITIONAL_JSON_HEADER, /** < additional json header */
+	F_GET_ADDITIONAL_JSON_HEADER,/** < get additional json header */
+	F_RECEIVER_UDP_SOCK_BUF_SIZE, /** < UDP socket buffer size */
+	F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE, /** < real UDP socket buffer size */
+	F_SET_RECEIVER_FRAMES_PER_FILE, /** < receiver frames per file */
+	F_RECEIVER_CHECK_VERSION, /** < check receiver version compatibility */
+	F_RECEIVER_DISCARD_POLICY, /** < frames discard policy */
+	F_RECEIVER_PADDING_ENABLE, /** < partial frames padding enable */
+	F_RECEIVER_DEACTIVATED_PADDING_ENABLE, /** < deactivated receiver padding enable */
+	F_RECEIVER_SET_READOUT_FLAGS, /**< set/get receiver readout flags */
+	NUM_REC_FUNCTIONS
+};
+
+#ifdef __cplusplus
+static const char* getFunctionNameFromEnum(enum detFuncs func) {
+	switch (func) {
+	case F_EXEC_COMMAND:					return "F_EXEC_COMMAND";
+	case F_GET_DETECTOR_TYPE:				return "F_GET_DETECTOR_TYPE";
+	case F_SET_EXTERNAL_SIGNAL_FLAG:		return "F_SET_EXTERNAL_SIGNAL_FLAG";
+	case F_SET_EXTERNAL_COMMUNICATION_MODE:	return "F_SET_EXTERNAL_COMMUNICATION_MODE";
+	case F_GET_ID:							return "F_GET_ID";
+	case F_DIGITAL_TEST:					return "F_DIGITAL_TEST";
+	case F_SET_DAC:							return "F_SET_DAC";
+	case F_GET_ADC:							return "F_GET_ADC";
+	case F_WRITE_REGISTER:					return "F_WRITE_REGISTER";
+	case F_READ_REGISTER:					return "F_READ_REGISTER";
+	case F_SET_MODULE:						return "F_SET_MODULE";
+	case F_GET_MODULE:						return "F_GET_MODULE";
+	case F_SET_SETTINGS:					return "F_SET_SETTINGS";
+	case F_GET_THRESHOLD_ENERGY:			return "F_GET_THRESHOLD_ENERGY";
+	case F_START_ACQUISITION:				return "F_START_ACQUISITION";
+	case F_STOP_ACQUISITION:				return "F_STOP_ACQUISITION";
+	case F_START_READOUT:					return "F_START_READOUT";
+	case F_GET_RUN_STATUS:					return "F_GET_RUN_STATUS";
+	case F_START_AND_READ_ALL:				return "F_START_AND_READ_ALL";
+	case F_READ_ALL:						return "F_READ_ALL";
+	case F_SET_TIMER:						return "F_SET_TIMER";
+	case F_GET_TIME_LEFT:					return "F_GET_TIME_LEFT";
+	case F_SET_DYNAMIC_RANGE:				return "F_SET_DYNAMIC_RANGE";
+	case F_SET_READOUT_FLAGS:				return "F_SET_READOUT_FLAGS";
+	case F_SET_ROI:							return "F_SET_ROI";
+	case F_SET_SPEED:						return "F_SET_SPEED";
+	case F_EXIT_SERVER:						return "F_EXIT_SERVER";
+	case F_LOCK_SERVER:						return "F_LOCK_SERVER";
+	case F_GET_LAST_CLIENT_IP:				return "F_GET_LAST_CLIENT_IP";
+	case F_SET_PORT:						return "F_SET_PORT";
+	case F_UPDATE_CLIENT:					return "F_UPDATE_CLIENT";
+	case F_CONFIGURE_MAC:					return "F_CONFIGURE_MAC";
+	case F_LOAD_IMAGE:						return "F_LOAD_IMAGE";
+	case F_READ_COUNTER_BLOCK:				return "F_READ_COUNTER_BLOCK";
+	case F_RESET_COUNTER_BLOCK:				return "F_RESET_COUNTER_BLOCK";
+	case F_ENABLE_TEN_GIGA:					return "F_ENABLE_TEN_GIGA";
+	case F_SET_ALL_TRIMBITS:				return "F_SET_ALL_TRIMBITS";
+	case F_SET_PATTERN:						return "F_SET_PATTERN";
+	case F_SET_PATTERN_MASK:				return "F_SET_PATTERN_MASK";
+	case F_GET_PATTERN_MASK:				return "F_GET_PATTERN_MASK";
+	case F_SET_PATTERN_BIT_MASK:			return "F_SET_PATTERN_BIT_MASK";
+	case F_GET_PATTERN_BIT_MASK:			return "F_GET_PATTERN_BIT_MASK";
+	case F_WRITE_ADC_REG:					return "F_WRITE_ADC_REG";
+	case F_SET_COUNTER_BIT:					return "F_SET_COUNTER_BIT";
+	case F_PULSE_PIXEL:						return "F_PULSE_PIXEL";
+	case F_PULSE_PIXEL_AND_MOVE:			return "F_PULSE_PIXEL_AND_MOVE";
+	case F_PULSE_CHIP:						return "F_PULSE_CHIP";
+	case F_SET_RATE_CORRECT:				return "F_SET_RATE_CORRECT";
+	case F_GET_RATE_CORRECT:				return "F_GET_RATE_CORRECT";
+	case F_SET_NETWORK_PARAMETER:			return "F_SET_NETWORK_PARAMETER";
+	case F_PROGRAM_FPGA:					return "F_PROGRAM_FPGA";
+	case F_RESET_FPGA:						return "F_RESET_FPGA";
+	case F_POWER_CHIP:						return "F_POWER_CHIP";
+	case F_ACTIVATE:						return "F_ACTIVATE";
+	case F_PREPARE_ACQUISITION:				return "F_PREPARE_ACQUISITION";
+	case F_THRESHOLD_TEMP:                  return "F_THRESHOLD_TEMP";
+	case F_TEMP_CONTROL:                    return "F_TEMP_CONTROL";
+	case F_TEMP_EVENT:                      return "F_TEMP_EVENT";
+    case F_AUTO_COMP_DISABLE:               return "F_AUTO_COMP_DISABLE";
+    case F_STORAGE_CELL_START:              return "F_STORAGE_CELL_START";
+    case F_CHECK_VERSION:              		return "F_CHECK_VERSION";
+    case F_SOFTWARE_TRIGGER:              	return "F_SOFTWARE_TRIGGER";
+    case F_LED:              				return "F_LED";
+
+    case NUM_DET_FUNCTIONS:              	return "NUM_DET_FUNCTIONS";
+    case RECEIVER_ENUM_START:				return "RECEIVER_ENUM_START";
+
+	case F_EXEC_RECEIVER_COMMAND:			return "F_EXEC_RECEIVER_COMMAND";
+	case F_EXIT_RECEIVER: 					return "F_EXIT_RECEIVER";
+	case F_LOCK_RECEIVER: 					return "F_LOCK_RECEIVER";
+	case F_GET_LAST_RECEIVER_CLIENT_IP: 	return "F_GET_LAST_RECEIVER_CLIENT_IP";
+	case F_SET_RECEIVER_PORT: 				return "F_SET_RECEIVER_PORT";
+	case F_UPDATE_RECEIVER_CLIENT: 			return "F_UPDATE_RECEIVER_CLIENT";
+	case F_GET_RECEIVER_ID: 				return "F_GET_RECEIVER_ID";
+	case F_GET_RECEIVER_TYPE: 				return "F_GET_RECEIVER_TYPE";
+	case F_SEND_RECEIVER_DETHOSTNAME:		return "F_SEND_RECEIVER_DETHOSTNAME";
+	case F_RECEIVER_SET_ROI: 				return "F_RECEIVER_SET_ROI";
+	case F_SETUP_RECEIVER_UDP:				return "F_SETUP_RECEIVER_UDP";
+	case F_SET_RECEIVER_TIMER:  			return "F_SET_RECEIVER_TIMER";
+	case F_SET_RECEIVER_DYNAMIC_RANGE:  	return "F_SET_RECEIVER_DYNAMIC_RANGE";
+	case F_RECEIVER_STREAMING_FREQUENCY:	return "F_RECEIVER_STREAMING_FREQUENCY";
+	case F_GET_RECEIVER_STATUS:				return "F_GET_RECEIVER_STATUS";
+	case F_START_RECEIVER:					return "F_START_RECEIVER";
+	case F_STOP_RECEIVER:					return "F_STOP_RECEIVER";
+	case F_SET_RECEIVER_FILE_PATH: 			return "F_SET_RECEIVER_FILE_PATH";
+	case F_SET_RECEIVER_FILE_NAME: 			return "F_SET_RECEIVER_FILE_NAME";
+	case F_SET_RECEIVER_FILE_INDEX: 		return "F_SET_RECEIVER_FILE_INDEX";
+	case F_GET_RECEIVER_FRAME_INDEX:		return "F_GET_RECEIVER_FRAME_INDEX";
+	case F_GET_RECEIVER_FRAMES_CAUGHT:		return "F_GET_RECEIVER_FRAMES_CAUGHT";
+	case F_RESET_RECEIVER_FRAMES_CAUGHT:	return "F_RESET_RECEIVER_FRAMES_CAUGHT";
+	case F_ENABLE_RECEIVER_FILE_WRITE:		return "F_ENABLE_RECEIVER_FILE_WRITE";
+	case F_ENABLE_RECEIVER_OVERWRITE:		return "F_ENABLE_RECEIVER_OVERWRITE";
+	case F_ENABLE_RECEIVER_TEN_GIGA:		return "F_ENABLE_RECEIVER_TEN_GIGA";
+	case F_SET_RECEIVER_FIFO_DEPTH:			return "F_SET_RECEIVER_FIFO_DEPTH";
+	case F_RECEIVER_ACTIVATE:				return "F_RECEIVER_ACTIVATE";
+	case F_STREAM_DATA_FROM_RECEIVER:		return "F_STREAM_DATA_FROM_RECEIVER";
+	case F_RECEIVER_STREAMING_TIMER:		return "F_RECEIVER_STREAMING_TIMER";
+	case F_SET_FLIPPED_DATA_RECEIVER:		return "F_SET_FLIPPED_DATA_RECEIVER";
+	case F_SET_RECEIVER_FILE_FORMAT:		return "F_SET_RECEIVER_FILE_FORMAT";
+	case F_SEND_RECEIVER_DETPOSID:			return "F_SEND_RECEIVER_DETPOSID";
+	case F_SEND_RECEIVER_MULTIDETSIZE:  	return "F_SEND_RECEIVER_MULTIDETSIZE";
+	case F_SET_RECEIVER_STREAMING_PORT: 	return "F_SET_RECEIVER_STREAMING_PORT";
+	case F_RECEIVER_STREAMING_SRC_IP: 		return "F_RECEIVER_STREAMING_SRC_IP";
+	case F_SET_RECEIVER_SILENT_MODE:		return "F_SET_RECEIVER_SILENT_MODE";
+	case F_ENABLE_GAPPIXELS_IN_RECEIVER:	return "F_ENABLE_GAPPIXELS_IN_RECEIVER";
+	case F_RESTREAM_STOP_FROM_RECEIVER:		return "F_RESTREAM_STOP_FROM_RECEIVER";
+    case F_ADDITIONAL_JSON_HEADER:      	return "F_ADDITIONAL_JSON_HEADER";
+    case F_GET_ADDITIONAL_JSON_HEADER:      return "F_GET_ADDITIONAL_JSON_HEADER";
+    case F_RECEIVER_UDP_SOCK_BUF_SIZE:  	return "F_RECEIVER_UDP_SOCK_BUF_SIZE";
+    case F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE: return "F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE";
+    case F_SET_RECEIVER_FRAMES_PER_FILE:	return "F_SET_RECEIVER_FRAMES_PER_FILE";
+    case F_RECEIVER_CHECK_VERSION:			return "F_RECEIVER_CHECK_VERSION";
+    case F_RECEIVER_DISCARD_POLICY:			return "F_RECEIVER_DISCARD_POLICY";
+    case F_RECEIVER_PADDING_ENABLE:			return "F_RECEIVER_PADDING_ENABLE";
+    case F_RECEIVER_DEACTIVATED_PADDING_ENABLE: return "F_RECEIVER_DEACTIVATED_PADDING_ENABLE";
+    case F_RECEIVER_SET_READOUT_FLAGS: 		return "F_RECEIVER_SET_READOUT_FLAGS";
+    case NUM_REC_FUNCTIONS: 				return "NUM_REC_FUNCTIONS";
+	default:								return "Unknown Function";
+	}
+};
+#endif
+

slsSupportLib/include/string_utils.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <cassert>
+#include <cstring>
+
+namespace sls {
+
+/* Implementation of a safe string copy function for setting fields in 
+for example the multi sls detector. It tries to copy the size of the 
+destination from the source, stopping on '\0'. 
+
+Warning this will truncate the source string and should be used with care. 
+Still this is better than strcpy and a buffer overflow...
+*/
+template <size_t array_size>
+void strcpy_safe(char (&destination)[array_size], const char *source) {
+    assert(array_size > strlen(source));
+    strncpy(destination, source, array_size-1);
+    destination[array_size - 1] = '\0';
+}
+
+template <size_t array_size>
+void strcpy_safe(char (&destination)[array_size], const std::string& source) {
+    assert(array_size > source.size());
+    strncpy(destination, source.c_str(), array_size-1);
+    destination[array_size - 1] = '\0';
+}
+
+/*
+Removes all occurrences of the specified char from a c string
+Templated on array size to ensure no access after buffer limits.
+*/
+template <size_t array_size>
+void removeChar(char (&str)[array_size], char ch) {
+    int count = 0;
+    for (int i = 0; str[i]; i++) {
+        if (str[i] != ch)
+            str[count++] = str[i];
+        if (i == array_size - 1)
+            break;
+    }
+    str[count] = '\0';
+}
+
+/* 
+Split a string using the specified delimeter and return a vector of strings.
+TODO! Look into switching to absl or a string_view based implementation. Current
+implementation should not be used in a performance critical place.
+*/
+std::vector<std::string> split(const std::string &strToSplit, char delimeter);
+
+/*
+Concatenate the non empty strings in the vector using +
+*/
+std::string concatenateNonEmptyStrings(const std::vector<std::string> &vec);
+
+/*
+Concatenate strings using + if the strings are different
+*/
+std::string concatenateIfDifferent(const std::vector<std::string> &container);
+
+/*
+Concatenate vector of things with str method using + if the strings are different
+*/
+template<typename T>
+std::string concatenateIfDifferent(const std::vector<T> &container);
+
+/*
+Convert an ip address string to a string in hex format. (removing dots)
+*/
+std::string stringIpToHex(const std::string &ip);
+
+}; // namespace sls

slsSupportLib/include/versionAPI.h

@@ -0,0 +1,10 @@
+/** API versions */
+#define GITBRANCH "refgui"
+#define APIGOTTHARD 0x190108
+#define APIMOENCH 0x181108
+#define APIEIGER 0x190405
+#define APIJUNGFRAU 0x190405
+#define APILIB 0x190405
+#define APIRECEIVER 0x190405
+#define APIGUI 0x190405
+#define APICTB 0x190405

slsSupportLib/src/ClientInterface.cpp

@@ -0,0 +1,42 @@
+#include "ClientInterface.h"
+#include "ClientSocket.h"
+
+ClientInterface::ClientInterface(sls::ClientSocket *socket, int n) : socket_(socket){}
+
+void ClientInterface::Client_Receive(int &ret, char *mess, void *retval, int sizeOfRetval) {
+    // get result of operation
+    socket_->receiveData(reinterpret_cast<char *>(&ret), sizeof(ret));
+
+    bool unrecognizedFunction = false;
+    if (ret == FAIL) {
+        bool created = false;
+        // allocate mess if null
+        if (!mess) {
+            created = true;
+            mess = new char[MAX_STR_LENGTH];
+            memset(mess, 0, MAX_STR_LENGTH);
+        }
+        // get error message
+        socket_->receiveData(mess, MAX_STR_LENGTH);
+        // cprintf(RED, "%s %d returned error: %s", type.c_str(), index, mess);
+
+        // unrecognized function, do not ask for retval
+        if (strstr(mess, "Unrecognized Function") != nullptr)
+            unrecognizedFunction = true;
+        // delete allocated mess
+        if (created)
+            delete[] mess;
+    }
+    // get retval
+    if (!unrecognizedFunction)
+        socket_->receiveData(reinterpret_cast<char *>(retval), sizeOfRetval);
+}
+
+int ClientInterface::Client_Send(int fnum, void *args, int sizeOfArgs, void *retval,
+                                 int sizeOfRetval, char *mess) {
+    int ret = FAIL;
+    socket_->sendData(reinterpret_cast<char *>(&fnum), sizeof(fnum));
+    socket_->sendData(reinterpret_cast<char *>(args), sizeOfArgs);
+    Client_Receive(ret, mess, retval, sizeOfRetval);
+    return ret;
+}

slsSupportLib/src/ClientSocket.cpp

@@ -0,0 +1,89 @@
+#include "ClientSocket.h"
+#include "logger.h"
+#include "sls_detector_defs.h"
+#include "sls_detector_exceptions.h"
+#include <arpa/inet.h>
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <stdexcept>
+#include <unistd.h>
+namespace sls {
+
+ClientSocket::ClientSocket(std::string stype, const std::string &host, uint16_t port)
+    : DataSocket(socket(AF_INET, SOCK_STREAM, 0)), socketType(stype) {
+
+    struct addrinfo hints, *result;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags |= AI_CANONNAME;
+
+    if (getaddrinfo(host.c_str(), NULL, &hints, &result) != 0) {
+        std::string msg =
+            "ClientSocket cannot decode host:" + host + " on port " + std::to_string(port) + "\n";
+        throw SocketError(msg);
+    }
+
+    // TODO! Erik, results could have multiple entries do we need to loop through them?
+    // struct sockaddr_in serverAddr {};
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(port);
+    memcpy((char *)&serverAddr.sin_addr.s_addr, &((struct sockaddr_in *)result->ai_addr)->sin_addr,
+           sizeof(in_addr_t));
+
+    if (::connect(getSocketId(), (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0) {
+        freeaddrinfo(result);
+        std::string msg = "ClientSocket: Cannot connect to " + socketType + ":" +
+                          host + " on port " + std::to_string(port) + "\n";
+        throw SocketError(msg);
+    }
+    freeaddrinfo(result);
+}
+
+ClientSocket::ClientSocket(std::string sType, struct sockaddr_in addr)
+    : DataSocket(socket(AF_INET, SOCK_STREAM, 0)), socketType(sType) {
+
+    if (::connect(getSocketId(), (struct sockaddr *)&addr, sizeof(addr)) != 0) {
+        char address[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &addr.sin_addr, address, INET_ADDRSTRLEN);
+        std::string msg = "ClientSocket: Cannot connect to " + socketType + ":" + address + " on port " +
+                          std::to_string(addr.sin_port) + "\n";
+        throw SocketError(msg);
+    }
+}
+
+int ClientSocket::sendCommandThenRead(int fnum, void *args, size_t args_size, void *retval,
+                                      size_t retval_size) {
+    int ret = slsDetectorDefs::FAIL;
+    sendData(&fnum, sizeof(fnum));
+    sendData(args, args_size);
+    readReply(ret, retval, retval_size);
+    return ret;
+}
+
+void ClientSocket::readReply(int &ret, void *retval, size_t retval_size) {
+
+    receiveData(&ret, sizeof(ret));
+    if (ret == slsDetectorDefs::FAIL) {
+        char mess[MAX_STR_LENGTH]{};
+        // get error message
+        receiveData(mess, sizeof(mess));
+        FILE_LOG(logERROR) <<  socketType << " returned error: " <<  mess;
+        std::cout << "\n"; // needed to reset the color.
+
+        // Do we need to know hostname here?
+        // In that case save it???
+        if (socketType == "Receiver") {
+            throw ReceiverError(mess);
+        } else if (socketType == "Detector") {
+            throw DetectorError(mess);
+        } else {
+            throw GuiError(mess);
+        }
+    }
+    // get retval
+    receiveData(retval, retval_size);
+}
+
+}; // namespace sls

slsSupportLib/src/CmdLineParser.cpp

@@ -0,0 +1,84 @@
+
+#include "CmdLineParser.h"
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+//printing function for debugging
+void CmdLineParser::Print() {
+    std::cout << "\nCmdLineParser::Print()\n";
+    std::cout << "\tmulti_id: " << multi_id_ << ", detector_id: " << detector_id_ << std::endl;
+    std::cout << "\texecutable: " << executable_ << '\n';
+    std::cout << "\tcommand: " << command_ << '\n';
+    std::cout << "\tn_arguments: " << n_arguments() << '\n';
+    std::cout << "\targuments: ";
+    for (const auto &argument : arguments_) {
+        std::cout << argument << " ";
+    }
+    std::cout << "\n\n";
+};
+
+void CmdLineParser::Parse(int argc, char *argv[]) {
+    //first element of argv is the command used to call the executable ->skipping
+    //and if this is the only command skip all
+    executable_ = argv[0];
+    if (argc > 1) {
+        //second element is cmd string that needs to be decoded
+        DecodeIdAndPosition(argv[1]);
+        //The rest of the arguments goes into a vector for later processing
+        for (int i = 2; i < argc; ++i) {
+            arguments_.emplace_back(std::string(argv[i]));
+        }
+    }
+};
+
+void CmdLineParser::Parse(const std::string &s) {
+    std::istringstream iss(s);
+    auto it = std::istream_iterator<std::string>(iss);
+    //read the first element and increment
+    command_ = *it++;
+    arguments_ = std::vector<std::string>(it, std::istream_iterator<std::string>());
+    ;
+    DecodeIdAndPosition(command_.c_str());
+}
+
+void CmdLineParser::DecodeIdAndPosition(const char *c) {
+    bool contains_id = std::strchr(c, '-') != nullptr;
+    bool contains_pos = std::strchr(c, ':') != nullptr;
+    char tmp[100];
+
+    if (contains_id && contains_pos) {
+        int r = sscanf(c, "%d-%d:%s", &multi_id_, &detector_id_, tmp);
+        if (r != 3) {
+            throw(std::invalid_argument("Cannot decode client or detector id from: \"" + std::string(c) + "\"\n"));
+        }
+        command_ = tmp;
+    } else if (contains_id && !contains_pos) {
+        int r = sscanf(c, "%d-%s", &multi_id_, tmp);
+        if (r != 2) {
+            throw(std::invalid_argument("Cannot decode client id from: \"" + std::string(c) + "\"\n"));
+        }
+        command_ = tmp;
+    } else if (!contains_id && contains_pos) {
+        int r = sscanf(c, "%d:%s", &detector_id_, tmp);
+        if (r != 2) {
+            throw(std::invalid_argument("Cannot decode detector id from: \"" + std::string(c) + "\"\n"));
+        }
+        command_ = tmp;
+    } else {
+        command_ = c;
+    }
+}
+
+std::vector<char *> CmdLineParser::argv() {
+    std::vector<char *> vec;
+    if (command_.empty()!=true){
+        vec.push_back(&command_.front());
+    }
+    
+    for (auto &arg : arguments_) {
+        vec.push_back(&arg.front());
+    }
+    return vec;
+}

slsSupportLib/src/DataSocket.cpp

@@ -0,0 +1,159 @@
+#include "DataSocket.h"
+#include "logger.h"
+#include "sls_detector_exceptions.h"
+#include <algorithm>
+#include <arpa/inet.h>
+#include <cstring>
+#include <iostream>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+
+namespace sls {
+
+DataSocket::DataSocket(int socketId) : socketId_(socketId) {}
+
+DataSocket::~DataSocket() {
+    if (socketId_ <= 0) {
+        return;
+    } else {
+        try {
+            close();
+        } catch (...) {
+            // pass
+        }
+    }
+}
+
+void DataSocket::swap(DataSocket &other) noexcept { std::swap(socketId_, other.socketId_); }
+
+DataSocket::DataSocket(DataSocket &&move) noexcept { move.swap(*this); }
+DataSocket &DataSocket::operator=(DataSocket &&move) noexcept {
+    move.swap(*this);
+    return *this;
+}
+
+size_t DataSocket::receiveData(void *buffer, size_t size) {
+    // std::cout << "Sending\n";
+    size_t dataRead = 0;
+    while (dataRead < size) {
+        dataRead +=
+            read(getSocketId(), reinterpret_cast<char *>(buffer) + dataRead, size - dataRead);
+    }
+    return dataRead;
+}
+
+size_t DataSocket::sendData(void *buffer, size_t size) {
+    // std::cout << "Receiving\n";
+    size_t dataSent = 0;
+    while (dataSent < size) {
+        dataSent +=
+            write(getSocketId(), reinterpret_cast<char *>(buffer) + dataSent, size - dataSent);
+    }
+    return dataSent;
+}
+
+int DataSocket::setTimeOut(int t_seconds) {
+    if (t_seconds <= 0)
+        return -1;
+
+    struct timeval t;
+    t.tv_sec = 0;
+    t.tv_usec = 0;
+    // Receive timeout indefinet
+    if (::setsockopt(getSocketId(), SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0) {
+        FILE_LOG(logERROR) << "setsockopt SO_RCVTIMEO " << 0;
+    }
+
+    t.tv_sec = t_seconds;
+    t.tv_usec = 0;
+    // Sending timeout in seconds
+    if (::setsockopt(getSocketId(), SOL_SOCKET, SO_SNDTIMEO, &t, sizeof(struct timeval)) < 0) {
+        FILE_LOG(logERROR) << "setsockopt SO_SNDTIMEO " << t_seconds;
+    }
+    return 0;
+}
+
+void DataSocket::close() {
+    if (socketId_ > 0) {
+        if(::close(socketId_)){
+            throw SocketError("could not close socket");
+        }
+        socketId_ = -1;
+        
+    } else {
+        throw std::runtime_error("Socket ERROR: close called on bad socket\n");
+    }
+}
+
+void DataSocket::shutDownSocket() {
+  	shutdown(getSocketId(), SHUT_RDWR);
+	close();  
+}
+
+struct sockaddr_in ConvertHostnameToInternetAddress(const std::string &hostname) {
+    struct addrinfo hints, *result;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags |= AI_CANONNAME;
+
+    struct sockaddr_in serverAddr {};
+    if (getaddrinfo(hostname.c_str(), NULL, &hints, &result) != 0) {
+        freeaddrinfo(result);
+        std::string msg = "ClientSocket cannot decode host:" + hostname + "\n";
+        throw SocketError(msg);
+    }
+    serverAddr.sin_family = AF_INET;
+    memcpy((char *)&serverAddr.sin_addr.s_addr, &((struct sockaddr_in *)result->ai_addr)->sin_addr,
+           sizeof(in_addr_t));
+    freeaddrinfo(result);
+    return serverAddr;
+}
+
+int ConvertHostnameToInternetAddress(const char *const hostname, struct ::addrinfo **res) {
+    // criteria in selecting socket address structures returned by res
+    struct ::addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    // get host info into res
+    int errcode = getaddrinfo(hostname, NULL, &hints, res);
+    if (errcode != 0) {
+        FILE_LOG(logERROR) << "Could not convert hostname (" << hostname
+                           << ") to internet address (zmq):" << gai_strerror(errcode);
+    } else {
+        if (*res == NULL) {
+            FILE_LOG(logERROR) << "Could not converthostname (" << hostname
+                               << ") to internet address (zmq):"
+                                  "gettaddrinfo returned null";
+        } else {
+            return 0;
+        }
+    }
+    FILE_LOG(logERROR) << "Could not convert hostname to internet address";
+    return 1;
+};
+
+/**
+ * Convert Internet Address structure pointer to ip string (char*)
+ * Clears the internet address structure as well
+ * @param res pointer to internet address structure
+ * @param ip pointer to char array to store result in
+ * @param ipsize size available in ip buffer
+ * @return 1 for fail, 0 for success
+ */
+// Do not make this static (for multi threading environment)
+int ConvertInternetAddresstoIpString(struct ::addrinfo *res, char *ip, const int ipsize) {
+    if (inet_ntop(res->ai_family, &((struct sockaddr_in *)res->ai_addr)->sin_addr, ip, ipsize) !=
+        NULL) {
+        ::freeaddrinfo(res);
+        return 0;
+    }
+    FILE_LOG(logERROR) << "Could not convert internet address to ip string";
+    return 1;
+}
+
+} // namespace sls

slsSupportLib/src/ServerInterface.cpp

@@ -0,0 +1,143 @@
+#include "ServerInterface.h"
+
+ServerInterface::ServerInterface(MySocketTCP *socket, int n, std::string t): mySocket(socket),
+																			 index(n),
+																			 type(t){}
+
+void ServerInterface::SetSocket(MySocketTCP *socket) {
+	mySocket = socket;
+}
+
+
+void ServerInterface::Client_Receive(int& ret, char* mess, void* retval, int sizeOfRetval) {
+    // get result of operation
+    mySocket->ReceiveDataOnly(&ret,sizeof(ret));
+
+    bool unrecognizedFunction = false;
+    if (ret == FAIL) {
+        bool created = false;
+        // allocate mess if null
+        if (!mess){
+            created = true;
+            mess = new char[MAX_STR_LENGTH];
+            memset(mess, 0, MAX_STR_LENGTH);
+        }
+        // get error message
+        mySocket->ReceiveDataOnly(mess,MAX_STR_LENGTH);
+        cprintf(RED, "%s %d returned error: %s", type.c_str(), index, mess);
+
+        // unrecognized function, do not ask for retval
+        if(strstr(mess,"Unrecognized Function") != nullptr)
+            unrecognizedFunction = true;
+        // delete allocated mess
+        if (created)
+            delete [] mess;
+    }
+    // get retval
+    if (!unrecognizedFunction)
+           mySocket->ReceiveDataOnly(retval, sizeOfRetval);
+}
+
+
+int ServerInterface::Client_Send(int fnum,
+		void* args, int sizeOfArgs,
+		void* retval, int sizeOfRetval,
+		char* mess) {
+    int ret = FAIL;
+    mySocket->SendDataOnly(&fnum,sizeof(fnum));
+    mySocket->SendDataOnly(args, sizeOfArgs);
+    Client_Receive(ret, mess, retval, sizeOfRetval);
+	return ret;
+}
+
+
+int ServerInterface::Server_SendResult(bool update, int ret,
+		void* retval, int retvalSize, char* mess) {
+
+	// update if different clients
+	if (update && ret == OK && mySocket->differentClients)
+		ret = FORCE_UPDATE;
+
+	// send success of operation
+	mySocket->SendDataOnly(&ret,sizeof(ret));
+	if(ret == FAIL) {
+		// send error message
+		if (mess)
+			mySocket->SendDataOnly(mess, MAX_STR_LENGTH);
+		// debugging feature. should not happen.
+		else
+			FILE_LOG(logERROR) << "No error message provided for this failure. Will mess up TCP\n";
+	}
+	// send return value
+	mySocket->SendDataOnly(retval, retvalSize);
+
+	return ret;
+}
+
+
+int ServerInterface::Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg, bool checkbase, void* base) {
+	// client socket crash, cannot receive arguments
+	if (sizeofArg && mySocket->ReceiveDataOnly(arg, sizeofArg) < 0)
+		return Server_SocketCrash();
+
+	// check if server object created
+	if (checkbase && base == nullptr)
+		Server_NullObjectError(ret, mess);
+
+	// no crash
+	return OK;
+}
+
+
+int ServerInterface::Server_VerifyLock(int& ret, char* mess, int lockstatus) {
+	// server locked
+	if (mySocket->differentClients && lockstatus)
+		return Server_LockedError(ret, mess);
+	return ret;
+}
+
+
+int ServerInterface::Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum) {
+	// server locked
+	if (mySocket->differentClients && lockstatus)
+		return Server_LockedError(ret, mess);
+
+	// server not idle for this command
+	if (status != slsDetectorDefs::IDLE)
+		return Server_NotIdleError(ret, mess, fnum);
+	return ret;
+}
+
+
+void ServerInterface::Server_NullObjectError(int& ret, char* mess) {
+	ret=FAIL;
+	strcpy(mess,"Receiver not set up. Please use rx_hostname first.\n");
+	FILE_LOG(logERROR) << mess;
+}
+
+
+int ServerInterface::Server_SocketCrash() {
+	FILE_LOG(logERROR) << "Reading from socket failed. Possible socket crash";
+	return FAIL;
+}
+
+
+int ServerInterface::Server_LockedError(int& ret, char* mess) {
+	ret = FAIL;
+	sprintf(mess,"Receiver locked by %s\n", mySocket->lastClientIP);
+	FILE_LOG(logERROR) << mess;
+	return ret;
+}
+
+
+int ServerInterface::Server_NotIdleError(int& ret, char* mess, int fnum) {
+	ret = FAIL;
+	sprintf(mess,"Can not execute %s when receiver is not idle\n",
+			getFunctionNameFromEnum((enum detFuncs)fnum));
+	FILE_LOG(logERROR) << mess;
+	return ret;
+}
+
+
+
+

slsSupportLib/src/ServerSocket.cpp

@@ -0,0 +1,79 @@
+#include "ServerSocket.h"
+#include "DataSocket.h"
+#include "logger.h"
+#include "sls_detector_defs.h"
+#include "sls_detector_exceptions.h"
+#include "string_utils.h"
+
+#include <arpa/inet.h>
+#include <iostream>
+#include <stdexcept>
+#include <unistd.h>
+#include <cstring>
+#define DEFAULT_PACKET_SIZE 1286
+#define SOCKET_BUFFER_SIZE (100 * 1024 * 1024) // 100 MB
+#define DEFAULT_BACKLOG 5
+
+namespace sls {
+
+ServerSocket::ServerSocket(int port)
+    : DataSocket(socket(AF_INET, SOCK_STREAM, 0)), serverPort(port) {
+
+    struct sockaddr_in serverAddr;
+    serverAddr.sin_family = AF_INET;
+    serverAddr.sin_port = htons(port);
+    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    if (bind(getSocketId(), (struct sockaddr *)&serverAddr,
+             sizeof(serverAddr)) != 0) {
+        close();
+        throw std::runtime_error("Server ERROR: cannot  bind socket");
+    }
+    if (listen(getSocketId(), DEFAULT_BACKLOG) != 0) {
+        close();
+        throw std::runtime_error("Server ERROR: cannot  listen to socket");
+    }
+}
+
+DataSocket ServerSocket::accept() {
+    struct sockaddr_in clientAddr;
+    socklen_t addr_size = sizeof clientAddr;
+    int newSocket =
+        ::accept(getSocketId(), (struct sockaddr *)&clientAddr, &addr_size);
+    if (newSocket == -1) {
+        throw std::runtime_error("Server ERROR: socket accept failed\n");
+    }
+    inet_ntop(AF_INET, &(clientAddr.sin_addr), &thisClient_.front(),
+              INET_ADDRSTRLEN);
+    std::cout << "lastClient: " << lastClient_ << " thisClient: " << thisClient_
+              << '\n';
+    // Here goes any check for locks etc
+    lastClient_ = thisClient_;
+
+    return DataSocket(newSocket);
+}
+
+const std::string &ServerSocket::getLastClient() { return lastClient_; }
+
+int ServerSocket::getPort() const { return serverPort; }
+
+void ServerSocket::SendResult(int &ret, void* retval, int retvalSize, char* mess) {
+
+	// send success of operation
+	sendData(&ret, sizeof(ret));
+
+    if (ret == slsDetectorDefs::FAIL) {
+        // create error message if empty
+        if (!strlen(mess))  {
+            strcpy(mess, "No error message provided for this failure in server. Will mess up TCP.");
+        }
+        
+        sendData(mess, MAX_STR_LENGTH);
+        throw sls::RuntimeError(mess);  
+    }
+    // send return value
+    sendData(retval, retvalSize);
+}
+
+
+}; // namespace sls

slsSupportLib/src/file_utils.cpp

@@ -0,0 +1,81 @@
+#include "file_utils.h"
+#include "logger.h"
+
+#include <iostream>
+#include <sstream>
+
+
+int readDataFile(std::ifstream &infile, short int *data, int nch, int offset) {
+	int ichan, iline=0;
+	short int idata;
+	int interrupt=0;
+	std::string str;
+	while (infile.good() and interrupt==0) {
+		getline(infile,str);
+		std::istringstream ssstr(str);
+		ssstr >> ichan >> idata;
+		if (ssstr.fail() || ssstr.bad()) {
+			interrupt=1;
+			break;
+		}
+		if (iline<nch) {
+			if (ichan>=offset) {
+				data[iline]=idata;
+				iline++;
+			}
+		} else {
+			interrupt=1;
+			break;
+		}
+		return iline;
+	};
+	return iline;
+}
+
+
+
+int readDataFile(std::string fname, short int *data, int nch) {
+	std::ifstream infile;
+	int iline=0;
+	std::string str;
+	infile.open(fname.c_str(), std::ios_base::in);
+	if (infile.is_open()) {
+		iline=readDataFile(infile, data, nch, 0);
+		infile.close();
+	} else {
+		FILE_LOG(logERROR) << "Could not read file " << fname;
+		return -1;
+	}
+	return iline;
+}
+
+
+
+int writeDataFile(std::ofstream &outfile,int nch,  short int *data, int offset) {
+	if (data==nullptr)
+		return slsDetectorDefs::FAIL;
+	for (int ichan=0; ichan<nch; ichan++)
+		outfile << ichan+offset << " " << *(data+ichan) << std::endl;
+	return slsDetectorDefs::OK;
+}
+
+
+int writeDataFile(std::string fname,int nch, short int *data) {
+	std::ofstream outfile;
+	if (data==nullptr)
+		return slsDetectorDefs::FAIL;
+	outfile.open (fname.c_str(),std::ios_base::out);
+	if (outfile.is_open())       {
+		writeDataFile(outfile, nch, data, 0);
+		outfile.close();
+		return slsDetectorDefs::OK;
+	} else {
+		FILE_LOG(logERROR) << "Could not open file " << fname << "for writing";
+		return slsDetectorDefs::FAIL;
+	}
+}
+
+
+
+
+

slsSupportLib/src/network_utils.cpp

@@ -0,0 +1,95 @@
+#include "sls_detector_exceptions.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <sstream>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include "network_utils.h"
+
+namespace sls {
+
+IpAddr::IpAddr(const std::string &address) {
+    inet_pton(AF_INET, address.c_str(), &addr_);
+}
+
+IpAddr::IpAddr(const char *address) { 
+    inet_pton(AF_INET, address, &addr_); 
+}
+
+std::string IpAddr::str() const {
+    char ipstring[INET_ADDRSTRLEN]{};
+    inet_ntop(AF_INET, &addr_, ipstring, INET_ADDRSTRLEN);
+    return ipstring;
+}
+std::string IpAddr::hex() const {
+    std::ostringstream ss;
+    ss << std::hex << std::setfill('0') << std::setw(2);
+    for (int i = 0; i != 4; ++i) {
+        ss << ((addr_ >> i * 8) & 0xFF);
+    }
+    return ss.str();
+}
+
+MacAddr::MacAddr(std::string mac) {
+    if ((mac.length() != 17) || (mac[2] != ':') || (mac[5] != ':') ||
+        (mac[8] != ':') || (mac[11] != ':') || (mac[14] != ':')) {
+        addr_ = 0;
+    } else {
+        mac.erase(std::remove(mac.begin(), mac.end(), ':'), mac.end());
+        addr_ = std::strtoul(mac.c_str(), nullptr, 16);
+    }
+}
+MacAddr::MacAddr(const char *address) : MacAddr(std::string(address)) {}
+
+std::string MacAddr::to_hex(const char delimiter) const {
+    std::ostringstream ss;
+    ss << std::hex << std::setfill('0') << std::setw(2);
+    ss << ((addr_ >> 40) & 0xFF);
+    for (int i = 32; i >= 0; i -= 8) {
+        if (delimiter)
+            ss << delimiter;
+        ss << ((addr_ >> i) & 0xFF);
+    }
+    return ss.str();
+}
+
+std::string MacAddr::str() const { 
+    return to_hex(':'); 
+}
+
+std::string MacAddr::hex() const { 
+    return to_hex(); 
+}
+
+std::ostream &operator<<(std::ostream &out, const IpAddr &addr) {
+    return out << addr.str();
+}
+
+std::ostream &operator<<(std::ostream &out, const MacAddr &addr) {
+    return out << addr.str();
+}
+
+uint32_t HostnameToIp(const char *hostname) {
+    addrinfo hints;
+    addrinfo *result = nullptr;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    if (getaddrinfo(hostname, NULL, &hints, &result)) {
+        freeaddrinfo(result);
+        throw RuntimeError("Could not convert hostname to ip");
+    }
+    uint32_t ip = ((sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
+    freeaddrinfo(result);
+    return ip;
+}
+
+} // namespace sls

slsSupportLib/src/string_utils.cpp

@@ -0,0 +1,54 @@
+
+#include "string_utils.h"
+#include "container_utils.h"
+#include "network_utils.h"
+#include <algorithm>
+#include <iomanip>
+#include <sstream>
+namespace sls {
+
+std::vector<std::string> split(const std::string &strToSplit, char delimeter) {
+    std::stringstream ss(strToSplit);
+    std::string item;
+    std::vector<std::string> splittedStrings;
+    while (std::getline(ss, item, delimeter)) {
+        splittedStrings.push_back(item);
+    }
+    return splittedStrings;
+}
+
+std::string concatenateNonEmptyStrings(const std::vector<std::string> &vec) {
+    std::string ret;
+    for (const auto &s : vec)
+        if (!s.empty())
+            ret += s + '+';
+    return ret;
+}
+
+std::string concatenateIfDifferent(const std::vector<std::string> &container) {
+    if (allEqual(container)) {
+        return container.front();
+    } else {
+        std::string result;
+        for (const auto &s : container)
+            result += s + '+';
+        return result;
+    }
+}
+template <typename T>
+std::string concatenateIfDifferent(const std::vector<T> &container) {
+    if (allEqual(container)) {
+        return container.front().str();
+    } else {
+        std::string result;
+        for (const auto &s : container)
+            result += s.str() + '+';
+        return result;
+    }
+}
+
+
+template std::string concatenateIfDifferent(const std::vector<IpAddr> &);
+template std::string concatenateIfDifferent(const std::vector<MacAddr> &);
+
+}; // namespace sls

slsSupportLib/tests/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(tests PRIVATE 
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-ClientInterface.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-CmdLineParser.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-container_utils.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-network_utils.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-string_utils.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-Timer.cpp
+                )

slsSupportLib/tests/test-ClientInterface.cpp

@@ -0,0 +1,12 @@
+#include "ClientInterface.h"
+#include "MySocketTCP.h"
+#include "catch.hpp"
+
+//tests to add
+//help for all docs
+//command for all depreciated commands
+
+TEST_CASE("hopp") {
+    REQUIRE(true);
+
+}

slsSupportLib/tests/test-CmdLineParser.cpp

@@ -0,0 +1,266 @@
+#include "CmdLineParser.h"
+#include "catch.hpp"
+#include <exception>
+#include <string>
+//tests to add
+//help for all docs
+//command for all depreciated commands
+
+TEST_CASE("Parse with no arguments results in no command and default id") {
+    //build up argc and argv
+    //first argument is the command used to call the binary
+    int argc = 1;
+    char *argv[argc];
+    char a0[] = "call";
+    argv[0] = static_cast<char *>(a0);
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command().empty());
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Parse empty string") {
+    std::string s;
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command().empty());
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Parse a command without client id and detector id results in default") {
+    int argc = 2;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "vrf";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Parse a string without client id and detector id results in default") {
+    std::string s = "vrf";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Parse a command with value but without client or detector id") {
+    int argc = 3;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "vrf";
+    char a2[] = "3000";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+    argv[2] = static_cast<char *>(a2);
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().size() == 1);
+    REQUIRE(p.arguments()[0] == "3000");
+}
+TEST_CASE("Parse a string with value but without client or detector id") {
+    std::string s = "vrf 3000\n";
+
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().size() == 1);
+    REQUIRE(p.arguments()[0] == "3000");
+}
+
+TEST_CASE("Decodes position") {
+    int argc = 2;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "7:vrf";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 7);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().empty());
+}
+TEST_CASE("Decodes position from string") {
+    std::string s = "7:vrf\n";
+
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 7);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Decodes double digit position") {
+    int argc = 2;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "73:vcmp";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 73);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vcmp");
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Decodes double digit position from string") {
+
+    std::string s = "73:vcmp";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 73);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == "vcmp");
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Decodes position and id") {
+    int argc = 2;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "5-8:vrf";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 5);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().empty());
+}
+TEST_CASE("Decodes position and id from string") {
+    std::string s = "5-8:vrf";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 5);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Double digit id") {
+    int argc = 2;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "56-8:vrf";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 56);
+    REQUIRE(p.command() == "vrf");
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Double digit id from string") {
+    std::string s = "56-8:vrf";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 56);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().empty());
+}
+
+TEST_CASE("Calling with wrong id throws invalid_argument") {
+
+    int argc = 2;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "asvldkn:vrf";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(argc, argv));
+}
+TEST_CASE("Calling with string with wrong id throws invalid_argument") {
+    std::string s = "asvldkn:vrf";
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(s));
+}
+
+TEST_CASE("Calling with wrong client throws invalid_argument") {
+    int argc = 2;
+    char *argv[argc];
+    char a0[] = "call";
+    char a1[] = "lki-3:vrf";
+    argv[0] = static_cast<char *>(a0);
+    argv[1] = static_cast<char *>(a1);
+
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(argc, argv));
+}
+TEST_CASE("Calling with string with wrong client throws invalid_argument") {
+    std::string s = "lki-3:vrf";
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(s));
+}
+
+TEST_CASE("Parses string with two arguments") {
+    std::string s = "trimen 3000 4000\n";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE("trimen" == p.command());
+    REQUIRE("3000" == p.arguments()[0]);
+    REQUIRE("4000" == p.arguments()[1]);
+    REQUIRE(p.arguments().size() == 2);
+}
+
+TEST_CASE("Build up argv"){
+    CmdLineParser p;
+    // p.argv();
+    REQUIRE(p.argv().empty());
+    REQUIRE(p.argv().data() == nullptr);
+
+    std::string s = "trimen 3000 4000\n";
+    p.Parse(s);
+    REQUIRE(p.argv().data() != nullptr);
+    REQUIRE(p.argv().size() == 3);
+
+}

slsSupportLib/tests/test-Timer.cpp

@@ -0,0 +1,23 @@
+#include "Timer.h"
+#include "catch.hpp"
+
+#include <chrono>
+#include <thread>
+
+TEST_CASE("Time 1s restart then time 2s") {
+    auto sleep_duration = std::chrono::seconds(1);
+    auto t = sls::Timer();
+    std::this_thread::sleep_for(sleep_duration);
+    REQUIRE(t.elapsed_s() == Approx(1).epsilon(0.01));
+
+    t.restart();
+    std::this_thread::sleep_for(sleep_duration * 2);
+    REQUIRE(t.elapsed_s() == Approx(2).epsilon(0.01));
+}
+
+TEST_CASE("Return ms") {
+    auto sleep_duration = std::chrono::milliseconds(1300);
+    auto t = sls::Timer();
+    std::this_thread::sleep_for(sleep_duration);
+    REQUIRE(t.elapsed_ms() == Approx(1300).epsilon(0.5));
+}

slsSupportLib/tests/test-container_utils.cpp

@@ -0,0 +1,125 @@
+#include "catch.hpp"
+#include "container_utils.h"
+#include <exception>
+#include <string>
+#include <vector>
+
+using namespace sls;
+
+TEST_CASE("Equality of an empty vector", "[support]") {
+    std::vector<int> v;
+    REQUIRE(v.empty());
+    REQUIRE_FALSE(allEqual(v));
+    REQUIRE_FALSE(allEqualWithTol(v, 2));
+    REQUIRE_FALSE(allEqualTo(v, 5));
+    REQUIRE_FALSE(anyEqualTo(v, 5));
+    REQUIRE_FALSE(anyEqualToWithTol(v, 5, 1));
+}
+
+TEST_CASE("Equality of a vector with one element", "[support]") {
+    std::vector<int> v{5};
+    REQUIRE(v.size() == 1);
+    REQUIRE(allEqual(v));
+    REQUIRE(allEqualWithTol(v, 1));
+    REQUIRE(allEqualTo(v, 5));
+    REQUIRE(allEqualToWithTol(v, 5, 2));
+    REQUIRE(anyEqualTo(v, 5));
+    REQUIRE(anyEqualToWithTol(v, 5, 1));
+}
+
+TEST_CASE("A larger vector of the same elements", "[support]") {
+    std::vector<int> v(101, 5);
+    REQUIRE(v.size() == 101);
+    REQUIRE(allEqual(v));
+    REQUIRE(allEqualWithTol(v, 1));
+    REQUIRE(allEqualTo(v, 5));
+    REQUIRE(anyEqualTo(v, 5));
+
+    SECTION("Push back another element to create a vector where not all are "
+            "equal") {
+        v.push_back(7);
+        REQUIRE(v.size() == 102);
+        REQUIRE_FALSE(allEqual(v));
+
+        REQUIRE_FALSE(allEqualWithTol(v, 1));
+        REQUIRE(allEqualWithTol(v, 3));
+
+        REQUIRE_FALSE(allEqualTo(v, 5));
+
+        REQUIRE_FALSE(allEqualToWithTol(v, 5, 1));
+        REQUIRE(allEqualToWithTol(v, 5, 3));
+        REQUIRE(anyEqualTo(v, 5));
+    }
+}
+
+TEST_CASE("A vector of double with different values", "[support]") {
+    std::vector<double> v{1.2, 2., 4.2, 4, 1.1};
+
+    REQUIRE(allEqual(v) == false);
+    REQUIRE(allEqualWithTol(v, 0.3) == false);
+    REQUIRE(allEqualWithTol(v, 3.2));
+}
+
+TEST_CASE("Sum of empty vector", "[support]") {
+    std::vector<float> v;
+    REQUIRE(sls::sum(v) == Approx(0));
+}
+
+TEST_CASE("Sum of vector", "[support]") {
+    std::vector<double> v{1.2, 2., 4.2, 4, 1.13};
+    REQUIRE(sls::sum(v) == Approx(12.53));
+}
+
+TEST_CASE("Minus one if different", "[support]") {
+    std::vector<double> v;
+    REQUIRE(v.empty());
+    double d = -1;
+    REQUIRE(sls::minusOneIfDifferent(v) == d);
+
+    SECTION("single element") {
+        v.push_back(7.3);
+        REQUIRE(v.size() == 1);
+        REQUIRE(sls::minusOneIfDifferent(v) == Approx(7.3));
+    }
+    SECTION("different elements") {
+        v.push_back(7.3);
+        v.push_back(1.0);
+        v.push_back(62.1);
+        REQUIRE(sls::minusOneIfDifferent(v) == Approx(-1.0));
+    }
+}
+
+TEST_CASE("minus one does not have side effects", "[support]") {
+    std::vector<int> v{1, 1, 1};
+    int i = sls::minusOneIfDifferent(v);
+    REQUIRE(i == 1);
+    i = 5;
+    REQUIRE(v[0] == 1);
+}
+
+TEST_CASE("Compare a vector containing two vectors", "[support]") {
+
+    std::vector<std::vector<int>> a{{0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 4, 5}};
+    std::vector<std::vector<int>> b{{0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 3, 5}};
+    std::vector<std::vector<int>> c{{0, 1, 2, 3, 4}, {0, 1, 2, 3, 3, 5}};
+    std::vector<std::vector<int>> d{
+        {0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}};
+    std::vector<int> e{0, 1, 2, 3, 4, 5};
+
+    CHECK(minusOneIfDifferent(a) == a[0]);
+    CHECK(minusOneIfDifferent(a) == e);
+    CHECK(minusOneIfDifferent(b) == std::vector<int>{-1});
+    CHECK(minusOneIfDifferent(c) == std::vector<int>{-1});
+    CHECK(minusOneIfDifferent(d) == d[2]);
+}
+
+
+TEST_CASE("vector of bool", "[support]"){
+    std::vector<bool> a{true, true, true};
+    std::vector<bool> b{false, false, false};
+    std::vector<bool> c{true, false, true};
+
+    CHECK(minusOneIfDifferent(a) == 1);
+    CHECK(minusOneIfDifferent(b) == 0);
+    CHECK(minusOneIfDifferent(c) == -1);
+}

slsSupportLib/tests/test-network_utils.cpp

@@ -0,0 +1,99 @@
+
+#include "catch.hpp"
+#include "network_utils.h"
+#include <iostream>
+#include <vector>
+
+#include "string_utils.h"
+#include "sls_detector_exceptions.h"
+
+using namespace sls;
+
+TEST_CASE("Convert mac address using classes", "[support]") {
+
+    std::vector<uint64_t> vec_addr{346856806822, 346856806852, 262027939863028};
+    std::vector<std::string> vec_ans{"00:50:c2:46:d9:a6", "00:50:c2:46:d9:c4",
+                                     "ee:50:22:46:d9:f4"};
+    for (size_t i = 0; i != vec_addr.size(); ++i) {
+        auto mac0 = MacAddr(vec_addr[i]);
+        auto mac1 = MacAddr(vec_ans[i]);
+
+        CHECK(mac0 == vec_addr[i]);
+        CHECK(mac1 == vec_addr[i]);
+        CHECK(mac0 == vec_ans[i]);
+        CHECK(mac1 == vec_ans[i]);
+        CHECK(mac0.str() == vec_ans[i]);
+        CHECK(mac1.str() == vec_ans[i]);
+    }
+}
+
+TEST_CASE("Hex representation of MAC", "[support]") {
+    MacAddr m{346856806822};
+    CHECK(m.hex() == "0050c246d9a6");
+    CHECK(m.str() == "00:50:c2:46:d9:a6");
+    CHECK_FALSE(m == 7);
+
+    MacAddr m2{"00:50:c2:46:d9:c4"};
+    CHECK(m2 == 346856806852);
+    CHECK(m2.hex() == "0050c246d9c4");
+    CHECK(m2.str() == "00:50:c2:46:d9:c4");
+
+    CHECK_FALSE(m2 == 3);
+}
+
+TEST_CASE("Convert IP using classes ", "[support]") {
+    std::vector<uint32_t> vec_addr{4073554305, 2747957633, 2697625985};
+    std::vector<std::string> vec_ans{"129.129.205.242", "129.129.202.163",
+                                     "129.129.202.160"};
+
+    for (size_t i = 0; i != vec_addr.size(); ++i) {
+        auto ip0 = IpAddr(vec_addr[i]);
+        auto ip1 = IpAddr(vec_ans[i]);
+
+        CHECK(ip0 == ip1);
+        CHECK(ip0 == vec_addr[i]);
+        CHECK(ip1 == vec_addr[i]);
+        CHECK(ip0 == vec_ans[i]);
+        CHECK(ip1 == vec_ans[i]);
+        CHECK(ip0.str() == vec_ans[i]);
+        CHECK(ip1.str() == vec_ans[i]);
+    }
+}
+
+TEST_CASE("Strange input gives 0", "[support]") {
+    CHECK(IpAddr("hej") == 0);
+    CHECK(MacAddr("hej") == 0);
+}
+
+TEST_CASE("Convert to uint for sending over network", "[support]") {
+    MacAddr addr{346856806822};
+    uint64_t a = addr.uint64();
+    CHECK(a == 346856806822);
+
+    IpAddr addr2{"129.129.205.242"};
+    uint32_t b = addr2.uint32();
+    CHECK(b == 4073554305);
+}
+
+TEST_CASE("Hostname lookup failed throws", "[support]"){
+    CHECK_THROWS_AS(HostnameToIp("pippifax"), RuntimeError);
+}
+
+TEST_CASE("IP Output operator gives same result as string", "[support]") {
+    IpAddr addr{"129.129.205.242"};
+    std::ostringstream os;
+    os << addr;
+    CHECK(os.str() == "129.129.205.242");
+    CHECK(os.str() == addr.str());
+
+}
+
+TEST_CASE("MAC Output operator gives same result as string", "[support]") {
+    MacAddr addr{"00:50:c2:46:d9:a6"};
+    std::ostringstream os;
+    os << addr;
+    CHECK(os.str() == "00:50:c2:46:d9:a6");
+    CHECK(os.str() == addr.str());
+}
+
+//TODO!(Erik) Look up a real hostname and verify the IP

slsSupportLib/tests/test-string_utils.cpp

@@ -0,0 +1,112 @@
+#include "MySocketTCP.h"
+#include "catch.hpp"
+#include "logger.h"
+#include <iostream>
+#include <vector>
+
+#include "string_utils.h"
+
+
+TEST_CASE("copy a string") {
+
+    char src[10] = "hej";
+    REQUIRE(src[3]=='\0');
+
+    char dst[20];
+
+    sls::strcpy_safe(dst, src);
+    REQUIRE(dst[0]=='h');
+    REQUIRE(dst[1]=='e');
+    REQUIRE(dst[2]=='j');
+    REQUIRE(dst[3]=='\0');
+
+}
+
+	
+#ifdef NDEBUG
+//This test can only run in release since we assert on the length of the string
+TEST_CASE("copy a long string"){
+    auto src = "some very very long sting that does not fit";
+    char dst[3];
+    sls::strcpy_safe(dst, src);
+    REQUIRE(dst[0]=='s');
+    REQUIRE(dst[1]=='o');
+    REQUIRE(dst[2]=='\0');
+    
+}
+#endif
+TEST_CASE("Concat") {
+  std::vector<std::string> v{"one", "one", "one"};
+  std::vector<std::string> v2{"one", "one", "one"};
+  auto r = sls::concatenateIfDifferent(v);
+  REQUIRE(r == std::string("one"));
+  r.clear();
+
+  // make sure we didn't modify the string
+  REQUIRE(v == v2);
+
+  SECTION("add a different value"){
+      v.emplace_back("two");
+      REQUIRE(v!=v2);
+      REQUIRE( sls::concatenateIfDifferent(v) == "one+one+one+two+");
+  }
+}
+
+TEST_CASE("split a string with end delimiter"){
+  std::string s("abra+kadabra+");
+  auto r =sls::split(s, '+');
+  REQUIRE(r.size()==2);
+  REQUIRE(r[0]=="abra");
+  REQUIRE(r[1]=="kadabra");
+}
+
+TEST_CASE("split a string without end delimiter"){
+  std::string s("abra+kadabra+filibom");
+  auto r =sls::split(s, '+');
+  REQUIRE(r.size()==3);
+  REQUIRE(r[0]=="abra");
+  REQUIRE(r[1]=="kadabra");
+  REQUIRE(r[2]=="filibom");
+}
+
+TEST_CASE("concatenate non empty strings"){
+  std::vector<std::string> vec{"hej", "kalas", "", "foto"};
+  REQUIRE(vec.size()==4);
+  auto ret = sls::concatenateNonEmptyStrings(vec);
+  REQUIRE(ret == "hej+kalas+foto+");
+}
+
+TEST_CASE("concatenate non empty strings with only emty"){
+  std::vector<std::string> vec{"", "", ""};
+  REQUIRE(vec.size()==3);
+  auto ret = sls::concatenateNonEmptyStrings(vec);
+  REQUIRE(ret.empty());
+}
+
+TEST_CASE("concatenate non empty strings with one element"){
+  std::vector<std::string> vec{"", "hej", "", "", ""};
+  REQUIRE(vec.size()==5);
+  auto ret = sls::concatenateNonEmptyStrings(vec);
+  REQUIRE(ret=="hej+");
+}
+
+
+TEST_CASE("Remove char from string"){
+  char str[] = "sometest"; 
+  sls::removeChar(str, 'e');
+  REQUIRE(std::string(str) == "somtst");
+}
+
+TEST_CASE("Remove char from empty string"){
+  char str[50] = {}; 
+  sls::removeChar(str, 'e');
+  REQUIRE(std::string(str) == "");
+}
+
+TEST_CASE("Many characters in a row"){
+  char str[] = "someeequitellll::ongstring"; 
+  sls::removeChar(str, 'l');
+  REQUIRE(std::string(str) == "someeequite::ongstring");
+}
+
+// TEST_CASE("concat things not being strings")