Merge remote branch 'slsReceiverSoftware/2.2' into 2.2

slsReceiverSoftware/.gitignore

@@ -0,0 +1,7 @@
+*~
+*.o
+build/*
+GPATH
+GRTAGS
+GSYMS
+GTAGS

slsReceiverSoftware/CMakeLists.txt

@@ -0,0 +1,56 @@
+set(SOURCES
+    src/MySocketTCP.cpp
+    src/UDPInterface.cpp
+    src/UDPBaseImplementation.cpp
+    src/UDPStandardImplementation.cpp
+    src/slsReceiverTCPIPInterface.cpp
+    src/slsReceiver.cpp
+    src/slsReceiverUsers.cpp
+    src/utilities.cpp
+)
+
+add_definitions(
+    -DDACS_INT  -DSLS_RECEIVER_UDP_FUNCTIONS
+)
+
+include_directories(
+    include
+    ../slsDetectorCalibration
+)
+
+add_library(zmq STATIC IMPORTED )
+
+set_target_properties(zmq PROPERTIES
+    IMPORTED_LOCATION ${CMAKE_CURRENT_SOURCE_DIR}/include/libzmq.a
+)
+
+add_library(slsReceiverStatic STATIC
+    ${SOURCES}
+    ${HEADERS}
+)
+set_target_properties(slsReceiverStatic PROPERTIES
+    ARCHIVE_OUTPUT_NAME SlsReceiver
+    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+)
+
+add_library(slsReceiverShared SHARED
+    ${SOURCES}
+    ${HEADERS}
+)
+set_target_properties(slsReceiverShared PROPERTIES
+    LIBRARY_OUTPUT_NAME SlsReceiver
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+)
+
+add_executable(slsReceiver
+    src/main.cpp
+)
+set_target_properties(slsReceiver PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+)
+target_link_libraries(slsReceiver
+    slsReceiverShared
+    pthread
+    zmq
+    rt
+)

slsReceiverSoftware/Makefile

@@ -0,0 +1,118 @@
+include ../Makefile.include
+
+DESTDIR		?=	../bin
+LIBDIR	 	?= 	$(DESTDIR)
+DOCDIR 		?= 	docs
+SRCDIR		=	src
+TESTDIR		=	test
+BUILDDIR	=	build
+PROGS		= 	$(DESTDIR)/slsReceiver 
+
+
+CFLAGS= -g -DC_ONLY -fPIC
+#FLAGS+=  #-DVERBOSE -DVERYVERBOSE
+
+DFLAGS= -g -DDACS_INT  -DSLS_RECEIVER_UDP_FUNCTIONS #-DVERBOSE
+
+INCLUDES?= $(INCLUDESRXR) -I include/ -I ../slsDetectorCalibration
+
+LIBZMQDIR = include
+LIBZMQ =  -L$(LIBZMQDIR) -Wl,-rpath=$(LIBZMQDIR) -lzmq
+
+#-Iinclude -I../slsDetectorCalibration -I$(ASM) 
+
+SRC_CLNT = MySocketTCP.cpp UDPInterface.cpp  UDPBaseImplementation.cpp UDPStandardImplementation.cpp slsReceiverTCPIPInterface.cpp slsReceiver.cpp slsReceiverUsers.cpp utilities.cpp 
+
+ifeq ($(REST), yes)
+	SRC_CLNT += UDPRESTImplementation.cpp
+endif
+
+MAIN_SRC = main.cpp
+
+DUMMY_MAIN_SRC = dummyMain.cpp
+
+OBJS=$(SRC_CLNT:%.cpp=$(BUILDDIR)/%.o) 
+
+
+$(info )
+$(info #######################################)
+$(info #    Compiling slsReceiverSoftware    #)
+$(info #######################################)
+$(info )
+
+
+.PHONY: all intdoc  package eigerReceiver clean
+
+all: builddir lib receiver
+
+dummy: $(DESTDIR)/dummyReceiver
+
+intdoc: $(SRC_H) $(SRC_CLNT) 
+	doxygen doxy.config
+
+$(BUILDDIR)/%.o : $(SRCDIR)/%.cpp Makefile
+ifeq ($(ROOTSLS),yes)
+	$(CXX) -DROOTSLS -o $@ -c $< $(INCLUDES) $(DFLAGS)  $(ROOTFLAGS) -fPIC  $(EPICSFLAGS) $(LDFLAGRXR) -L/usr/lib64/ $(FLAGS) 
+else	
+	$(CXX) -o $@ -c $< $(INCLUDES) $(DFLAGS) -fPIC  $(EPICSFLAGS) $(LDFLAGRXR) -lpthread $(FLAGS) $(LIBZMQ)  -lrt 
+endif
+
+lib:  $(OBJS) $(DESTDIR)/libSlsReceiver.so $(DESTDIR)/libSlsReceiver.a 
+
+receiver: $(DESTDIR)/slsReceiver
+
+
+$(DESTDIR)/libSlsReceiver.so: $(OBJS) 
+	$(CXX)  -shared -Wl,-soname,libSlsReceiver.so -o libSlsReceiver.so  $(OBJS) -lc $(INCLUDES) $(DFLAGS) $(FLAGS) $(EPICSFLAGS)  -L/usr/lib64 -lpthread $(LIBZMQ) -lrt 
+	$(shell test -d $(DESTDIR) || mkdir -p $(DESTDIR))
+	mv libSlsReceiver.so $(DESTDIR)
+
+$(DESTDIR)/libSlsReceiver.a: $(OBJS) 
+	ar  rcs libSlsReceiver.a  $(OBJS) 
+	mv libSlsReceiver.a $(DESTDIR)
+
+
+$(DESTDIR)/slsReceiver: 	lib
+	$(CXX)   -o $@  $(SRCDIR)/$(MAIN_SRC)  $(FLAGS)  $(INCLUDES) $(CLAGS) $(LIBS) $(LDFLAGRXR) -fPIC  $(LIBZMQ) -lrt 
+#$(EIGERFLAGS)
+
+
+$(DESTDIR)/dummyReceiver: 	lib
+	$(CXX)   -o $@  $(SRCDIR)/$(DUMMY_MAIN_SRC)  $(FLAGS)  $(INCLUDES) $(CLAGS) $(LIBS) $(LDFLAGRXR) -fPIC $(LIBZMQ)  -lrt 
+#$(EIGERFLAGS)
+
+
+# Stand-alone Mysocket tests
+mysocket_test:
+	g++ -o $(TESTDIR)/MySocketTCP.o -c $(SRCDIR)/MySocketTCP.cpp -I include
+	g++ -o $(TESTDIR)/rec $(TESTDIR)/MySocketTCP.o $(TESTDIR)/rec.cxx -I include
+	g++ -o $(TESTDIR)/send $(TESTDIR)/MySocketTCP.o $(TESTDIR)/send.cxx -I include
+
+
+clean: buildclean
+	make testclean
+	if test -e $(DESTDIR)/libSlsReceiver.a; then rm $(DESTDIR)/libSlsReceiver.a;fi
+	if test -e $(DESTDIR)/libSlsReceiver.so; then rm $(DESTDIR)/libSlsReceiver.so;fi
+	if test -e $(PROGS); then rm $(PROGS);fi
+
+builddir:
+	if [ ! -d $(BUILDDIR) ]; then mkdir $(BUILDDIR); fi
+
+buildclean:
+	rm -rf $(OBJS)		
+
+testclean:
+	if [ -f $(TESTDIR)/rec ]; then \
+		cd $(TESTDIR) && rm *.o rec send; \
+	fi
+
+
+#-------------------------------------------------------------------------------
+
+install: package
+
+install_inc:
+	$(shell test -d $(DESTDIR) || mkdir -p $(DESTDIR))
+	cp -P slsReceiver/slsReceiverUsers.h $(DESTDIR)
+
+

slsReceiverSoftware/gitInfo.txt

@@ -0,0 +1,9 @@
+Path: slsDetectorsPackage/slsReceiverSoftware 
+URL: origin git@git.psi.ch:sls_detectors_software/sls_receiver_software.git 
+Repository Root: origin git@git.psi.ch:sls_detectors_software/sls_receiver_software.git 
+Repsitory UUID: 2f78f4e118bfba443f84a3f72b2839610a8858a3 
+Revision: 493 
+Branch: developer 
+Last Changed Author: Dhanya_Maliakal 
+Last Changed Rev: 493 
+Last Changed Date: 2016-11-30 10:36:46 +0100

slsReceiverSoftware/include/MySocketTCP.h

@@ -0,0 +1,79 @@
+
+#ifndef MY_SOCKET_TCP_H
+#define MY_SOCKET_TCP_H 
+
+
+
+
+/**
+ * 
+ * @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:
+  MySocketTCP(const char* const host_ip_or_name, unsigned short int const port_number):  genericSocket(host_ip_or_name, port_number,TCP), last_keep_connection_open_action_was_a_send(0){setPacketSize(TCP_PACKET_SIZE);}; // sender (client): where to? ip
+    MySocketTCP(unsigned short int const port_number):genericSocket(port_number,TCP), last_keep_connection_open_action_was_a_send(0) {setPacketSize(TCP_PACKET_SIZE);}; // receiver (server) local no need for ip
+
+
+  //The following two functions will connectioned->send/receive->disconnect
+  int  SendData(void* buf,int length);//length in characters
+  int  ReceiveData(void* buf,int length);
+ 
+
+  //The following two functions stay connected, blocking other connections, and must be manually disconnected,
+  //          when the last call is a SendData() or ReceiveData() the disconnection will be done automatically
+  //These function will also automatically disconnect->reconnect if
+  //          two reads (or two writes) are called in a row to preserve the data send/receive structure 
+  int  SendDataAndKeepConnection(void* buf,int length);
+  int  ReceiveDataAndKeepConnection(void* buf,int length);
+
+ private:
+
+
+  bool last_keep_connection_open_action_was_a_send;
+
+
+};
+#endif

slsReceiverSoftware/include/RestHelper.h

@@ -0,0 +1,307 @@
+/**
+ * @file   RestHelper.h
+ * @author Leonardo Sala <leonardo.sala@psi.ch>
+ * @date   Tue Mar 25 09:28:19 2014
+ * 
+ * @brief  
+ * 
+ * 
+ */
+
+#include <Poco/Net/HTTPClientSession.h>
+#include <Poco/Net/HTTPRequest.h>
+#include <Poco/Net/HTTPResponse.h>
+#include <Poco/StreamCopier.h>
+#include <Poco/Path.h>
+#include <Poco/URI.h>
+#include <Poco/Exception.h>
+#include <Poco/Timespan.h>
+
+#include "JsonBox/Value.h"
+#include "JsonBox/JsonParsingError.h"
+
+//#include "logger.h"
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <exception>
+#include <unistd.h>
+
+
+
+using namespace Poco::Net;
+using namespace Poco;
+using namespace std;
+
+class RestHelper {
+ public:
+
+  RestHelper(int timeout=10, int n_tries=1){    
+  /** 
+   * 
+   * 
+   * @param timeout default=10
+   * @param n_tries default=1
+   */
+
+    http_timeout = timeout;
+    n_connection_tries = n_tries;
+  }
+
+  ~RestHelper(){
+	  delete session;
+  };
+
+
+  void set_connection_params(int timeout, int n_tries){
+    http_timeout = timeout;
+    n_connection_tries = n_tries;
+  }
+
+
+  void get_connection_params(int *timeout, int *n_tries){
+    *timeout = http_timeout;
+    *n_tries = n_connection_tries;
+    
+  }
+
+
+  void init(string hostname, int port){
+	  /** Initialize the RestHelper. Hostname and port parameters are not supposed to change.
+	   *  
+	   * 
+	   * @param hostname FQDN of the host to connect to , e.g. www.iamfake.org, or sodoi.org
+	   * @param port 
+	   * 
+	   * @return 
+	   */
+
+	  //Check for http:// string
+	  string proto_str = "http://";
+	  
+	  if( size_t found = hostname.find(proto_str) != string::npos ){
+		  char c1[hostname.size()-found-1];
+		  size_t length1 = hostname.copy(c1, hostname.size()-found-1, proto_str.size());
+	 	  c1[length1]='\0';
+		  hostname = c1;
+	  }
+	  
+	  full_hostname = "http://"+hostname;
+	  session = new HTTPClientSession(hostname, port );
+	  session->setKeepAliveTimeout( Timespan( http_timeout,0) );
+  };
+
+
+  void init(string hostname_port){
+	  /** Initialize the RestHelper. Hostname_port parameters are not supposed to change.
+	   *  
+	   * 
+	   * @param hostname FQDN and port of the host to connect to , e.g. www.iamfake.org:8080, or sodoi.org:1111. Default port is 8080
+	   * 
+	   * @return 
+	   */
+	  
+	  //Check for http:// string
+	  string proto_str = "http://";
+	  if( size_t found = hostname_port.find(proto_str) != string::npos ){
+		  char c1[hostname_port.size()-found-1];
+		  size_t length1 = hostname_port.copy(c1, hostname_port.size()-found-1, proto_str.size());
+	 	  c1[length1]='\0';
+		  hostname_port = c1;
+	  }
+
+	  size_t found = hostname_port.rfind(":");
+	  char c1[ found ], c2[hostname_port.size()-found-1];
+	  string hostname;
+	  size_t length1 = hostname_port.copy(c1, found);
+	 
+	  c1[length1]='\0';
+	  hostname = c1;
+	  size_t length2 = hostname_port.copy(c2, found-1, found+1);
+	  c2[length2]='\0';
+	  int port = atoi(c2);
+
+	  full_hostname = proto_str+hostname;
+	  session = new HTTPClientSession(hostname,port );
+	  session->setKeepAliveTimeout( Timespan( http_timeout,0) );
+  };
+  
+
+  int get_json(string request, string* answer){
+    /** Retrieves a reply from the RESTful webservice. 
+     * 
+     * 
+     * @param request Request without the hostname, e.g. if the full request would have been http://fake.org/fakemethod, request=fakemethod
+     * @param answer 
+     * 
+     * @return 0 if successful, -1 if failure happens.
+     */    
+    URI * uri = new URI(full_hostname+"/"+request);
+    string path(uri->getPathAndQuery());
+    if (path.empty()) path = "/";
+
+    // send request
+    HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
+    req.setContentType("application/json\r\n");
+    int code = send_request(session, req, answer);
+    delete uri;
+    return code;
+  };
+
+
+  int get_json(string request,  JsonBox::Value* json_value){
+    /** 
+     * 
+     * 
+     * @param request 
+     * @param json_value 
+     * 
+     * @return 
+     */    
+    URI *uri = new URI(full_hostname+"/"+request);
+    string path(uri->getPathAndQuery());
+    if (path.empty()) path = "/";
+    // send request
+    HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
+    req.setContentType("application/json\r\n");
+    string answer;
+    int code = send_request(session, req, &answer);
+    if(code == 0 ) {
+      FILE_LOG(logDEBUG) << __AT__ << " REQUEST: " << " ANSWER: " << answer;
+      json_value->loadFromString(answer);
+    }
+    delete uri;
+    return code;
+  };
+
+
+  int post_json(string request, string *answer, string request_body="{}"){
+    /** 
+     * 
+     * 
+     * @param request 
+     * @param answer 
+     * @param request_body Eventual arguments to the URL, e.g. action=login&name=mammamia
+     * 
+     * @return 
+     */
+    //from: http://stackoverflow.com/questions/1499086/poco-c-net-ssl-how-to-post-https-request
+    URI *uri = new URI(full_hostname+"/"+request);
+    string path(uri->getPathAndQuery());
+    if (path.empty()) path = "/";
+    HTTPRequest req(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1 );
+    req.setContentType("application/json\r\n");
+    req.setContentLength( request_body.length() );
+    int code = send_request(session, req, answer, request_body);
+    
+    delete uri;
+    return code;
+  }
+
+
+  int post_json(string request,  JsonBox::Value* json_value, string request_body="{}"){
+    /** 
+     * 
+     * 
+     * @param request 
+     * @param json_value 
+     * @param request_body Eventual arguments to the URL, e.g. action=login&name=mammamia
+     * 
+     * @return 
+     */
+
+    URI *uri = new URI(full_hostname+"/"+request);
+    string path(uri->getPathAndQuery());
+    if (path.empty()) path = "/";
+    HTTPRequest req(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1 );
+    //this does not work
+    //req.setContentType("application/json\r\n");
+    //req.setContentLength( request.length() );
+    string answer;
+    int code = send_request(session, req, &answer, request_body);
+    if(code==0){
+      try{
+	json_value->loadFromString(answer);
+      }
+      catch (JsonBox::JsonParsingError& e){
+	try{
+	  json_value->loadFromString("{\"global_state\":\"" + answer + "\"}");
+	}
+	catch(exception &e){
+	  FILE_LOG(logERROR) << "Exception converting answer: " << e.what() ;
+	}
+      }
+    }
+    delete uri;
+    return code;
+  }
+    
+
+ private:
+
+  HTTPClientSession *session;
+  string full_hostname;
+  /// HTTP timeout in seconds, default is 8
+  int http_timeout; 
+  /// Number of connection tries
+  int n_connection_tries;
+
+
+  int send_request(HTTPClientSession *session, HTTPRequest &req, string *answer, string request_body=""){
+    /** 
+     * 
+     * 
+     * @param session 
+     * @param req 
+     * @param answer 
+     * @param request_body 
+     * 
+     * @return 
+     */
+    
+    int n = 0;
+    int code = -1;
+    while(n < n_connection_tries){
+	    
+	    req.setContentType("application/json");
+	    //without this you need to tell the lenght: http://pocoproject.org/forum/viewtopic.php?f=12&t=5741&p=10019&hilit=post+json#p10019
+	    // request.setContentLength(my_string.length());
+	    req.setChunkedTransferEncoding(true);
+	    try {
+		    //istringstream rs(request_body);
+		    //req.read(rs);
+		    //cout << " --- " <<  rs << endl;
+		    if (request_body == "")
+			    session->sendRequest( (req) );
+		    else{
+			    ostream &os = session->sendRequest( req ) ;
+			    os << request_body;
+		    }
+		    
+		    HTTPResponse res;
+		    istream &is = session->receiveResponse(res);
+		    StreamCopier::copyToString(is, *answer);
+		    code = res.getStatus();
+		    if (code != 200){
+			    FILE_LOG(logERROR) << "HTTP ERROR " << res.getStatus() << ": " << res.getReason() ;
+			    code = -1;
+		    }
+		    else
+			    code = 0;
+		    return code;
+	    }
+	    catch (exception& e){
+		    FILE_LOG(logERROR) << "Exception connecting to "<< full_hostname << ": "<< e.what() << ", sleeping 5 seconds (" << n << "/"<<n_connection_tries << ")";
+		    sleep(5);
+	    }
+	    n+=1;
+    }
+    
+    std::cout << "Hostname: " << full_hostname << std::endl;
+    FILE_LOG(logERROR) << "Cannot connect to the REST server host " <<  full_hostname << "! Please check..." ; 
+    throw std::runtime_error("Cannot connect to the REST server! Please check...");
+    //return code;
+  }
+
+};

slsReceiverSoftware/include/UDPBaseImplementation.h

@@ -0,0 +1,646 @@
+//#ifdef UDP_BASE_IMPLEMENTATION
+#ifndef UDP_BASE_IMPLEMENTATION_H
+#define UDP_BASE_IMPLEMENTATION_H
+/********************************************//**
+ * @file UDPBaseImplementation.h
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ ***********************************************/
+
+
+//#include "sls_receiver_defs.h"
+#include "UDPInterface.h"
+//#include <stdio.h>
+
+/**
+ * @short does all the base functions for a receiver, set/get parameters, start/stop etc.
+ */
+
+class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInterface {
+	
+ public:
+
+	/*************************************************************************
+	 * Constructor & Destructor **********************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+	/**
+	 * Constructor
+	 */
+	UDPBaseImplementation();
+
+	/**
+	 * Destructor
+	 */
+	virtual ~UDPBaseImplementation();
+
+	/*
+	 * Initialize class members
+	 */
+	void initializeMembers();
+
+	/*************************************************************************
+	 * Getters ***************************************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+
+	//**initial parameters***
+	/*
+	 * Get detector hostname
+	 * @return NULL or hostname or NULL if uninitialized (max of 1000 characters)
+	 */
+	char *getDetectorHostname() const;
+
+	/*
+	 * Get flipped data across 'axis'
+	 * @return if data is flipped across 'axis'
+	 */
+	int getFlippedData(int axis=0) const;
+
+
+	//***file parameters***
+	/**
+	 * Get File Name Prefix (without frame index, file index and extension (_d0_f000000000000_8.raw))
+	 * @return NULL or file name prefix (max of 1000 characters)
+	 */
+	char *getFileName() const;
+
+	/**
+	 * Get File Path
+	 * @return NULL or file path (max of 1000 characters)
+	 */
+	char *getFilePath() const;
+
+	/**
+	 * Get File Index
+	 * @return file index of acquisition
+	 */
+	uint64_t getFileIndex() const;
+
+	/**
+	 * Get Scan Tag
+	 * @return scan tag //FIXME: needed? (unsigned integer?)
+	 */
+	int getScanTag() const;
+
+	/**
+	 * Get if Frame Index is enabled (acquisition of more than 1 frame adds '_f000000000000' to file name )
+	 * @return true if frame index needed, else false
+	 */
+	bool getFrameIndexEnable() const;
+
+	/**
+	 * Get File Write Enable
+	 * @return true if file write enabled, else false
+	 */
+	bool getFileWriteEnable() const;
+
+	/**
+	 * Get File Over Write Enable
+	 * @return true if file over write enabled, else false
+	 */
+	bool getOverwriteEnable() const;
+
+	/**
+	 * Get data compression, by saving only hits (so far implemented only for Moench and Gotthard)
+	 * @return true if data compression enabled, else false
+	 */
+	bool getDataCompressionEnable() const;
+
+
+	//***acquisition count parameters***
+	/**
+	 * Get Total Frames Caught for an entire acquisition (including all scans)
+	 * @return total number of frames caught for entire acquisition
+	 */
+	uint64_t getTotalFramesCaught() const;
+
+	/**
+	 * Get Frames Caught for each real time acquisition (eg. for each scan)
+	 * @return number of frames caught for each scan
+	 */
+	uint64_t getFramesCaught() const;
+
+	/**
+	 * Get Current Frame Index for an entire  acquisition (including all scans)
+	 * @return current frame index (represents all scans too)
+	 */
+	int64_t getAcquisitionIndex() const;
+
+
+	//***connection parameters***
+	/**
+	 * Get UDP Port Number
+	 * @return udp port number
+	 */
+	uint32_t getUDPPortNumber() const;
+
+	/**
+	 * Get Second UDP Port Number (eiger specific)
+	 * @return second udp port number
+	 */
+	uint32_t getUDPPortNumber2() const;
+
+	/**
+	 * Get Ehernet Interface
+	 * @ethernet interface. eg. eth0 or "" if listening to all (max of 1000 characters)
+	 */
+	char *getEthernetInterface() const;
+
+
+	//***acquisition parameters***
+	/**
+	 * Get Short Frame Enabled, later will be moved to getROI (so far only for gotthard)
+	 * @return index of adc enabled, else -1 if all enabled
+	 */
+	int getShortFrameEnable() const;
+
+	/**
+	 * Get the Frequency of Frames Sent to GUI
+	 * @return 0 for random frame requests, n for nth frame frequency
+	 */
+	uint32_t getFrameToGuiFrequency() const;
+
+	/**
+	 * Gets the timer between frames streamed when frequency is set to 0
+	 * @return timer between frames streamed
+	 */
+	uint32_t getFrameToGuiTimer() const;
+
+	/**
+	 * Get the data stream enable
+	 * @return 1 to send via zmq, else 0
+	 */
+	uint32_t getDataStreamEnable() const;
+
+
+	/**
+	 * Get Acquisition Period
+	 * @return acquisition period
+	 */
+	uint64_t getAcquisitionPeriod() const;
+
+	/**
+	 * Get Acquisition Time
+	 * @return acquisition time
+	 */
+	uint64_t getAcquisitionTime() const;
+
+	/*
+	 * Get Number of Frames expected by receiver from detector
+	 * The data receiver status will change from running to idle when it gets this number of frames FIXME: (Not implemented)
+	 * @return number of frames expected
+	 */
+	uint64_t getNumberOfFrames() const;
+
+	/**
+	 * Get Dynamic Range or Number of Bits Per Pixel
+	 * @return dynamic range that is 4, 8, 16 or 32
+	 */
+	uint32_t getDynamicRange() const;
+
+	/**
+	 * Get Ten Giga Enable
+	 * @return true if 10Giga enabled, else false (1G enabled)
+	 */
+	bool getTenGigaEnable() const;
+
+	/**
+	 * Get Fifo Depth
+	 * @return fifo depth
+	 */
+	uint32_t getFifoDepth() const;
+
+
+	//***receiver status***
+	/**
+	 * Get Listening Status of Receiver
+	 * @return can be idle, listening or error depending on if the receiver is listening or not
+	 */
+	runStatus getStatus() const;
+
+	/**
+	 * Get activate
+	 * If deactivated, receiver will write dummy packets 0xFF
+	 * (as it will receive nothing from detector)
+	 * @return 0 for deactivated, 1 for activated
+	 */
+	int getActivate() const;
+
+
+
+	/*************************************************************************
+	 * Setters ***************************************************************
+	 * They modify the local cache of configuration or detector parameters ***
+	 *************************************************************************/
+
+	//**initial parameters***
+	/**
+	 * Configure command line parameters
+	 * @param config_map mapping of config parameters passed from command line arguments
+	 */
+	void configure(map<string, string> config_map);
+
+	/*
+	 * Get flipped data across 'axis'
+	 * @return if data is flipped across 'axis'
+	 */
+	void setFlippedData(int axis=0, int enable=-1);
+
+
+	//***file parameters***
+	/**
+	 * Set File Name Prefix (without frame index, file index and extension (_d0_f000000000000_8.raw))
+	 * Does not check for file existence since it is created only at startReceiver
+	 * @param c file name (max of 1000 characters)
+	 */
+	void setFileName(const char c[]);
+
+	/**
+	 * Set File Path
+	 * Checks for file directory existence before setting file path,
+	 * If it doesn't exist, it will set it blank
+	 * @param c file path (max of 1000 characters)
+	 */
+	void setFilePath(const char c[]);
+
+	/**
+	 * Set File Index of acquisition
+	 * @param i file index of acquisition
+	 */
+	void setFileIndex(const uint64_t i);
+
+	/**
+	 * Set Scan Tag
+	 * @param i scan tag //FIXME: needed? (unsigned integer?)
+	 */
+	void setScanTag(const int i);
+
+	/**
+	 * Set Frame Index Enable (acquisition of more than 1 frame adds '_f000000000000' to file name )
+	 * @param b true for frame index enable, else false
+	 */
+	void setFrameIndexEnable(const bool b);
+
+	/**
+	 * Set File Write Enable
+	 * @param b true for file write enable, else false
+	 */
+	void setFileWriteEnable(const bool b);
+
+	/**
+	 * Set File Overwrite Enable
+	 * @param b true for file overwrite enable, else false
+	 */
+	void setOverwriteEnable(const bool b);
+
+	/**
+	 * Set data compression, by saving only hits (so far implemented only for Moench and Gotthard)
+	 * @param b true for data compression enable, else false
+	 * @return OK or FAIL
+	 */
+	int setDataCompressionEnable(const bool b);
+
+
+	//***connection parameters***
+	/**
+	 * Set UDP Port Number
+	 * @param i udp port number
+	 */
+	void setUDPPortNumber(const uint32_t i);
+
+	/**
+	 * Set Second UDP Port Number (eiger specific)
+	 * @return second udp port number
+	 */
+	void setUDPPortNumber2(const uint32_t i);
+
+	/**
+	 * Set Ethernet Interface to listen to
+	 * @param c ethernet inerface eg. eth0 (max of 1000 characters)
+	 */
+	void setEthernetInterface(const char* c);
+
+
+	//***acquisition parameters***
+	/**
+	 * Set Short Frame Enabled, later will be moved to getROI (so far only for gotthard)
+	 * @param i index of adc enabled, else -1 if all enabled
+	 */
+	void setShortFrameEnable(const int i);
+
+	/**
+	 * Set the Frequency of Frames Sent to GUI
+	 * @param freq 0 for random frame requests, n for nth frame frequency
+	 * @return OK or FAIL
+	 */
+	int setFrameToGuiFrequency(const uint32_t freq);
+
+	/**
+	 * Sets the timer between frames streamed when frequency is set to 0
+	 * @param time_in_ms timer between frames streamed
+	 */
+	void setFrameToGuiTimer(const uint32_t time_in_ms);
+
+	/**
+	 * Set the data stream enable
+	 * @param enable 0 to disable, 1 to enable
+	 * @return OK or FAIL
+	 */
+	uint32_t setDataStreamEnable(const uint32_t enable);
+
+	/**
+	 * Set Acquisition Period
+	 * @param i acquisition period
+	 * @return OK or FAIL
+	 */
+	int setAcquisitionPeriod(const uint64_t i);
+
+	/**
+	 * Set Acquisition Time
+	 * @param i acquisition time
+	 * @return OK or FAIL
+	 */
+	int setAcquisitionTime(const uint64_t i);
+
+	/**
+	 * Set Number of Frames expected by receiver from detector
+	 * The data receiver status will change from running to idle when it gets this number of frames
+	 * @param i number of frames expected
+	 * @return OK or FAIL
+	 */
+	int setNumberOfFrames(const uint64_t i);
+
+	/**
+	 * Set Dynamic Range or Number of Bits Per Pixel
+	 * @param i dynamic range that is 4, 8, 16 or 32
+	 * @return OK or FAIL
+	 */
+	int setDynamicRange(const uint32_t i);
+
+	/**
+	 * Set Ten Giga Enable
+	 * @param b true if 10Giga enabled, else false (1G enabled)
+	 * @return OK or FAIL
+	 */
+	int setTenGigaEnable(const bool b);
+
+	/**
+	 * Set Fifo Depth
+	 * @param i fifo depth value
+	 * @return OK or FAIL
+	 */
+	int setFifoDepth(const uint32_t i);
+
+
+	/*************************************************************************
+	 * Behavioral functions***************************************************
+	 * They may modify the status of the receiver ****************************
+	 *************************************************************************/
+
+
+	//***initial functions***
+	/**
+	 * Set receiver type (and corresponding detector variables in derived STANDARD class)
+	 * It is the first function called by the client when connecting to receiver
+	 * @param d detector type
+	 * @return OK or FAIL
+	 */
+	int setDetectorType(const detectorType d);
+
+	/**
+	 * Sets detector hostname (and corresponding detector variables in derived REST class)
+	 * It is second function called by the client when connecting to receiver.
+	 * you can call this function only once. //FIXME: is this still valid, this implemented in derived REST class?
+	 * @param c detector hostname
+	 */
+	void initialize(const char *c);
+
+
+	//***acquisition functions***
+	/**
+	 * Reset acquisition parameters such as total frames caught for an entire acquisition (including all scans)
+	 */
+	void resetAcquisitionCount();
+
+	/**
+	 * Start Listening for Packets by activating all configuration settings to receiver
+	 * @param c error message if FAIL
+	 * @return OK or FAIL
+	 */
+	int startReceiver(char *c=NULL);
+
+	/**
+	 * Stop Listening for Packets
+	 * Calls startReadout(), which stops listening and sets status to Transmitting
+	 * When it has read every frame in buffer,it returns with the status Run_Finished
+	 */
+	void stopReceiver();
+
+	/**
+	 * Stop Listening to Packets
+	 * and sets status to Transmitting
+	 */
+	void startReadout();
+
+	/**
+	 * Shuts down and deletes UDP Sockets
+	 * @return OK or FAIL
+	 */
+	int shutDownUDPSockets();
+
+	/**
+	 * Get the buffer-current frame read by receiver
+	 * @param ithread port thread index
+	 * @param c pointer to current file name
+	 * @param raw address of pointer, pointing to current frame to send to gui
+	 * @param startAcq start index of the acquisition
+	 * @param startFrame start index of the scan
+	 */
+	void readFrame(int ithread, char* c,char** raw, int64_t &startAcq, int64_t &startFrame);
+
+	/**
+	 * abort acquisition with minimum damage: close open files, cleanup.
+	 * does nothing if state already is 'idle'
+	 */
+	void abort();  //FIXME: needed, isn't stopReceiver enough?
+
+	/**
+	 * Closes file / all files(if multiple files)
+	 * @param ithread writer thread index
+	 */
+	void closeFile(int ithread = 0);
+
+	/**
+	 * Activate / Deactivate Receiver
+	 * If deactivated, receiver will write dummy packets 0xFF
+	 * (as it will receive nothing from detector)
+	 */
+	int setActivate(int enable = -1);
+
+	//***callback functions***
+	/**
+	 * Call back for start acquisition
+	 * callback arguments are
+	 * filepath
+	 * filename
+	 * fileindex
+	 * datasize
+	 *
+	 * return value is the action which decides what the user and default responsibilities to save data are
+	 * 0 callback takes care of open,close,wrie file
+	 * 1 callback writes file, we have to open, close it
+	 * 2 we open, close, write file, callback does not do anything
+	 */
+	void registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg);
+
+	/**
+	 * Call back for acquisition finished
+	 * callback argument is
+	 * total frames caught
+	 */
+	void registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg);
+
+	/**
+	 * Call back for raw data
+	 * args to raw data ready callback are
+	 * framenum
+	 * datapointer
+	 * datasize in bytes
+	 * file descriptor
+	 * guidatapointer (NULL, no data required)
+	 */
+	void registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg);
+
+
+
+
+ protected:
+
+	/*************************************************************************
+	 * Class Members *********************************************************
+	 *************************************************************************/
+	//**detector parameters***
+	/** detector type */
+	detectorType myDetectorType;
+	/** detector hostname */
+	char detHostname[MAX_STR_LENGTH];
+	/** Number of Packets per Frame*/
+	uint32_t packetsPerFrame;
+	/** Acquisition Period */
+	uint64_t acquisitionPeriod;
+	/** Acquisition Time */
+	uint64_t acquisitionTime;
+	/** Frame Number */
+	uint64_t numberOfFrames;
+	/** Dynamic Range */
+	uint32_t dynamicRange;
+	/** Ten Giga Enable*/
+	bool tengigaEnable;
+	/** Fifo Depth */
+	uint32_t fifoDepth;
+	/** enable for flipping data across both axes */
+	int flippedData[2];
+
+	//***receiver parameters***
+	/** Maximum Number of Listening Threads/ UDP Ports */
+	const static int MAX_NUMBER_OF_LISTENING_THREADS = 2;
+	/** Receiver Status */
+	runStatus status;
+	/** Activated/Deactivated */
+	int activated;
+
+	//***connection parameters***
+	/** Ethernet Interface */
+	char eth[MAX_STR_LENGTH];
+	/** Server UDP Port Number*/
+	uint32_t udpPortNum[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	//***file parameters***
+	/** File Name without frame index, file index and extension (_d0_f000000000000_8.raw)*/
+	char fileName[MAX_STR_LENGTH];
+	/** File Path */
+	char filePath[MAX_STR_LENGTH];
+	/** File Index */
+	uint64_t fileIndex;
+	/** Scan Tag */
+	int scanTag;
+	/** Frame Index Enable */
+	bool frameIndexEnable;
+	/** File Write enable */
+	bool fileWriteEnable;
+	/** Overwrite enable */
+	bool overwriteEnable;
+	/** Data Compression Enable - save only hits */
+	bool dataCompressionEnable;
+
+	//***acquisition count parameters***
+	/** Total packets caught for an entire acquisition (including all scans) */
+	uint64_t totalPacketsCaught;
+	/** Packets Caught for each real time acquisition (eg. for each scan) */
+	uint64_t packetsCaught;
+
+	//***acquisition indices parameters***
+	/** Actual current frame index of an entire acquisition (including all scans) */
+	uint64_t acquisitionIndex;
+
+	//***acquisition parameters***
+	/* Short Frame Enable or index of adc enabled, else -1 if all enabled (gotthard specific) TODO: move to setROI */
+	int shortFrameEnable;
+	/** Frequency of Frames sent to GUI */
+	uint32_t frameToGuiFrequency;
+	/** Timer of Frames sent to GUI when frequency is 0 */
+	uint32_t frameToGuiTimerinMS;
+	/** Data Stream Enable from Receiver */
+	int32_t dataStreamEnable;
+	static const int DEFAULT_STREAMING_TIMER = 500;
+
+
+
+
+	//***callback parameters***
+	/**
+	 * function being called back for start acquisition
+	 * callback arguments are
+	 * filepath
+	 * filename
+	 * fileindex
+	 * datasize
+	 *
+	 * return value is
+	 * 0 callback takes care of open,close,wrie file
+	 * 1 callback writes file, we have to open, close it
+	 * 2 we open, close, write file, callback does not do anything
+	 */
+	int (*startAcquisitionCallBack)(char*, char*,int, int, void*);
+	void *pStartAcquisition;
+
+	/**
+	 * function being called back for acquisition finished
+	 * callback argument is
+	 * total frames caught
+	 */
+	void (*acquisitionFinishedCallBack)(int, void*);
+	void *pAcquisitionFinished;
+
+
+	/**
+	 * function being called back for raw data
+	 * args to raw data ready callback are
+	 * framenum
+	 * datapointer
+	 * datasize in bytes
+	 * file descriptor
+	 * guidatapointer (NULL, no data required)
+	 */
+	void (*rawDataReadyCallBack)(int, char*, int, FILE*, char*, void*);
+	void *pRawDataReady;
+
+
+private:
+
+};
+
+
+#endif
+
+//#endif

slsReceiverSoftware/include/UDPInterface.h

@@ -0,0 +1,577 @@
+#ifndef UDPINTERFACE_H
+#define UDPINTERFACE_H
+
+/***********************************************
+ * @file UDPInterface.h
+ * @short Base class with all the functions for the UDP inteface of the receiver
+ ***********************************************/
+/**
+ * \mainpage Base class with all the functions for the UDP inteface of the receiver
+ */
+
+/**
+ * @short Base class with all the functions for the UDP inteface of the receiver
+ */
+
+#include <exception>
+
+#include "sls_receiver_defs.h"
+#include "receiver_defs.h"
+#include "utilities.h"
+#include "logger.h"
+
+
+class UDPInterface {
+	
+
+	/*  abstract class that defines the UDP interface of an sls detector data receiver.
+	 *
+	 *  Use the factory method UDPInterface::create() to get an instance:
+	 *
+	 *  UDPInterface *udp_interface = UDPInterface::create()
+	 *
+	 *
+	 *  supported sequence of method-calls:
+	 *
+	 *  initialize() : once and only once after create() //FIXME: only once functionality implemented in the derived REST class, so not mention here?
+	 *
+	 *	get*()       : anytime after initialize(), multiples times
+	 *
+	 *  set*()       : anytime after initialize(), multiple times
+	 *
+	 *  startReceiver(): anytime after initialize(). Will fail in TCPIP itself if state already is 'running':
+	 *
+	 *  Only startReceiver() does change the data receiver configuration, it does pass the whole configuration cache to the data receiver.
+	 *
+	 *  abort(), //FIXME: needed?
+	 *
+	 *  stopReceiver() : anytime after initialize(). Will do nothing if state already is idle.
+	 *  				 Otherwise, sets status to transmitting when shutting down sockets
+	 *  				 then to run_finished when all data obtained
+	 *  				 then to idle when returning from this function
+	 *
+	 *
+	 *  getStatus() returns the actual state of the data receiver - idle, running or error, enum defined in include/sls_receiver_defs.h
+	 *
+	 *
+	 *
+	 *  get*() and set*() methods access the local cache of configuration values only and *do not* modify the data receiver settings.
+	 *
+	 *	set methods return nothing, use get methods to validate a set method success
+	 *
+	 *  get-methods that return a char array (char *) allocate a new array at each call. The caller is responsible to free the allocated space:
+	 *
+	 *      char *c = receiver->getFileName();
+	 *       Or
+	 *      FIXME: so that the pointers are not shared external to the class, do the following way in the calling method?
+	 *      char *c = new char[MAX_STR_LENGTH];
+	 *      strcpy(c,receiver->getFileName());
+	 *      ....
+	 *
+	 *      delete[] c;
+	 *
+	 *  All pointers passed in externally will be allocated and freed by the calling function
+	 *
+	 *  OK and FAIL are defined in include/sls_receiver_defs.h for functions implementing behavior
+	 *
+	 */
+	
+ public:
+	
+	/*************************************************************************
+	 * Constructor & Destructor **********************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+	/**
+	 * Constructor
+	 * Only non virtual function implemented in this class
+	 * Factory create method to create a standard or REST object
+	 * @param [in] receiver_type type can be standard or REST
+	 * @return a UDPInterface reference to object depending on receiver type
+	 */
+	static UDPInterface *create(string receiver_type = "standard");
+
+	/**
+	 * Destructor
+	 */
+	virtual ~UDPInterface() {};
+	
+
+
+	/*************************************************************************
+	 * Getters ***************************************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+
+	//**initial/detector parameters***
+	/*
+	 * Get detector hostname
+	 * @return hostname or NULL if uninitialized, must be released by calling function  (max of 1000 characters)
+	 */
+	virtual char *getDetectorHostname() const  = 0;
+
+	/*
+	 * Get flipped data across 'axis'
+	 * @return if data is flipped across 'axis'
+	 */
+	virtual int getFlippedData(int axis=0) const = 0;
+
+
+	//***file parameters***
+	/**
+	 * Get File Name Prefix (without frame index, file index and extension (_d0_f000000000000_8.raw))
+	 * @return NULL or pointer to file name prefix, must be released by calling function (max of 1000 characters)
+	 */
+	virtual char *getFileName() const = 0;
+
+	/**
+	 * Get File Path
+	 * @return NULL or pointer to file path, must be released by calling function  (max of 1000 characters)
+	 */
+	virtual char *getFilePath() const = 0;
+
+	/**
+	 * Get File Index
+	 * @return NULL or file index of acquisition
+	 */
+	virtual uint64_t getFileIndex() const = 0;
+
+	/**
+	 * Get Scan Tag
+	 * @return scan tag //FIXME: needed? (unsigned integer?)
+	 */
+	virtual int getScanTag() const = 0;
+
+	/**
+	 * Get if Frame Index is enabled (acquisition of more than 1 frame adds '_f000000000000' to file name )
+	 * @return true if frame index needed, else false
+	 */
+	virtual bool getFrameIndexEnable() const = 0;
+
+	/**
+	 * Get File Write Enable
+	 * @return true if file write enabled, else false
+	 */
+	virtual bool getFileWriteEnable() const = 0;
+
+	/**
+	 * Get File Over Write Enable
+	 * @return true if file over write enabled, else false
+	 */
+	virtual bool getOverwriteEnable() const = 0;
+
+	/**
+	 * Get data compression, by saving only hits (so far implemented only for Moench and Gotthard)
+	 * @return true if data compression enabled, else false
+	 */
+	virtual bool getDataCompressionEnable() const = 0;
+
+
+	//***acquisition count parameters***
+	/**
+	 * Get Total Frames Caught for an entire acquisition (including all scans)
+	 * @return total number of frames caught for entire acquisition
+	 */
+	virtual uint64_t getTotalFramesCaught() const = 0;
+
+	/**
+	 * Get Frames Caught for each real time acquisition (eg. for each scan)
+	 * @return number of frames caught for each scan
+	 */
+	virtual uint64_t getFramesCaught() const = 0;
+
+	/**
+	 * Get Current Frame Index for an entire  acquisition (including all scans)
+	 * @return current frame index (represents all scans too) or -1 if no packets caught
+	 */
+	virtual int64_t getAcquisitionIndex() const = 0;
+
+
+	//***connection parameters***
+	/**
+	 * Get UDP Port Number
+	 * @return udp port number
+	 */
+	virtual uint32_t getUDPPortNumber() const = 0;
+
+	/**
+	 * Get Second UDP Port Number (eiger specific)
+	 * @return second udp port number
+	 */
+	virtual uint32_t getUDPPortNumber2() const = 0;
+
+	/**
+	 * Get Ehernet Interface
+	 * @return ethernet interface. eg. eth0 (max of 1000 characters)
+	 */
+	virtual char *getEthernetInterface() const = 0;
+
+
+	//***acquisition parameters***
+	/**
+	 * Get Short Frame Enabled, later will be moved to getROI (so far only for gotthard)
+	 * @return index of adc enabled, else -1 if all enabled
+	 */
+	virtual int getShortFrameEnable() const = 0;
+
+	/**
+	 * Get the Frequency of Frames Sent to GUI
+	 * @return 0 for random frame requests, n for nth frame frequency
+	 */
+	virtual uint32_t getFrameToGuiFrequency() const = 0;
+
+	/**
+	 * Gets the timer between frames streamed when frequency is set to 0
+	 * @return timer between frames streamed
+	 */
+	virtual uint32_t getFrameToGuiTimer() const = 0;
+
+
+	/**
+	 * Get the data stream enable
+	 * @return 1 to send via zmq, else 0
+	 */
+	virtual uint32_t getDataStreamEnable() const = 0;
+
+	/**
+	 * Get Acquisition Period
+	 * @return acquisition period
+	 */
+	virtual uint64_t getAcquisitionPeriod() const = 0;
+
+	/**
+	 * Get Acquisition Time
+	 * @return acquisition time
+	 */
+	virtual uint64_t getAcquisitionTime() const = 0;
+
+	/*
+	 * Get Number of Frames expected by receiver from detector
+	 * The data receiver status will change from running to idle when it gets this number of frames FIXME: (Not implemented)
+	 * @return number of frames expected
+	 */
+	virtual uint64_t getNumberOfFrames() const = 0;
+
+	/**
+	 * Get Dynamic Range or Number of Bits Per Pixel
+	 * @return dynamic range that is 4, 8, 16 or 32
+	 */
+	virtual uint32_t getDynamicRange() const = 0;
+
+	/**
+	 * Get Ten Giga Enable
+	 * @return true if 10Giga enabled, else false (1G enabled)
+	 */
+	virtual bool getTenGigaEnable() const = 0;
+
+	/**
+	 * Get Fifo Depth
+	 * @return fifo depth
+	 */
+	virtual uint32_t getFifoDepth() const = 0;
+
+	//***receiver status***
+	/**
+	 * Get Listening Status of Receiver
+	 * @return can be idle, listening or error depending on if the receiver is listening or not
+	 */
+	virtual slsReceiverDefs::runStatus getStatus() const = 0;
+
+	/**
+	 * Get activate
+	 * If deactivated, receiver will write dummy packets 0xFF
+	 * (as it will receive nothing from detector)
+	 * @return 0 for deactivated, 1 for activated
+	 */
+	virtual int getActivate() const = 0;
+
+
+	/*************************************************************************
+	 * Setters ***************************************************************
+	 * They modify the local cache of configuration or detector parameters ***
+	 *************************************************************************/
+
+	//**initial parameters***
+	/**
+	 * Configure command line parameters
+	 * @param config_map mapping of config parameters passed from command line arguments
+	 */
+	virtual void configure(map<string, string> config_map) = 0;
+
+	/*
+	 * Get flipped data across 'axis'
+	 * @return if data is flipped across 'axis'
+	 */
+	virtual void setFlippedData(int axis=0, int enable=-1) = 0;
+
+
+	//***file parameters***
+	/**
+	 * Set File Name Prefix (without frame index, file index and extension (_d0_f000000000000_8.raw))
+	 * Does not check for file existence since it is created only at startReceiver
+	 * @param c file name (max of 1000 characters)
+	 */
+	virtual void setFileName(const char c[]) = 0;
+
+	/**
+	 * Set File Path
+	 * Checks for file directory existence before setting file path
+	 * @param c file path (max of 1000 characters)
+	 */
+	virtual void setFilePath(const char c[]) = 0;
+
+	/**
+	 * Set File Index of acquisition
+	 * @param i file index of acquisition
+	 */
+	virtual void setFileIndex(const uint64_t i) = 0;
+
+	/**
+	 * Set Scan Tag
+	 * @param i scan tag //FIXME: needed? (unsigned integer?)
+	 */
+	virtual void setScanTag(const int i) = 0;
+
+	/**
+	 * Set Frame Index Enable (acquisition of more than 1 frame adds '_f000000000000' to file name )
+	 * @param b true for frame index enable, else false
+	 */
+	virtual void setFrameIndexEnable(const bool b) = 0;
+
+	/**
+	 * Set File Write Enable
+	 * @param b true for file write enable, else false
+	 */
+	virtual void setFileWriteEnable(const bool b) = 0;
+
+	/**
+	 * Set File Overwrite Enable
+	 * @param b true for file overwrite enable, else false
+	 */
+	virtual void setOverwriteEnable(const bool b) = 0;
+
+	/**
+	 * Set data compression, by saving only hits (so far implemented only for Moench and Gotthard)
+	 * @param b true for data compression enable, else false
+	 * @return OK or FAIL
+	 */
+	virtual int setDataCompressionEnable(const bool b) = 0;
+
+	//***connection parameters***
+	/**
+	 * Set UDP Port Number
+	 * @param i udp port number
+	 */
+	virtual void setUDPPortNumber(const uint32_t i) = 0;
+
+	/**
+	 * Set Second UDP Port Number (eiger specific)
+	 * @return second udp port number
+	 */
+	virtual void setUDPPortNumber2(const uint32_t i) = 0;
+
+	/**
+	 * Set Ethernet Interface to listen to
+	 * @param c ethernet inerface eg. eth0 (max of 1000 characters)
+	 */
+	virtual void setEthernetInterface(const char* c) = 0;
+
+
+	//***acquisition parameters***
+	/**
+	 * Set Short Frame Enabled, later will be moved to getROI (so far only for gotthard)
+	 * @param i index of adc enabled, else -1 if all enabled
+	 */
+	virtual void setShortFrameEnable(const int i) = 0;
+
+	/**
+	 * Set the Frequency of Frames Sent to GUI
+	 * @param freq 0 for random frame requests, n for nth frame frequency
+	 * @return OK or FAIL
+	 */
+	virtual int setFrameToGuiFrequency(const uint32_t freq) = 0;
+
+	/**
+	 * Sets the timer between frames streamed when frequency is set to 0
+	 * @param time_in_ms timer between frames streamed
+	 */
+	virtual void setFrameToGuiTimer(const uint32_t time_in_ms) = 0;
+
+	/**
+	 * Set the data stream enable
+	 * @param enable 0 to disable, 1 to enable
+	 * @return OK or FAIL
+	 */
+	virtual uint32_t setDataStreamEnable(const uint32_t enable) = 0;
+
+	/**
+	 * Set Acquisition Period
+	 * @param i acquisition period
+	 * @return OK or FAIL
+	 */
+	virtual int setAcquisitionPeriod(const uint64_t i) = 0;
+
+	/**
+	 * Set Acquisition Time
+	 * @param i acquisition time
+	 * @return OK or FAIL
+	 */
+	virtual int setAcquisitionTime(const uint64_t i) = 0;
+
+	/**
+	 * Set Number of Frames expected by receiver from detector
+	 * The data receiver status will change from running to idle when it gets this number of frames FIXME: (Not implemented)
+	 * @param i number of frames expected
+	 * @return OK or FAIL
+	 */
+	virtual int setNumberOfFrames(const uint64_t i) = 0;
+
+	/**
+	 * Set Dynamic Range or Number of Bits Per Pixel
+	 * @param i dynamic range that is 4, 8, 16 or 32
+	 * @return OK or FAIL
+	 */
+	virtual int setDynamicRange(const uint32_t i) = 0;
+
+	/**
+	 * Set Ten Giga Enable
+	 * @param b true if 10Giga enabled, else false (1G enabled)
+	 * @return OK or FAIL
+	 */
+	virtual int setTenGigaEnable(const bool b) = 0;
+
+	/**
+	 * Set Fifo Depth
+	 * @param i fifo depth value
+	 * @return OK or FAIL
+	 */
+	virtual int setFifoDepth(const uint32_t i) = 0;
+
+
+	/*************************************************************************
+	 * Behavioral functions***************************************************
+	 * They may modify the status of the receiver ****************************
+	 *************************************************************************/
+
+
+	//***initial functions***
+	/**
+	 * Set receiver type (and corresponding detector variables in derived STANDARD class)
+	 * It is the first function called by the client when connecting to receiver
+	 * @param d detector type
+	 * @return OK or FAIL
+	 */
+	virtual int setDetectorType(const slsReceiverDefs::detectorType d) = 0;
+
+	/**
+	 * Sets detector hostname (and corresponding detector variables in derived REST class)
+	 * It is second function called by the client when connecting to receiver.
+	 * you can call this function only once. //FIXME: is this still valid, this implemented in derived REST class?
+	 * @param c detector hostname
+	 */
+	virtual void initialize(const char *c) = 0;
+
+
+	//***acquisition functions***
+	/**
+	 * Reset acquisition parameters such as total frames caught for an entire acquisition (including all scans)
+	 */
+	virtual void resetAcquisitionCount() = 0;
+
+	/**
+	 * Start Listening for Packets by activating all configuration settings to receiver
+	 * @param c error message if FAIL
+	 * @return OK or FAIL
+	 */
+	virtual int startReceiver(char *c=NULL) = 0;
+
+	/**
+	 * Stop Listening for Packets
+	 * Calls startReadout(), which stops listening and sets status to Transmitting
+	 * When it has read every frame in buffer,it returns with the status Run_Finished
+	 */
+	virtual void stopReceiver() = 0;
+
+	/**
+	 * Stop Listening to Packets
+	 * and sets status to Transmitting
+	 */
+	virtual void startReadout() = 0;
+
+	/**
+	 * Shuts down and deletes UDP Sockets
+	 * @return OK or FAIL
+	 */
+	virtual int shutDownUDPSockets() = 0;
+
+	/**
+	 * Get the buffer-current frame read by receiver
+	 * @param ithread port thread index
+	 * @param c pointer to current file name
+	 * @param raw address of pointer, pointing to current frame to send to gui
+	 * @param startAcq start index of the acquisition
+	 * @param startFrame start index of the scan
+	 */
+	virtual void readFrame(int ithread, char* c,char** raw, int64_t &startAcq, int64_t &startFrame)=0;
+
+	/**
+	 * abort acquisition with minimum damage: close open files, cleanup.
+	 * does nothing if state already is 'idle'
+	 */
+	virtual void abort() = 0;  //FIXME: needed, isnt stopReceiver enough?
+
+	/**
+	 * Closes file / all files(if multiple files)
+	 * @param ithread writer thread index
+	 */
+	virtual void closeFile(int ithread = 0) = 0;
+
+	/**
+	 * Activate / Deactivate Receiver
+	 * If deactivated, receiver will write dummy packets 0xFF
+	 * (as it will receive nothing from detector)
+	 */
+	virtual int setActivate(int enable = -1) = 0;
+
+
+	//***callback functions***
+	/**
+	 * Call back for start acquisition
+	 * callback arguments are
+	 * filepath
+	 * filename
+	 * fileindex
+	 * datasize
+	 *
+	 * return value is
+	 * 0 callback takes care of open,close,wrie file
+	 * 1 callback writes file, we have to open, close it
+	 * 2 we open, close, write file, callback does not do anything
+	 */
+	virtual void registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg) = 0;
+
+	/**
+	 * Call back for acquisition finished
+	 * callback argument is
+	 * total frames caught
+	 */
+	virtual void registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg) = 0;
+
+	/**
+	 * Call back for raw data
+	 * args to raw data ready callback are
+	 * framenum
+	 * datapointer
+	 * datasize in bytes
+	 * file descriptor
+	 * guidatapointer (NULL, no data required)
+	 */
+	virtual void registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg) = 0;
+
+
+ protected:
+ private:
+	
+};
+
+#endif  /* #ifndef UDPINTERFACE_H */

slsReceiverSoftware/include/UDPRESTImplementation.h

@@ -0,0 +1,156 @@
+//#ifdef REST
+#ifndef UDP_REST_IMPLEMENTATION_H
+#define UDP_REST_IMPLEMENTATION_H
+/********************************************//**
+ * @file UDPRESTImplementation.h
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ ***********************************************/
+
+
+#include "UDPBaseImplementation.h"
+#include "RestHelper.h"
+
+#include <string.h>
+#include <stdio.h>
+
+/**
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ */
+
+class UDPRESTImplementation : protected virtual slsReceiverDefs, public UDPBaseImplementation {
+public:
+	/*************************************************************************
+	 * Constructor & Destructor **********************************************
+	 *************************************************************************/
+	/**
+	 * Constructor
+	 */
+	UDPRESTImplementation();
+
+	/**
+	 * Destructor
+	 */
+	virtual ~UDPRESTImplementation();
+
+
+ protected:
+
+	/*************************************************************************
+	 * Getters ***************************************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+	/**
+	 * Get Rest State
+	 */
+	string get_rest_state(RestHelper * rest/*, string *rest_state*/);
+	
+
+	/*************************************************************************
+	 * Setters ***************************************************************
+	 * They modify the local cache of configuration or detector parameters ***
+	 *************************************************************************/
+	/**
+	 * Initialize REST
+	 */
+	void initialize_REST();
+
+
+
+
+ public:
+	/*************************************************************************
+	 * Getters ***************************************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+
+
+	/*************************************************************************
+	 * Setters ***************************************************************
+	 * They modify the local cache of configuration or detector parameters ***
+	 *************************************************************************/
+
+	/**
+	 * Overridden method
+	 * Configure command line parameters
+	 * @param config_map mapping of config parameters passed from command line arguments
+	 */
+	void configure(map<string, string> config_map);	
+
+
+	/*************************************************************************
+	 * Behavioral functions***************************************************
+	 * They may modify the status of the receiver ****************************
+	 *************************************************************************/
+
+	/**
+	 * Overridden method
+	 * Start Listening for Packets by activating all configuration settings to receiver
+	 * When this function returns, it has status RUNNING(upon SUCCESS) or IDLE (upon failure)
+	 * @param c error message if FAIL
+	 * @return OK or FAIL
+	 */
+	int startReceiver(char *c=NULL);
+
+	/**
+	 * Overridden method
+	 * Stop Listening for Packets
+	 * Calls startReadout(), which stops listening and sets status to Transmitting
+	 * When it has read every frame in buffer, the status changes to Run_Finished
+	 * When this function returns, receiver has status IDLE
+	 * Pre: status is running, semaphores have been instantiated,
+	 * Post: udp sockets shut down, status is idle, semaphores destroyed
+	 */
+	void stopReceiver();
+
+	/**
+	 * Overridden method
+	 * Stop Listening to Packets
+	 * and sets status to Transmitting
+	 * Next step would be to get all data and stop receiver completely and return with idle state
+	 * Pre: status is running, udp sockets have been initialized, stop receiver initiated
+	 * Post:udp sockets closed, status is transmitting,
+	 */
+	void startReadout();
+
+	/**
+	 * Overridden method
+	 * Shuts down and deletes UDP Sockets
+	 * TCPIPInterface can also call this in case of illegal shutdown of receiver
+	 * @return OK or FAIL
+	 */
+	int shutDownUDPSockets();
+
+	/**
+	 * Overridden method
+	 * Get the buffer-current frame read by receiver
+	 * @param c pointer to current file name
+	 * @param raw address of pointer, pointing to current frame to send to gui
+	 * @param startAcq start index of the acquisition
+	 * @param startFrame start index of the scan
+	 */
+	void readFrame(char* c,char** raw, uint64_t &startAcq, uint64_t &startFrame);
+
+	/**
+	 * Overridden method
+	 * Closes file / all files(data compression involves multiple files)
+	 * TCPIPInterface can also call this in case of illegal shutdown of receiver
+	 * @param i thread index valid for datacompression using root files, -1 for all threads
+	 */
+	void closeFile(int i = -1);
+
+	uint64_t getTotalFramesCaught() const;
+
+
+private:
+	bool isInitialized;
+	RestHelper * rest ;
+	int rest_port;  		// receiver backend port
+	string rest_hostname;  	// receiver hostname
+	bool is_main_receiver;
+	
+};
+
+
+#endif
+
+//#endif /*REST*/

slsReceiverSoftware/include/UDPStandardImplementation.h

@@ -0,0 +1,847 @@
+//#ifdef UDP_BASE_IMPLEMENTATION
+#ifndef UDP_STANDARD_IMPLEMENTATION_H
+#define UDP_STANDARD_IMPLEMENTATION_H
+/********************************************//**
+ * @file UDPBaseImplementation.h
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ ***********************************************/
+
+#include "UDPBaseImplementation.h"
+
+#include "genericSocket.h"
+#include "circularFifo.h"
+#include "singlePhotonDetector.h"
+#include "slsReceiverData.h"
+#include "moenchCommonMode.h"
+
+
+#ifdef MYROOT1
+#include <TTree.h>
+#include <TFile.h>
+#endif
+
+#include <string.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <semaphore.h>
+
+
+/**
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ */
+
+
+class UDPStandardImplementation: private virtual slsReceiverDefs, public UDPBaseImplementation {
+ public:
+
+
+	/*************************************************************************
+	 * Constructor & Destructor **********************************************
+	 *************************************************************************/
+	/**
+	 * Constructor
+	 */
+	UDPStandardImplementation();
+
+	/**
+	 * Destructor
+	 */
+	virtual ~UDPStandardImplementation();
+
+
+	/*************************************************************************
+	 * Getters ***************************************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+
+
+	/*************************************************************************
+	 * Setters ***************************************************************
+	 * They modify the local cache of configuration or detector parameters ***
+	 *************************************************************************/
+
+	//**initial parameters***
+	//*** file parameters***
+	/**
+	 * Set File Name Prefix (without frame index, file index and extension (_d0_f000000000000_8.raw))
+	 * Does not check for file existence since it is created only at startReceiver
+	 * @param c file name (max of 1000 characters)
+	 */
+	void setFileName(const char c[]);
+
+	/**
+	 * Overridden method
+	 * Set data compression, by saving only hits (so far implemented only for Moench and Gotthard)
+	 * @param b true for data compression enable, else false
+	 * @return OK or FAIL
+	 */
+	int setDataCompressionEnable(const bool b);
+
+	//***acquisition count parameters***
+	/**
+	 * Get Total Frames Caught for an entire acquisition (including all scans)
+	 * @return total number of frames caught for entire acquisition
+	 */
+	uint64_t getTotalFramesCaught() const;
+
+	/**
+	 * Get Frames Caught for each real time acquisition (eg. for each scan)
+	 * @return number of frames caught for each scan
+	 */
+	uint64_t getFramesCaught() const;
+
+	//***acquisition parameters***
+	/**
+	 * Overridden method
+	 * Set Short Frame Enabled, later will be moved to getROI (so far only for gotthard)
+	 * @param i index of adc enabled, else -1 if all enabled
+	 */
+	void setShortFrameEnable(const int i);
+
+	/**
+	 * Set the Frequency of Frames Sent to GUI
+	 * @param freq 0 for random frame requests, n for nth frame frequency
+	 * @return OK or FAIL
+	 */
+	int setFrameToGuiFrequency(const uint32_t freq);
+
+	/**
+	 * Set the data stream enable
+	 * @param enable 0 to disable, 1 to enable
+	 * @return OK or FAIL
+	 */
+	uint32_t setDataStreamEnable(const uint32_t enable);
+
+	/**
+	 * Overridden method
+	 * Set Acquisition Period
+	 * @param i acquisition period
+	 * @return OK or FAIL
+	 */
+	int setAcquisitionPeriod(const uint64_t i);
+
+	/**
+	 * Set Acquisition Time
+	 * @param i acquisition time
+	 * @return OK or FAIL
+	 */
+	int setAcquisitionTime(const uint64_t i);
+
+	/**
+	 * Overridden method
+	 * Set Number of Frames expected by receiver from detector
+	 * The data receiver status will change from running to idle when it gets this number of frames
+	 * @param i number of frames expected
+	 * @return OK or FAIL
+	 */
+	int setNumberOfFrames(const uint64_t i);
+
+	/**
+	 * Overridden method
+	 * Set Dynamic Range or Number of Bits Per Pixel
+	 * @param i dynamic range that is 4, 8, 16 or 32
+	 * @return OK or FAIL
+	 */
+	int setDynamicRange(const uint32_t i);
+
+	/**
+	 * Overridden method
+	 * Set Ten Giga Enable
+	 * @param b true if 10Giga enabled, else false (1G enabled)
+	 * @return OK or FAIL
+	 */
+	int setTenGigaEnable(const bool b);
+
+
+	/**
+	 * Overridden method
+	 * Set Fifo Depth
+	 * @param i fifo depth value
+	 * @return OK or FAIL
+	 */
+	int setFifoDepth(const uint32_t i);
+
+	/*************************************************************************
+	 * Behavioral functions***************************************************
+	 * They may modify the status of the receiver ****************************
+	 *************************************************************************/
+
+	//***initial functions***
+	/**
+	 * Overridden method
+	 * Set receiver type (and corresponding detector variables in derived STANDARD class)
+	 * It is the first function called by the client when connecting to receiver
+	 * @param d detector type
+	 * @return OK or FAIL
+	 */
+	int setDetectorType(const detectorType d);
+
+	//***acquisition functions***
+	/**
+	 * Overridden method
+	 * Reset acquisition parameters such as total frames caught for an entire acquisition (including all scans)
+	 */
+	void resetAcquisitionCount();
+
+	/**
+	 * Overridden method
+	 * Start Listening for Packets by activating all configuration settings to receiver
+	 * When this function returns, it has status RUNNING(upon SUCCESS) or IDLE (upon failure)
+	 * @param c error message if FAIL
+	 * @return OK or FAIL
+	 */
+	int startReceiver(char *c=NULL);
+
+	/**
+	 * Overridden method
+	 * Stop Listening for Packets
+	 * Calls startReadout(), which stops listening and sets status to Transmitting
+	 * When it has read every frame in buffer, the status changes to Run_Finished
+	 * When this function returns, receiver has status IDLE
+	 * Pre: status is running, semaphores have been instantiated,
+	 * Post: udp sockets shut down, status is idle, semaphores destroyed
+	 */
+	void stopReceiver();
+
+	/**
+	 * Overridden method
+	 * Stop Listening to Packets
+	 * and sets status to Transmitting
+	 * Next step would be to get all data and stop receiver completely and return with idle state
+	 * Pre: status is running, udp sockets have been initialized, stop receiver initiated
+	 * Post:udp sockets closed, status is transmitting
+	 */
+	void startReadout();
+
+	/**
+	 * Overridden method
+	 * Shuts down and deletes UDP Sockets
+	 * TCPIPInterface can also call this in case of illegal shutdown of receiver
+	 * @return OK or FAIL
+	 */
+	int shutDownUDPSockets();
+
+	/**
+	 * Overridden method
+	 * Get the buffer-current frame read by receiver
+	 * @param ithread writer thread
+	 * @param c pointer to current file name
+	 * @param raw address of pointer, pointing to current frame to send to gui
+	 * @param startAcq start index of the acquisition
+	 * @param startFrame start index of the scan
+	 */
+	void readFrame(int ithread, char* c,char** raw, int64_t &startAcq, int64_t &startFrame);
+
+
+	void resetGuiPointer(int ithread);
+	/**
+	 * Overridden method
+	 * Closes file / all files(data compression involves multiple files)
+	 * TCPIPInterface can also call this in case of illegal shutdown of receiver
+	 * @param ithread writer thread index
+	 */
+	void closeFile(int ithread = 0);
+
+	/**
+	 * Activate / Deactivate Receiver
+	 * If deactivated, receiver will write dummy packets 0xFF
+	 * (as it will receive nothing from detector)
+	 */
+	int setActivate(int enable = -1);
+
+private:
+	/*************************************************************************
+	 * Getters ***************************************************************
+	 * They access local cache of configuration or detector parameters *******
+	 *************************************************************************/
+
+/*
+	uint64_t (*getFrameNumber)();
+	uint64_t eigerGetFrameNumber();
+	uint64_t generalGetFrameNumber();
+	getframenumber = &generalgetframenumber;
+	if(dettpe == eiger) getframenumber = &eigerGerFramenumber;
+
+	call using getframenumber();
+*/
+
+	//**initial parameters***
+
+    /**
+	 * Delete and free member parameters
+	 */
+    void deleteMembers();
+
+	/**
+	 * Deletes all the filter objects for single photon data
+	 * Deals with data compression
+	 */
+	void deleteFilter();
+
+	/**
+	 * Initialize base member parameters
+	 */
+	void initializeBaseMembers();
+
+	/**
+	 * Initialize member parameters
+	 */
+	void initializeMembers();
+
+	/**
+	 * Sets up all the filter objects for single photon data
+	 * Deals with data compression
+	 */
+	void initializeFilter();
+
+	/**
+	 * Set up the Fifo Structure for processing buffers
+	 * between listening and writer threads
+	 * When the parameters ahve been determined and if fifostructure needs to be changes,
+	 * the listerning and writing threads are also destroyed together with this
+	 * @return OK or FAIL
+	 */
+	int setupFifoStructure();
+
+
+
+	/*************************************************************************
+	 * Listening and Writing Threads *****************************************
+	 *************************************************************************/
+	/**
+	 * Create Data Call Back Threads
+	 * @param destroy is true to destroy all the threads
+	 * @return OK or FAIL
+	 */
+	int createDataCallbackThreads(bool destroy = false);
+
+	/**
+	 *  Create Listening Threads
+	 * @param destroy is true to destroy all the threads
+	 */
+	int createListeningThreads(bool destroy = false);
+
+	/**
+	 * Create Writer Threads
+	 * @param destroy is true to destroy all the threads
+	 * @return OK or FAIL
+	 */
+	int createWriterThreads(bool destroy = false);
+
+
+
+
+	/**
+	 * Set Thread Priorities
+	 */
+	void setThreadPriorities();
+
+	/**
+	 * Creates UDP Sockets
+	 * @return OK or FAIL
+	 */
+	int createUDPSockets();
+
+	/**
+	 * Initializes writer variables and creates the first file
+	 * also does the startAcquisitionCallBack
+	 * @return OK or FAIL
+	 */
+	int setupWriter();
+
+	/**
+	 * Creates new file and reset some parameters
+	 * @param ithread writer thread index
+	 * @return OK or FAIL
+	 */
+	int createNewFile(int ithread);
+
+	/**
+	 * Creates new tree and file for compression
+	 * @param ithread thread number
+	 * @param iframe frame number
+	 * @return OK or FAIL
+	 */
+	int createCompressionFile(int ithread, int iframe);
+
+	/**
+	 * Static function - Starts Data Callback Thread of this object
+	 * @param this_pointer pointer to this object
+	 */
+	static void* startDataCallbackThread(void *this_pointer);
+
+	/**
+	 * Static function - Starts Listening Thread of this object
+	 * @param this_pointer pointer to this object
+	 */
+	static void* startListeningThread(void *this_pointer);
+
+	/**
+	 * Static function - Starts Writing Thread of this object
+	 * @param this_pointer pointer to this object
+	 */
+	static void* startWritingThread(void *this_pointer);
+
+	/**
+	 * Thread that sends data packets to client
+	 */
+	void startDataCallback();
+
+	/**
+	 * Thread that listens to packets
+	 * It pops the fifofree for free addresses, listens to packets and pushes them into the fifo
+	 * This is continuously looped for each buffer in a nested loop, which is again looped for each acquisition
+	 * Exits only for changing dynamic range, 10G parameters etc and recreated
+	 *
+	 */
+	void startListening();
+
+	/**
+	 * Called by startListening
+	 * Listens to buffer, until  packet(s) received or shutdownUDPsocket called by client
+	 * Also copies carryovers from previous frame in front of buffer (gotthard and moench)
+	 * For eiger, it ignores packets less than onePacketSize
+	 * @param ithread listening thread index
+	 * @param cSize number of bytes carried on from previous buffer
+	 * @param temp temporary storage of previous buffer
+	 * @return the number of bytes actually received
+	 */
+	int prepareAndListenBuffer(int ithread, int cSize, char* temp);
+
+	/**
+	 * Called by startListening
+	 * Creates the packets
+	 * @param ithread listening thread index
+	 * @return the number of bytes actually received
+	 */
+	int prepareAndListenBufferDeactivated(int ithread);
+
+
+	/**
+	 * Called by startListening
+	 * Listens to each packet and copies only complete frames
+	 * until all receiver or shutdownUDPsocket called by client
+	 * @param ithread listening thread index
+	 * @return the number of bytes copied to buffer
+	 */
+	int prepareAndListenBufferCompleteFrames(int ithread);
+
+	/**
+	 * Called by startListening
+	 * Its called for the first packet of a scan or acquistion
+	 * Sets the startframeindices and the variables to know if acquisition started
+	 * @param ithread listening thread number
+	 */
+	void startFrameIndices(int ithread);
+
+	/**
+	 * Called by prepareAndListenBuffer
+	 * This is called when udp socket is shut down by client
+	 * It pushes ffff instead of packet number into fifo
+	 * to inform writers about the end of listening session
+	 * Then sets the listening mask so that it stops listening and wait for next acquisition trigger
+	 * @param ithread listening thread number
+	 * @param numbytes number of bytes received
+	 */
+	void stopListening(int ithread, int numbytes);
+
+	/*
+	 * Called by startListening for gotthard and moench to handle split frames
+	 * It processes listening thread buffers by ensuring split frames are in the same buffer
+	 * @param ithread listening thread index
+	 * @param cSize number of bytes carried over to the next buffer to reunite with split frame
+	 * @param temp temporary buffer to store the split frame
+	 * @param rc number of bytes received
+	 * @return packet count
+	 */
+	uint32_t processListeningBuffer(int ithread, int &cSize,char* temp, int rc);
+
+	/**
+	 * Thread started which writes packets to file.
+	 * It calls popAndCheckEndofAcquisition to  pop fifo and check if it is a dummy end buffer
+	 * It then calls a function to process and write packets to file and pushes the addresses into the fifoFree
+	 * This is continuously looped for each buffer in a nested loop, which is again looped for each acquisition
+	 * Exits only for changing dynamic range, 10G parameters etc and recreated
+	 *
+	 */
+	void startWriting();
+
+	/**
+	 * Called by processWritingBuffer and processWritingBufferPacketByPacket
+	 * When dummy-end buffers are popped from all FIFOs (acquisition over), this is called
+	 * It frees the FIFO addresses, closes all files
+	 * For data compression, it waits for all threads to be done
+	 * Changes the status to RUN_FINISHED and prints statistics
+	 * @param ithread writing thread index
+	 * @param wbuffer writing buffer popped out from FIFO
+	 */
+	void stopWriting(int ithread, char* wbuffer);
+
+	/**
+	 * Called by processWritingBuffer and processWritingBufferPacketByPacket
+	 * Updates parameters, (writes headers for eiger) and writes to file when not a dummy frame
+	 * Copies data for gui display and frees addresses popped from FIFOs
+	 * @param ithread writing thread index
+	 * @param wbuffer writing buffer popped out from FIFO
+	 * @param npackets number of packets
+	 */
+	void handleWithoutDataCompression(int ithread, char* wbuffer,uint32_t npackets);
+
+	/**
+	 * Called by startWriting for jungfrau and eiger
+	 * writes complete frames to file
+	 * Copies data for gui display and frees addresses popped from FIFOs
+	 * @param ithread writing thread index
+	 * @param wbuffer writing buffer popped out from FIFO
+	 */
+	void handleCompleteFramesOnly(int ithread, char* wbuffer);
+
+	/**
+	 * Calle by handleWithoutDataCompression
+	 * Creating headers Writing to file without compression
+	 * @param ithread writer thread index
+	 * @param wbuffer is the address of buffer popped out of FIFO
+	 * @param numpackets is the number of packets
+	 */
+	void writeFileWithoutCompression(int ithread, char* wbuffer,uint32_t numpackets);
+
+	/**
+	 * Called by writeToFileWithoutCompression
+	 * Create headers for file writing (at the moment, this is eiger specific)
+	 * @param wbuffer writing buffer popped from FIFOs
+	 */
+	void createHeaders(char* wbuffer);
+
+	/**
+	 * Updates the file header char aray, each time the corresp parameter is changed
+	 * @param ithread writer thread index
+	 */
+	void updateFileHeader(int ithread);
+
+	/**
+	 * Called by handleWithoutDataCompression and handleWithCompression after writing to file
+	 * Copy frames for GUI and updates appropriate parameters for frequency frames to gui
+	 * Uses semaphore for nth frame mode
+	 * @param ithread writer thread index
+	 * @param buffer buffer to copy
+	 * @param numpackets number of packets to copy
+	 */
+	void copyFrameToGui(int ithread, char* buffer, uint32_t numpackets);
+
+	void waitWritingBufferForNextAcquisition(int ithread);
+
+	/**
+	 * Called by processWritingBuffer
+	 * Processing fifo popped buffers for data compression
+	 * Updates parameters and writes to file
+	 * Copies data for gui display and frees addresses popped from FIFOs
+	 * @param ithread writing thread number
+	 * @param wbuffer writer buffer
+	 * @param nf number of frames
+	 */
+	void handleDataCompression(int ithread, char* wbuffer, uint64_t &nf);
+
+
+	/**
+	 * Get Frame Number
+	 * @param ithread writer thread index
+	 * @param wbuffer writer buffer
+	 * @param framenumber reference to the frame number
+	 * @param packetnumber reference to the packet number
+	 * @param subframenumber reference to the subframe number
+	 * @oaram bunchid reference to the bunch id
+	 * @return OK or FAIL
+	 */
+	int getFrameandPacketNumber(int ithread, char* wbuffer, uint64_t &framenumber, uint32_t &packetnumber, uint32_t &subframenumber, uint64_t &bunchid);
+
+	/**
+	 * Find offset upto this frame number and write it to file
+	 * @param ithread writer thread index
+	 * @param wbuffer writer buffer
+	 * @param offset reference of offset to look from and replaces offset to starting of nextframenumber
+	 * @param nextFrameNumber frame number up to which data written
+	 * @param numpackets number of packets in buffer
+	 * @param numPacketsWritten number of packets written to file
+	 */
+	int writeUptoFrameNumber(int ithread, char* wbuffer, int &offset, uint64_t nextFrameNumber, uint32_t numpackets, int &numPacketsWritten);
+
+	/*************************************************************************
+	 * Class Members *********************************************************
+	 *************************************************************************/
+
+	/** Maximum Number of Writer Threads */
+
+#ifdef DCOMPRESS
+	/**** most likely not used ***/
+	const static int MAX_NUMBER_OF_WRITER_THREADS = 15;
+#else
+	const static int MAX_NUMBER_OF_WRITER_THREADS = 2;
+#endif
+
+	//**detector parameters***
+	/*Detector Readout ID*/
+	int detID;
+
+	/** Size of 1 buffer processed at a time */
+	int bufferSize;
+
+	/** One Packet Size including headers */
+	int onePacketSize;
+
+	/** One Packet Size without headers */
+	int oneDataSize;
+
+	/** Frame Index Mask */
+	uint64_t frameIndexMask;
+
+	/** Frame Index Offset */
+	int frameIndexOffset;
+
+	/** Packet Index Mask */
+	uint64_t packetIndexMask;
+
+	/** Footer offset from start of Packet*/
+	int footerOffset;
+
+	/** variable to exclude missing packet */
+	bool excludeMissingPackets;
+
+
+	//***File parameters***
+#ifdef MYROOT1
+	/** Tree where the hits are stored */
+	TTree *myTree[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** File where the tree is saved */
+	TFile *myFile[MAX_NUMBER_OF_WRITER_THREADS];
+#endif
+
+	/** Complete File name */
+	char completeFileName[MAX_NUMBER_OF_WRITER_THREADS][MAX_STR_LENGTH];
+
+	/** File Name without frame index, file index and extension (_d0_f000000000000_8.raw)*/
+	char fileNamePerThread[MAX_NUMBER_OF_WRITER_THREADS][MAX_STR_LENGTH];
+
+		/** Maximum Frames Per File **/
+	uint64_t maxFramesPerFile;
+	const static int progressFrequency = 10;
+
+	/** If file created successfully for all Writer Threads */
+	bool fileCreateSuccess;
+
+	/** File header */
+	const static unsigned int FILE_HEADER_SIZE = 500;
+	char fileHeader[MAX_NUMBER_OF_WRITER_THREADS][FILE_HEADER_SIZE];
+
+	/** File Descriptor */
+	FILE *sfilefd[MAX_NUMBER_OF_WRITER_THREADS];
+
+
+	//***acquisition indices/count parameters***
+	/** Frame Number of First Frame of an entire Acquisition (including all scans) */
+	uint64_t startAcquisitionIndex;
+
+	/** Frame index at start of each real time acquisition (eg. for each scan) */
+	uint64_t startFrameIndex;
+
+	/** Actual current frame index of each time acquisition (eg. for each scan) */
+	uint64_t frameIndex[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Current Frame Number */
+	uint64_t currentFrameNumber[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Previous Frame number from buffer to calculate loss */
+	int64_t frameNumberInPreviousFile[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Previous Frame number from last check to calculate loss */
+	int64_t frameNumberInPreviousCheck[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** total packet count from last check */
+	int64_t totalWritingPacketCountFromLastCheck[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Pckets currently in current file, starts new file when it reaches max */
+	int64_t lastFrameNumberInFile[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** packets in current file */
+	uint64_t totalPacketsInFile[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/**Total packet count written by each writing thread */
+	uint64_t totalWritingPacketCount[MAX_NUMBER_OF_LISTENING_THREADS];
+
+
+	/* Acquisition started */
+	bool acqStarted;
+
+	/* Measurement started - for each thread to get progress print outs*/
+	bool measurementStarted[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Total packet Count listened to by listening threads */
+	int totalListeningPacketCount[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Total packet Count ignored by listening threads */
+	int totalIgnoredPacketCount[MAX_NUMBER_OF_LISTENING_THREADS];
+
+
+
+
+
+
+	//***receiver parameters***
+	/** Receiver Buffer */
+	char *buffer[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Memory allocated */
+	char *mem0[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Circular fifo to point to addresses of data listened to */
+	CircularFifo<char>* fifo[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Circular fifo to point to address already written and freed, to be reused */
+	CircularFifo<char>* fifoFree[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** UDP Sockets - Detector to Receiver */
+	genericSocket* udpSocket[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Number of Jobs Per Buffer */
+	int numberofJobsPerBuffer;
+
+	/** Total fifo size */
+	uint32_t fifoSize;
+
+	/** fifo buffer header size */
+	uint32_t fifoBufferHeaderSize;
+
+	/** Dummy Packet identifier value */
+	const static uint32_t dummyPacketValue = 0xFFFFFFFF;
+
+
+
+	//***receiver to GUI parameters***
+	/** Current Frame copied for GUI */
+	char* latestData[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Pointer to file name to be sent to GUI */
+	char guiFileName[MAX_NUMBER_OF_WRITER_THREADS][MAX_STR_LENGTH];
+
+	/** Number of packets copied to be sent to gui (others padded) */
+	uint32_t guiNumPackets[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Semaphore to synchronize Writer and GuiReader threads*/
+	sem_t writerGuiSemaphore[MAX_NUMBER_OF_WRITER_THREADS]; //datacompression, only first thread sends to gui
+
+	/** Semaphore to synchronize Writer and GuiReader threads*/
+	sem_t dataCallbackWriterSemaphore[MAX_NUMBER_OF_WRITER_THREADS]; //datacompression, only first thread sends to gui
+
+	/** counter for nth frame to gui */
+	int frametoGuiCounter[MAX_NUMBER_OF_WRITER_THREADS];
+
+
+
+	//***data call back thread parameters***
+	/** Ensures if zmq threads created successfully */
+	bool zmqThreadStarted;
+
+	/** Number of data callback Threads */
+	int numberofDataCallbackThreads;
+
+	/** Data Callback Threads */
+	pthread_t dataCallbackThreads[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Semaphores Synchronizing DataCallback Threads */
+	sem_t dataCallbackSemaphore[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Mask with each bit indicating status of each data callback thread  */
+	volatile uint32_t dataCallbackThreadsMask;
+
+	/** Set to self-terminate data callback threads waiting for semaphores */
+	bool killAllDataCallbackThreads;
+
+
+
+	//***general and listening thread parameters***
+	/** Ensures if threads created successfully */
+	bool threadStarted;
+
+	/** Current Thread Index*/
+	int currentThreadIndex;
+
+	/** Number of Listening Threads */
+	int numberofListeningThreads;
+
+	/** Listening Threads */
+	pthread_t listeningThreads[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Semaphores Synchronizing Listening Threads */
+	sem_t listenSemaphore[MAX_NUMBER_OF_LISTENING_THREADS];
+
+	/** Mask with each bit indicating status of each listening thread  */
+	volatile uint32_t listeningThreadsMask;
+
+	/** Set to self-terminate listening threads waiting for semaphores */
+	bool killAllListeningThreads;
+
+
+
+	//***writer thread parameters***
+	/** Number of Writer Threads */
+	int numberofWriterThreads;
+
+	/** Writer Threads */
+	pthread_t writingThreads[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Semaphores Synchronizing Writer Threads */
+	sem_t writerSemaphore[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Mask with each bit indicating status of each writer thread */
+	volatile uint32_t writerThreadsMask;
+
+	/** Mask with each bit indicating file created for each writer thread*/
+	volatile uint32_t createFileMask;
+
+	/** Set to self-terminate writer threads waiting for semaphores */
+	bool killAllWritingThreads;
+
+
+	//***filter parameters***
+	/** Common Mode Subtraction Enable FIXME: Always false, only moench uses, Ask Anna */
+	bool commonModeSubtractionEnable;
+
+	/** Moench Common Mode Subtraction */
+	moenchCommonMode *moenchCommonModeSubtraction;
+
+	/** Single Photon Detector Object for each writer thread */
+	singlePhotonDetector<uint16_t> *singlePhotonDetectorObject[MAX_NUMBER_OF_WRITER_THREADS];
+
+	/** Receiver Data Object for each writer thread */
+	slsReceiverData<uint16_t>  *receiverData[MAX_NUMBER_OF_WRITER_THREADS];
+
+
+
+
+	//***mutex***
+	/** Status mutex */
+	pthread_mutex_t statusMutex;
+
+	/** Writing mutex */
+	pthread_mutex_t writeMutex;
+
+	/** GuiDataReady Mutex */
+	pthread_mutex_t  dataReadyMutex;
+
+	/** Progress (currentFrameNumber) Mutex  */
+	pthread_mutex_t progressMutex;
+
+
+	//***callback***
+	/** The action which decides what the user and default responsibilities to save data are
+	 * 0 raw data ready callback takes care of open,close,write file
+	 * 1 callback writes file, we have to open, close it
+	 * 2 we open, close, write file, callback does not do anything */
+	int cbAction;
+
+};
+
+
+#endif
+
+//#endif

slsReceiverSoftware/include/ansi.h

@@ -0,0 +1,61 @@
+#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_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"
+
+#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);
+}
+
+*/

slsReceiverSoftware/include/circularFifo.h

@@ -0,0 +1,160 @@
+/* CircularFifo.h 
+* Not any company's property but Public-Domain
+* Do with source-code as you will. No requirement to keep this
+* header if need to use it/change it/ or do whatever with it
+*
+* Note that there is No guarantee that this code will work
+* and I take no responsibility for this code and any problems you
+* might get if using it. The code is highly platform dependent!
+*
+* Code & platform dependent issues with it was originally
+* published at http://www.kjellkod.cc/threadsafecircularqueue
+* 2009-11-02
+* @author Kjell Hedstr<EFBFBD>m, hedstrom@kjellkod.cc */
+
+#ifndef CIRCULARFIFO_H_
+#define CIRCULARFIFO_H_
+
+//#include "sls_receiver_defs.h"
+#include <semaphore.h>
+#include <vector>
+#include <iostream>
+using namespace std;
+
+typedef  double double32_t;
+typedef  float float32_t;
+typedef  int int32_t;
+
+
+
+/** Circular Fifo (a.k.a. Circular Buffer)
+* Thread safe for one reader, and one writer */
+template<typename Element>
+class CircularFifo {
+public:
+
+   CircularFifo(unsigned int Size) : tail(0), head(0){
+	   Capacity = Size + 1;
+	   array.resize(Capacity);
+	   sem_init(&free_mutex,0,0);
+   }
+   virtual ~CircularFifo() {
+		sem_destroy(&free_mutex);
+   }
+
+   bool push(Element*& item_);
+   bool pop(Element*& item_);
+
+   bool isEmpty() const;
+   bool isFull() const;
+
+   int getSemValue();
+
+private:
+   volatile unsigned int tail; // input index
+   vector <Element*> array;
+   volatile unsigned int head; // output index
+   unsigned int Capacity;
+   sem_t free_mutex;
+
+   unsigned int increment(unsigned int idx_) const;
+};
+
+template<typename Element>
+int CircularFifo<Element>::getSemValue()
+{
+	int value;
+	sem_getvalue(&free_mutex, &value);
+	return value;
+}
+
+
+/** Producer only: Adds item to the circular queue.
+* If queue is full at 'push' operation no update/overwrite
+* will happen, it is up to the caller to handle this case
+*
+* \param item_ copy by reference the input item
+* \return whether operation was successful or not */
+template<typename Element>
+bool CircularFifo<Element>::push(Element*& item_)
+{
+
+	//cout<<"*head:"<<head<<endl;
+	//cout<<"*tail before"<<tail<<endl;
+   unsigned int nextTail = increment(tail);
+   //cout<<"*next tail"<<nextTail<<endl;
+   if(nextTail != head)
+   {
+      array[tail] = item_;
+      tail = nextTail;
+      sem_post(&free_mutex);
+      return true;
+   }
+   // queue was full
+   return false;
+}
+
+/** Consumer only: Removes and returns item from the queue
+* If queue is empty at 'pop' operation no retrieve will happen
+* It is up to the caller to handle this case
+*
+* \param item_ return by reference the wanted item
+* \return whether operation was successful or not */
+template<typename Element>
+bool CircularFifo<Element>::pop(Element*& item_)
+{
+	//cout<<"-tail:"<<tail<<endl;
+	//cout<<"-head before:"<<head<<endl;
+   //if(head == tail)
+    //  return false;  // empty queue
+  sem_wait(&free_mutex);
+
+   item_ = array[head];
+   head = increment(head);
+   //cout<<"-head after:"<<head<<endl;
+   return true;
+}
+
+/** Useful for testinng and Consumer check of status
+  * Remember that the 'empty' status can change quickly
+  * as the Procuder adds more items.
+  *
+  * \return true if circular buffer is empty */
+template<typename Element>
+bool CircularFifo<Element>::isEmpty() const
+{
+   return (head == tail);
+}
+
+/** Useful for testing and Producer check of status
+  * Remember that the 'full' status can change quickly
+  * as the Consumer catches up.
+  *
+  * \return true if circular buffer is full.  */
+template<typename Element>
+bool CircularFifo<Element>::isFull() const
+{
+   int tailCheck = (tail+1) % Capacity;
+   return (tailCheck == head);
+}
+
+/** Increment helper function for index of the circular queue
+* index is inremented or wrapped
+*
+*  \param idx_ the index to the incremented/wrapped
+*  \return new value for the index */
+template<typename Element>
+unsigned int CircularFifo<Element>::increment(unsigned int idx_) const
+{
+   // increment or wrap
+   // =================
+   //    index++;
+   //    if(index == array.lenght) -> index = 0;
+   //
+   //or as written below:
+   //    index = (index+1) % array.length
+   idx_ = (idx_+1) % Capacity;
+   return idx_;
+}
+
+#endif /* CIRCULARFIFO_H_ */

slsReceiverSoftware/include/dummyUDPInterface.h

@@ -0,0 +1,436 @@
+#ifndef DUMMYUDPINTERFACE_H
+#define DUMMYUDPINTERFACE_H
+
+/***********************************************
+ * @file UDPInterface.h
+ * @short Base class with all the functions for the UDP inteface of the receiver
+ ***********************************************/
+/**
+ * \mainpage Base class with all the functions for the UDP inteface of the receiver
+ */
+
+/**
+ * @short Base class with all the functions for the UDP inteface of the receiver
+ */
+
+#include "UDPInterface.h"
+#include "sls_receiver_defs.h"
+#include "genericSocket.h"
+
+
+class dummyUDPInterface : public UDPInterface {
+	
+
+	/* abstract class that defines the UDP interface of an sls detector data receiver.
+	 *
+	 * Use the factory method UDPInterface::create() to get an instance:
+	 *
+	 *      UDPInterface *udp_interface = UDPInterface::create()
+	 *
+	 *  supported sequence of method-calls:
+	 *
+	 *  initialize() : once and only once after create()
+	 *
+	 *  get*()       : anytime after initialize(), multiples times
+	 *  set*()       : anytime after initialize(), multiple times
+	 *
+	 *  startReceiver(): anytime after initialize(). Will fail if state already is 'running'
+	 *
+	 *  abort(),
+	 *  stopReceiver() : anytime after initialize(). Will do nothing if state already is idle.
+	 *
+	 *  getStatus() returns the actual state of the data receiver - running or idle. All other
+	 *  get*() and set*() methods access the local cache of configuration values only and *do not* modify the data receiver settings.
+	 *
+	 *  Only startReceiver() does change the data receiver configuration, it does pass the whole configuration cache to the data receiver.
+	 *
+	 *  get- and set-methods that return a char array (char *) allocate a new array at each call. The caller is responsible to free the allocated space:
+	 *
+	 *      char *c = receiver->getFileName();
+	 *          ....
+	 *      delete[] c;
+	 *
+	 *  always: 1:YES       0:NO      for int as bool-like arguments
+	 *
+	 */
+	
+ public:
+	
+	/**
+	 * Destructor
+	 */
+  dummyUDPInterface() :  UDPInterface(), dynamicRange(16), scanTag(1000), nFrames(100), fWrite(1), fOverwrite(1), fIndex(0), fCaught(0), totfCaught(0), startAcqIndex(0), startFrameIndex(0), acqIndex(0), dataCompression(false), period(0), type(slsReceiverDefs::GENERIC), framesNeeded(100), udpPort1(1900), udpPort2(1901),  shortFrame(0), nFramesToGui(0), e10G(0) {strcpy(detHostname,"none"); strcpy(fName,"run"); strcpy(fPath,"/scratch/"); strcpy(eth,"eth0"); cout << "New dummy UDP Interface" << endl;
+		     
+		     	
+
+
+};
+
+    ~dummyUDPInterface() {cout << "Destroying  dummy UDP Interface" << endl;};
+	
+
+    void del(){cout << "Destroying  dummy UDP Interface" << endl;};
+	
+  virtual void configure(map<string, string> config_map) {};
+	/**
+	 * Initialize the Receiver
+	 @param detectorHostName detector hostname
+	 * you can call this function only once. You must call it before you call startReceiver() for  the first time.
+	 */
+  virtual void initialize(const char *detectorHostName){ cout << "set detector hostname to" << detHostname << endl; strcpy(detHostname,detectorHostName);};
+	
+
+	 /* Returns detector hostname
+	    /returns hostname
+	    * caller needs to deallocate the returned char array.
+	    * if uninitialized, it must return NULL
+	    */
+  virtual char *getDetectorHostname() const { cout << "get detector hostname " << detHostname << endl; return (char*) detHostname;};
+
+	/**
+	 * Returns status of receiver: idle, running or error
+	 */
+	virtual slsReceiverDefs::runStatus getStatus() const { cout << "get dsummy status IDLE "  << endl; return slsReceiverDefs::IDLE;};;
+
+	/**
+	 * Returns File Name
+	 * caller is responsible to deallocate the returned char array.
+	 */
+	virtual char *getFileName() const  { cout << "get file name " << fName << endl; return (char*) fName;};
+
+
+	/**
+	 * Returns File Path
+	 * caller is responsible to deallocate the returned char array
+	 */
+	virtual char *getFilePath() const  { cout << "get file path " << fPath << endl; return  (char*) fPath;};;
+
+
+	/**
+	 * Returns the number of bits per pixel
+	 */
+	virtual int getDynamicRange() const { cout << "get dynamic range " << dynamicRange << endl; return dynamicRange;};;
+
+	/**
+	 * Returns scan tag
+	 */
+	virtual int getScanTag() const  { cout << "get scan tag " << scanTag << endl; return scanTag;};
+
+	/*
+	 * Returns number of frames to receive
+	 * This is the number of frames to expect to receiver from the detector.
+	 * The data receiver will change from running to idle when it got this number of frames
+	 */
+	virtual int getNumberOfFrames() const  { cout << "get number of frames " << nFrames << endl; return nFrames;};
+
+	/**
+	* Returns file write enable
+	* 1: YES 0: NO
+	*/
+	virtual int getEnableFileWrite() const  { cout << "get enable file write " << fWrite << endl; return fWrite;};
+
+	/**
+	* Returns file over write enable
+	* 1: YES 0: NO
+	*/
+	virtual int getEnableOverwrite() const  { cout << "get enable file overwrite " << fOverwrite << endl; return fOverwrite;};
+
+	/**
+	 * Set File Name (without frame index, file index and extension)
+	 @param c file name
+	 /returns file name
+	  * returns NULL on failure (like bad file name)
+	  * does not check the existence of the file - we don't know which path we'll finally use, so no point to check.
+	  * caller is responsible to deallocate the returned char array.
+	 */
+	virtual char* setFileName(const char c[])  { strcpy(fName,c); cout << "set file name " << fName << endl; return fName; };
+
+	/**
+	 * Set File Path
+	 @param c file path
+	 /returns file path
+	  * checks the existence of the directory. returns NULL if directory does not exist or is not readable.
+	  * caller is responsible to deallocate the returned char array.
+	 */
+	virtual char* setFilePath(const char c[]) { strcpy(fPath,c); cout << "set file path " << fPath << endl; return fPath; };
+
+	/**
+	 * Returns the number of bits per pixel
+	 @param dr sets dynamic range
+	 /returns dynamic range
+	  * returns -1 on failure
+	  * FIXME: what are the allowd values - should we use an enum as argument?
+	 */
+	virtual int setDynamicRange(const int dr)  {dynamicRange=dr; cout << "set dynamic range " << dynamicRange << endl; return dynamicRange; };
+
+
+	/**
+	 * Set scan tag
+	 @param tag scan tag
+	 /returns scan tag (always non-negative)
+	  * FIXME: valid range - only positive? 16bit ore 32bit?
+	  * returns -1 on failure
+	 */
+	virtual int setScanTag(const int tag)  {scanTag=tag; cout << "set scan tag " << scanTag << endl; return scanTag; };
+
+
+	/**
+	 * Sets number of frames
+	 @param fnum number of frames
+	 /returns number of frames
+	 */
+	virtual int setNumberOfFrames(const int fnum) {nFrames=fnum; cout << "set number of frames " << nFrames << endl; return nFrames; };
+
+
+	/**
+	 * Set enable file write
+	 * @param i file write enable
+	 /returns file write enable
+	 */
+	virtual int setEnableFileWrite(const int i)  {fWrite=i; cout << "set enable file write " << fWrite << endl; return fWrite; };
+
+
+	/**
+	 * Set enable file overwrite
+	 * @param i file overwrite enable
+	 /returns file overwrite enable
+	 */
+	virtual int setEnableOverwrite(const int i)  {fOverwrite=i; cout << "set enable file overwrite " << fOverwrite << endl; return fOverwrite; };
+
+
+	/**
+	 * Starts Receiver - activate all configuration settings to the eiger receiver and start to listen for packets
+	 @param message is the error message if there is an error
+	 /returns 0 on success or -1 on failure
+	 */
+	//FIXME: success == 0 or success == 1?
+	virtual int startReceiver(char *message=NULL) {cout << "dummy start receiver" << endl; 
+	  char buff[8225];
+	  buff[8224]='\0';
+	  int ip=0;
+	  int ib;
+	  genericSocket *udpSocket= new genericSocket(50004,genericSocket::UDP,8224);
+	  while((ib=udpSocket->ReceiveDataOnly(buff,8224))>0) {
+	    cout << "***   "<< ib <<"  **************************  " << ip++ << endl;
+	    cout << buff << endl;
+	    cout << "*****************************" << endl << endl<< endl ;
+	  }
+return 0;};
+
+	/**
+	 * Stops Receiver - stops listening for packets
+	 /returns success
+	  * same as abort(). Always returns 0.
+	 */
+	virtual int stopReceiver()  {cout << "dummy stop receiver" << endl; return 0;};
+
+	/**
+	 * abort acquisition with minimum damage: close open files, cleanup.
+	 * does nothing if state already is 'idle'
+	 */
+	virtual void abort()   {cout << "Aborting receiver" << endl; };
+
+
+
+/*******************************************************************************************************************
+ ****************************************  Added by Dhanya *********************************************************
+ *******************************************************************************************************************/
+
+	/**
+	 * Returns File Index
+	 */
+	virtual int getFileIndex() {cout << "get file index " << fIndex << endl; return fIndex;};
+
+	/**
+	 * Returns Total Frames Caught for an entire acquisition (including all scans)
+	 */
+	virtual int getTotalFramesCaught() {cout << "get total frames caught " << totfCaught << endl ; return  totfCaught;};
+	
+	/**
+	 * Returns Frames Caught for each real time acquisition (eg. for each scan)
+	 */
+	virtual int getFramesCaught()  {cout << "get frames caught " << fCaught << endl; return   fCaught;};
+
+
+	/**
+	 * Returns the frame index at start of entire acquisition (including all scans)
+	 */
+	virtual uint32_t getStartAcquisitionIndex(){ cout << "get start acquisition index " << startAcqIndex << endl; return startAcqIndex; };
+	
+	/**
+	 * Returns current Frame Index Caught for an entire  acquisition (including all scans)
+	 */
+	virtual uint32_t getAcquisitionIndex(){ cout << "get acquisition index " << acqIndex << endl; return acqIndex; };
+	
+	
+	/**
+	 * Returns the frame index at start of each real time acquisition (eg. for each scan)
+	 */
+	virtual uint32_t getStartFrameIndex() { cout << "get start frame index " << startFrameIndex << endl; return startFrameIndex; };
+	
+	
+	/** get data compression, by saving only hits
+	 */
+	virtual bool getDataCompression() { cout << "get data compression " << dataCompression << endl; return dataCompression;};
+
+	/**
+	 * Set receiver type
+	 * @param det detector type
+	 * Returns success or FAIL
+	 */
+	virtual int setDetectorType(slsReceiverDefs::detectorType det) {type=det; cout << "set detector type " << det << endl; return slsReceiverDefs::OK;};
+	
+	/**
+	 * Set File Index
+	 * @param i file index
+	 */
+	virtual int setFileIndex(int i) {fIndex=i; cout << "get file index " << fIndex << endl; return fIndex;};
+	
+	/** set acquisition period if a positive number
+	 */
+	virtual int64_t setAcquisitionPeriod(int64_t index) {if (index>=0) {period=index; cout << "set period " << period << endl;} else { cout << "get period " << period << endl;} return period;};
+
+	/**
+	 * Set Frame Index Needed
+	 * @param i frame index needed
+	 */
+	virtual int setFrameIndexNeeded(int i) {framesNeeded=i;  cout << "set frame index needed " << period << endl; return framesNeeded;};
+
+	/**
+	 * Set UDP Port Number
+	 */
+	virtual void setUDPPortNo(int p){udpPort1=p;  cout << "set UDP port 1 " << udpPort1 << endl; };
+
+
+	/**
+	 * Set UDP Port Number
+	 */
+	virtual void setUDPPortNo2(int p) {udpPort2=p;  cout << "set UDP port 2 " << udpPort2 << endl; };
+
+	/**
+	 * Set Ethernet Interface or IP to listen to
+	 */
+	virtual void setEthernetInterface(char* c){strcpy(eth,c); cout << "set eth " << c;};
+
+	/**
+	 * Set short frame
+	 * @param i if shortframe i=1
+	 */
+	virtual int setShortFrame(int i){shortFrame=i; cout << " set short frame" << shortFrame << endl; return shortFrame;};
+
+	/**
+	 * Set the variable to send every nth frame to gui
+	 * or if 0,send frame only upon gui request
+	 */
+	virtual int setNFrameToGui(int i) {nFramesToGui=i; cout << "set nframes to gui " << nFramesToGui << endl; return nFramesToGui;};
+
+	/**
+	 * Resets the Total Frames Caught
+	 * This is how the receiver differentiates between entire acquisitions
+	 * Returns 0
+	 */
+	virtual void resetTotalFramesCaught() {totfCaught=0; cout << "total frames caugh reset " << totfCaught << endl;};
+
+	/** enabl data compression, by saving only hits
+	 /returns if failed
+	 */
+	virtual int enableDataCompression(bool enable) {dataCompression=enable; cout << "set data compression " << dataCompression<< endl; return dataCompression;};
+
+	/**
+	 * enable 10Gbe
+	 @param enable 1 for 10Gbe or 0 for 1 Gbe, -1 to read out
+	 \returns enable for 10Gbe
+	 */
+	virtual int enableTenGiga(int enable = -1) {if (enable>=0) {e10G=enable; cout << "set 10Gb "<< e10G << endl;} else cout << "get 10Gb "<< e10G << endl; return e10G;};
+
+	/**
+	 * Returns the buffer-current frame read by receiver
+	 * @param c pointer to current file name
+	 * @param raw address of pointer, pointing to current frame to send to gui
+	 * @param fnum frame number for eiger as it is not in the packet
+	 * @param startAcquisitionIndex is the start index of the acquisition
+	 * @param startFrameIndex is the start index of the scan
+	 */
+	virtual void readFrame(char* c,char** raw, uint32_t &fnum, uint32_t &startAcquisitionIndex, uint32_t &startFrameIndex){cout << "dummy read frame" << endl; };
+
+	/** set status to transmitting and
+	 * when fifo is empty later, sets status to run_finished
+	 */
+	virtual void startReadout(){cout << "dummy start readout" << endl; };
+
+	/**
+	 * shuts down the  udp sockets
+	 * \returns if success or fail
+	 */
+	virtual int shutDownUDPSockets(){cout << "dummy shut down udp sockets" << endl; return slsReceiverDefs::OK;};
+
+	/**
+	 * Closes all files
+	 * @param ithr thread index, -1 for all threads
+	 */
+	virtual void closeFile(int ithr = -1){cout << "dummy close file" << ithr << endl; };
+
+	/**
+	 * Call back for start acquisition
+	   callback arguments are
+	   filepath
+	   filename
+	   fileindex
+	   datasize
+
+	   return value is
+	   0 callback takes care of open,close,wrie file
+	   1 callback writes file, we have to open, close it
+	   2 we open, close, write file, callback does not do anything
+	*/
+	virtual void registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg){cout << "dummy register callback start acquisition" << endl; };
+
+	/**
+	 * Call back for acquisition finished
+	   callback argument is
+	   total frames caught
+	*/
+	virtual void registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg){cout << "dummy register callback acquisition finished" << endl; }; 
+
+	/**
+	 * Call back for raw data
+	  args to raw data ready callback are
+	  framenum
+	  datapointer
+	  datasize in bytes
+	  file descriptor
+	  guidatapointer (NULL, no data required)
+	*/
+virtual void registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg){cout << "dummy register callback get raw data" << endl; }; 
+	
+ protected:
+	
+ private:
+ char detHostname[1000];
+	char fName[10000];
+	char fPath[10000];
+	int dynamicRange;
+	int scanTag;
+	int nFrames;
+	int fWrite;
+	int fOverwrite;
+
+	int fIndex;
+	int fCaught;
+int totfCaught;
+int startAcqIndex;
+int startFrameIndex;
+int acqIndex;
+bool dataCompression;
+ int64_t period;
+ slsReceiverDefs::detectorType type;
+ int framesNeeded;
+ int udpPort1;
+ int udpPort2;
+ char eth[1000];
+ int shortFrame;
+ int nFramesToGui;
+ int e10G;
+};
+
+#endif  /* #ifndef DUMMYUDPINTERFACE_H */

slsReceiverSoftware/include/genericSocket.h

@@ -0,0 +1,735 @@
+
+#ifndef GENERIC_SOCKET_H
+#define GENERIC_SOCKET_H
+
+
+#include "ansi.h"
+
+
+/**
+ * 
+ * @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
+ */
+
+
+
+//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)
+*/
+
+#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>
+
+#endif
+#include <stdlib.h>  /******exit */
+
+#include <unistd.h>
+#include <string.h>
+#include <iostream>
+
+#include <math.h>
+#include <errno.h>
+#include <stdio.h>
+
+
+
+using namespace std;
+
+#define DEFAULT_PACKET_SIZE 1286
+/*#define SOCKET_BUFFER_SIZE (100*1024*1024) //100MB*/
+#define SOCKET_BUFFER_SIZE (2000*1024*1024) //100MB
+#define DEFAULT_PORTNO    1952
+#define DEFAULT_BACKLOG 5
+#define DEFAULT_UDP_PORTNO 50001
+#define DEFAULT_GUI_PORTNO 65000
+#define DEFAULT_ZMQ_PORTNO 70001
+
+
+
+class genericSocket{
+
+ public:
+
+  /** 
+     Communication protocol 
+*/
+enum communicationProtocol{
+  TCP,  /**< TCP/IP */
+  UDP /**< UDP */
+};
+
+
+
+ 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),
+	 socketDescriptor(-1),
+	 file_des(-1),
+	 packet_size(ps),
+	 nsending(0),
+	 nsent(0),
+	 total_sent(0),// sender (client): where to? ip
+	 header_packet_size(0)
+   { 
+	 memset(&serverAddress, 0, sizeof(serverAddress));
+	 memset(&clientAddress, 0, sizeof(clientAddress));
+  //   strcpy(hostname,host_ip_or_name);
+
+	 strcpy(lastClientIP,"none");
+	 strcpy(thisClientIP,"none1");
+	 strcpy(dummyClientIP,"dummy");
+	 differentClients = 0;
+
+     struct hostent *hostInfo = gethostbyname(host_ip_or_name);
+     if (hostInfo == NULL){
+       cerr << "Exiting: Problem interpreting host: " << host_ip_or_name << "\n";
+     } else {
+       // Set some fields in the serverAddress structure.  
+       serverAddress.sin_family = hostInfo->h_addrtype;
+       memcpy((char *) &serverAddress.sin_addr.s_addr, hostInfo->h_addr_list[0], hostInfo->h_length);
+       //((char *) &serverAddress.sin_addr.s_addr)[hostInfo->h_length]='\0'; //a fix for valgrind
+       serverAddress.sin_port = htons(port_number);   
+       socketDescriptor=0; //You can use send and recv, //would it work?????
+     } 
+     clientAddress_length=sizeof(clientAddress);
+   }
+
+   
+   int getProtocol(communicationProtocol p) {
+     switch (p) {
+     case TCP:
+       return SOCK_STREAM;
+       break;
+     case UDP:
+       return SOCK_DGRAM;
+       
+     default: 
+       cerr << "unknow protocol " << p << endl;
+       return -1;
+     }
+   }
+   
+   int getProtocol() {return getProtocol(protocol);};
+   
+
+
+
+  /** 
+      The constructor for a server
+      @short the contructor for a server
+      \param port_number port number to listen to
+      \param p TCP or UDP
+      \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):
+     //portno(port_number),
+     protocol(p),
+     is_a_server(1),
+     socketDescriptor(-1),
+     file_des(-1),
+     packet_size(ps),
+	 nsending(0),
+	 nsent(0),
+	 total_sent(0),
+	 header_packet_size(hsize)
+   {
+
+	  memset(&serverAddress, 0, sizeof(serverAddress));
+	  memset(&clientAddress, 0, sizeof(clientAddress));
+/* // you can specify an IP address: */
+/* // or you can let it automatically select one: */
+/* myaddr.sin_addr.s_addr = INADDR_ANY; */
+
+
+		 strcpy(lastClientIP,"none");
+		 strcpy(thisClientIP,"none1");
+		 strcpy(dummyClientIP,"dummy");
+		 differentClients = 0;
+
+	 if(serverAddress.sin_port == htons(port_number)){
+		 socketDescriptor = -10;
+		 return;
+	 }
+
+     char ip[20];
+
+     strcpy(ip,"0.0.0.0");
+     clientAddress_length=sizeof(clientAddress);
+     if (eth) {
+       strcpy(ip,nameToIp(string(eth)).c_str());
+       if (string(ip)==string("0.0.0.0"))
+	 strcpy(ip,eth);
+     }
+    
+     // strcpy(hostname,"localhost"); //needed?!?!?!?
+    
+
+     socketDescriptor = socket(AF_INET, getProtocol(),0); //tcp
+
+     if (socketDescriptor < 0) {
+       cerr << "Can not create socket "<<endl;
+       return;
+     } 
+     
+     // 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 (string(ip)!=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(socketDescriptor,SOL_SOCKET,SO_REUSEADDR,&val,sizeof(int)) == -1) {
+    	 cerr << "setsockopt" << endl;
+    	 socketDescriptor=-1;
+         return;
+     }
+
+
+     //increase buffer size if its udp
+     val = SOCKET_BUFFER_SIZE;
+     if((p == UDP) && (setsockopt(socketDescriptor, SOL_SOCKET, SO_RCVBUF, &val, sizeof(int)) == -1))
+     {
+       cerr << "WARNING:Could not set socket receive buffer size" << endl;
+       //socketDescriptor=-1;
+       //return;
+     }
+
+
+
+     if(bind(socketDescriptor,(struct sockaddr *) &serverAddress,sizeof(serverAddress))<0){
+       cerr << "Can not bind socket "<< endl;
+       socketDescriptor=-1;
+       return;
+     }
+
+
+     if (getProtocol()==SOCK_STREAM)
+       listen(socketDescriptor, DEFAULT_BACKLOG); 
+
+   }
+  
+
+
+
+
+
+
+
+
+
+
+
+
+     /** 
+	 The destructor: disconnects and close the socket
+	 @short the destructor 
+	 
+     */
+     ~genericSocket(){				\
+       Disconnect();
+       if (socketDescriptor >= 0){		\
+	 close(socketDescriptor);		\
+       }					\
+       if(is_a_server and getProtocol() == TCP){\
+    	   if(file_des>0)\
+    		   close(file_des);\
+       }
+	   file_des=-1;				\
+       serverAddress.sin_port=-1;	\
+     };
+     
+
+/*      /\** @short if client returns hostname for connection */
+/* 	 \param name string to write the hostname to */
+/* 	 \returns 0 if client, 1 if server (in this case ignore name return value) */
+
+/*      *\/ */
+/*      int getHostname(char *name){ */
+/*        if (is_a_server==0) { */
+/* 	 strcpy(name,getHostname().c_str()); */
+/*        } */
+/*        return is_a_server; */
+/*      }; */
+/*       /\** @short if client returns hostname for connection */
+/* 	 \returns hostname */
+
+/*       *\/ */
+/*      string getHostname(){return string(hostname);}; */
+
+/*      /\** @short returns port number for connection */
+/* 	 \returns port number */
+/*      *\/ */
+/*      int getPortNumber(){return portno;}; */
+
+    /** @short returns communication protocol
+	 \returns TCP or UDP
+     */
+     int getCommunicationProtocol(){return protocol;};
+
+
+    /** @short returns error status
+	 \returns 1 if error
+     */
+     int getErrorStatus(){if (socketDescriptor==-10) return -10; else if (socketDescriptor<0) return 1; else return 0;};
+     
+
+ /** @short etablishes connection; disconnect should always follow
+	 \returns 1 if error
+     */
+     int  Connect(){//cout<<"connect"<<endl;
+
+     if(file_des>0) return file_des;
+       if (protocol==UDP) return -1;
+
+     if(is_a_server && protocol==TCP){ //server tcp; the server will wait for the clients connection
+    	 if (socketDescriptor>0) {
+    		 if ((file_des = accept(socketDescriptor,(struct sockaddr *) &clientAddress, &clientAddress_length)) < 0) {
+    			 cerr << "Error: with server accept, connection refused"<<endl;
+    			 switch(errno) {
+    			 case EWOULDBLOCK:
+    				 printf("ewouldblock eagain\n");
+    				 break;
+    			 case EBADF:
+    				 printf("ebadf\n");
+    				 break;
+    			 case ECONNABORTED:
+    				 printf("econnaborted\n");
+    				 break;
+    			 case EFAULT:
+    				 printf("efault\n");
+    				 break;
+    			 case EINTR:
+    				 printf("eintr\n");
+    				 break;
+    			 case EINVAL:
+    				 printf("einval\n");
+    				 break;
+    			 case EMFILE:
+    				 printf("emfile\n");
+    				 break;
+    			 case ENFILE:
+    				 printf("enfile\n");
+    				 break;
+    			 case ENOTSOCK:
+    				 printf("enotsock\n");
+    				 break;
+    			 case EOPNOTSUPP:
+    				 printf("eOPNOTSUPP\n");
+    				 break;
+    			 case ENOBUFS:
+    				 printf("ENOBUFS\n");
+    				 break;
+    			 case ENOMEM:
+    				 printf("ENOMEM\n");
+    				 break;
+    			 case ENOSR:
+    				 printf("ENOSR\n");
+    				 break;
+    			 case EPROTO:
+    				 printf("EPROTO\n");
+    				 break;
+    			 default:
+    				 printf("unknown error\n");
+    			 }
+    			 socketDescriptor=-1;
+    		 }
+    		 else{
+    			 inet_ntop(AF_INET, &(clientAddress.sin_addr), dummyClientIP, INET_ADDRSTRLEN);
+#ifdef VERY_VERBOSE
+    			 cout << "client connected "<< file_des << endl;
+#endif
+
+    		 }
+
+    	 }
+    	 // file_des = socketDescriptor;
+
+#ifdef VERY_VERBOSE
+    	 cout << "fd " << file_des  << endl;
+#endif
+     } else {
+    	 if (socketDescriptor<=0)
+    		 socketDescriptor = socket(AF_INET, getProtocol(),0);
+    	 //    SetTimeOut(10);
+    	 if (socketDescriptor < 0){
+    		 cerr << "Can not create socket "<<endl;
+    		 file_des = socketDescriptor;
+    	 } else {
+    		 if(connect(socketDescriptor,(struct sockaddr *) &serverAddress,sizeof(serverAddress))<0){
+    			 cerr << "Can not connect to socket "<<endl;
+    			 file_des = -1;
+    		 } else{
+    			 file_des = socketDescriptor;
+    		 }
+    	 }
+
+     }
+     return file_des;
+     }
+
+     uint16_t getPortNumber(){
+    	 return ntohs(serverAddress.sin_port);
+     }
+
+     int getFileDes(){return file_des;};
+
+     int getsocketDescriptor(){return socketDescriptor;};
+
+
+     void exitServer(){
+    	 if(is_a_server){
+    		  if (socketDescriptor>=0){
+    		    close(socketDescriptor);
+    		    socketDescriptor = -1;
+    		  }
+    	 }
+     }
+
+     /** @short free connection */
+     void Disconnect(){
+    	 if (protocol==UDP){
+    		 close(socketDescriptor);
+    		 socketDescriptor=-1;
+    	 }
+    	 else{
+    		 if(file_des>=0){ //then was open
+    			 if(is_a_server){
+    				 close(file_des);
+    			 }
+    			 else {
+    				 //while(!shutdown(socketDescriptor, SHUT_RDWR));
+    				 close(socketDescriptor);
+    				 socketDescriptor=-1;
+    			 }
+    			 file_des=-1;
+    		 }
+    	 }
+     }; 
+
+
+     void ShutDownSocket(){
+    	 while(!shutdown(socketDescriptor, SHUT_RDWR));
+    	 Disconnect();
+     };
+
+
+
+     /** Set the socket timeout ts is in seconds */
+     int SetTimeOut(int ts){
+
+
+       if (ts<=0)
+	 return -1;
+       
+       //cout << "socketdescriptor "<< socketDescriptor << endl; 
+       struct timeval tout;
+       tout.tv_sec  = 0;
+       tout.tv_usec = 0;
+       if(::setsockopt(socketDescriptor, SOL_SOCKET, SO_RCVTIMEO, &tout, sizeof(struct timeval)) <0)
+	 {
+	   cerr << "Error in setsockopt SO_RCVTIMEO "<< 0 << endl;
+	 }
+       tout.tv_sec  = ts;
+       tout.tv_usec = 0;
+       if(::setsockopt(socketDescriptor, SOL_SOCKET, SO_SNDTIMEO, &tout, sizeof(struct timeval)) < 0)
+	 {
+	   cerr << "Error in setsockopt SO_SNDTIMEO " << ts <<  endl;
+	 }
+       return 0;
+       
+
+     };
+
+   
+     int setPacketSize(int i=-1) { if (i>=0) packet_size=i;return packet_size;};
+
+  
+
+     static string ipToName(string ip) {
+       struct ifaddrs *addrs, *iap;
+       struct sockaddr_in *sa;
+       char buf[32];
+
+       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, sizeof(buf));
+	   if (ip==string(buf)) {
+	     //printf("%s\n", iap->ifa_name);
+	     strcpy(buf,iap->ifa_name);
+	     break;
+	   }
+	 }
+       }
+       freeifaddrs(addrs);
+       return string(buf);
+     };
+     
+     static string nameToMac(string inf) {
+       struct ifreq ifr;
+       int sock, j, k;
+       char mac[32];
+       
+       sock=getSock(inf,&ifr);
+       
+       if (-1==ioctl(sock, SIOCGIFHWADDR, &ifr)) {
+	 perror("ioctl(SIOCGIFHWADDR) ");
+	 return string("00:00:00:00:00:00");
+       }
+       for (j=0, k=0; j<6; j++) {
+	 k+=snprintf(mac+k, sizeof(mac)-k-1, j ? ":%02X" : "%02X",
+		     (int)(unsigned int)(unsigned char)ifr.ifr_hwaddr.sa_data[j]);
+       }
+       mac[sizeof(mac)-1]='\0';
+       
+       if(sock!=1){
+    	   close(sock);
+       }
+       return string(mac);
+       
+     };
+    
+
+     
+     static string nameToIp(string inf){
+       struct ifreq ifr;
+       int sock;
+       char *p, addr[32];
+       
+       sock=getSock(inf,&ifr);
+       
+       if (-1==ioctl(sock, SIOCGIFADDR, &ifr)) {
+	 perror("ioctl(SIOCGIFADDR) ");
+	 return string("0.0.0.0");
+       }
+       p=inet_ntoa(((struct sockaddr_in *)(&ifr.ifr_addr))->sin_addr);
+       strncpy(addr,p,sizeof(addr)-1);
+       addr[sizeof(addr)-1]='\0';
+       
+       if(sock!=1){
+    	   close(sock);
+       }
+       return string(addr);
+       
+     };
+     
+     static int getSock(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;
+
+     };
+
+    
+     int ReceiveDataOnly(void* buf,int length=0){
+
+    	 if (buf==NULL) return -1;
+
+    	 total_sent=0;
+
+    	 switch(protocol) {
+    	 case TCP:
+    		 if (file_des<0) return -1;
+    		 while(length>0){
+    			 nsending = (length>packet_size) ? packet_size:length;
+    			 nsent = read(file_des,(char*)buf+total_sent,nsending);
+    			 if(!nsent) 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 (socketDescriptor<0) return -1;
+    		 //if length given, listens to length, else listens for packetsize till length is reached
+    		 if(length){
+
+    			 /*int k = 0;*/
+
+    			 while(length>0){
+   					 nsending = (length>packet_size) ? packet_size:length;
+    			     nsent = recvfrom(socketDescriptor,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length);
+    				 if(nsent != nsending){ //if((nsent != nsending)){ && (nsent < packet_size)){
+    					 if(nsent && (nsent != header_packet_size) && (nsent != -1))
+    							 cprintf(RED,"Incomplete Packet size %d\n",nsent);
+    					 break;
+    				 }
+    				 length-=nsent;
+    				 total_sent+=nsent;
+    			 }
+    		 }
+    		 //listens to only 1 packet
+    		 else{
+    			 //normal
+    			 nsending=packet_size;
+    			 while(1){
+    				 nsent = recvfrom(socketDescriptor,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, &clientAddress_length);
+      				 if(nsent<=0 || nsent == packet_size)
+    					 break;
+    				 if(nsent != packet_size && nsent != header_packet_size)
+    						cprintf(RED,"Incomplete Packet size %d\n",nsent);
+    			 }
+    			//nsent = 1040;
+    			total_sent+=nsent;
+    		 }
+    		 break;
+    	 default:
+    		 ;
+    	 }
+#ifdef VERY_VERBOSE
+    	 cout << "sent "<< total_sent << " Bytes" << endl;
+#endif
+
+
+    	 return total_sent;
+
+
+
+     }
+
+
+     int SendDataOnly(void *buf, int length) {
+#ifdef VERY_VERBOSE
+       cout << "want to send "<< length << " Bytes" << endl; 
+#endif
+       if (buf==NULL) return -1;
+       
+       total_sent=0;
+       
+
+       switch(protocol) {
+       case TCP:
+	 if (file_des<0) return -1;
+	 while(length>0){
+	   nsending = (length>packet_size) ? packet_size:length;
+	   nsent = write(file_des,(char*)buf+total_sent,nsending); 
+	   if(!nsent) break;
+	   length-=nsent;
+	   total_sent+=nsent;
+	 }
+	 break;
+       case UDP:
+	 if (socketDescriptor<0) return -1;
+	 while(length>0){
+	   nsending = (length>packet_size) ? packet_size:length;
+	   nsent = sendto(socketDescriptor,(char*)buf+total_sent,nsending, 0, (struct sockaddr *) &clientAddress, clientAddress_length); 
+	   if(!nsent) break;
+	   length-=nsent;
+	   total_sent+=nsent;
+	 }
+	 
+	 break;
+       default:
+	 ;
+       }
+#ifdef VERY_VERBOSE
+       cout << "sent "<< total_sent << " Bytes" << endl; 
+#endif
+       return total_sent;
+       
+
+     }
+
+
+     int getCurrentTotalReceived(){
+    	 return total_sent;
+     }
+
+     char lastClientIP[INET_ADDRSTRLEN];
+     char thisClientIP[INET_ADDRSTRLEN];
+     int differentClients;
+
+
+ protected:
+
+  communicationProtocol protocol; 
+  int is_a_server;
+  int socketDescriptor;
+  int file_des;
+  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;
+       
+
+  // pthread_mutex_t mp;
+};
+#endif

slsReceiverSoftware/include/gitInfoReceiver.h

@@ -0,0 +1,11 @@
+//#define SVNPATH ""
+#define SVNURL "git@git.psi.ch:sls_detectors_software/sls_receiver_software.git"
+//#define SVNREPPATH ""
+#define SVNREPUUID "2f78f4e118bfba443f84a3f72b2839610a8858a3"
+//#define SVNREV 0x493
+//#define SVNKIND ""
+//#define SVNSCHED ""
+#define SVNAUTH "Dhanya_Maliakal"
+#define SVNREV 0x493
+#define SVNDATE 0x20161130
+//

slsReceiverSoftware/include/gitInfoReceiverTmp.h

@@ -0,0 +1,11 @@
+//#define SVNPATH ""
+#define SVNURL ""
+//#define SVNREPPATH ""
+#define SVNREPUUID ""
+//#define SVNREV ""
+//#define SVNKIND ""
+//#define SVNSCHED ""
+#define SVNAUTH ""
+#define SVNREV ""
+#define SVNDATE ""
+//

slsReceiverSoftware/include/logger.h

@@ -0,0 +1,246 @@
+//#ifndef __LOG_H__
+//#define __LOG_H__
+
+#include <sstream>
+#include <string>
+#include <stdio.h>
+#include <unistd.h>
+#include <ansi.h>
+
+#ifdef VERBOSE
+#define FILELOG_MAX_LEVEL logDEBUG
+#endif
+
+#ifdef VERYVERBOSE
+#define FILELOG_MAX_LEVEL logDEBUG4
+#endif
+
+#ifdef FIFODEBUG
+#define FILELOG_MAX_LEVEL logDEBUG5
+#endif
+
+#ifndef FILELOG_MAX_LEVEL
+#define FILELOG_MAX_LEVEL logINFO
+#endif
+
+
+#define STRINGIFY(x) #x
+#define TOSTRING(x) STRINGIFY(x)
+#define MYCONCAT(x,y)  
+#define __AT__  string(__FILE__) + string("::") + string(__func__) + string("(): ")
+#define __SHORT_FORM_OF_FILE__ \
+(strrchr(__FILE__,'/') \
+? strrchr(__FILE__,'/')+1 \
+: __FILE__ \
+)
+#define __SHORT_AT__  string(__SHORT_FORM_OF_FILE__) + string("::") + string(__func__) + string("(): ")
+
+//":" TOSTRING(__LINE__)
+
+/*
+void error(const char *location, const char *msg){
+  printf("Error at %s: %s\n", location, msg);
+}
+*/
+
+inline std::string NowTime();
+
+enum TLogLevel {logERROR, logWARNING, 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);
+};
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#   if defined (BUILDING_FILELOG_DLL)
+#       define FILELOG_DECLSPEC   __declspec (dllexport)
+#   elif defined (USING_FILELOG_DLL)
+#       define FILELOG_DECLSPEC   __declspec (dllimport)
+#   else
+#       define FILELOG_DECLSPEC
+#   endif // BUILDING_DBSIMPLE_DLL
+#else
+#   define FILELOG_DECLSPEC
+#endif // _WIN32
+
+class FILELOG_DECLSPEC FILELog : public Log<Output2FILE> {};
+//typedef Log<Output2FILE> FILELog;
+
+#ifdef REST
+#define FILE_LOG(level) \
+	if (level > FILELOG_MAX_LEVEL) ;				\
+	else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
+	else FILELog().Get(level)
+#else
+	#define FILE_LOG(level) \
+	if (level > FILELOG_MAX_LEVEL) ;				\
+	else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
+	else FILELog().Get(level)
+#endif
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+
+#include <windows.h>
+
+
+
+inline std::string NowTime()
+
+{
+    const int MAX_LEN = 200;
+    char buffer[MAX_LEN];
+    if (GetTimeFormatA(LOCALE_USER_DEFAULT, 0, 0, 
+            "HH':'mm':'ss", buffer, MAX_LEN) == 0)
+        return "Error in NowTime()";
+
+    char result[100] = {0};
+    static DWORD first = GetTickCount();
+    sprintf(result, "%s.%03ld", buffer, (long)(GetTickCount() - first) % 1000); 
+    return result;
+}
+
+#else
+
+#include <sys/time.h>
+
+inline std::string NowTime()
+{
+    char buffer[11];
+    time_t t;
+    time(&t);
+    tm r = {0};
+    strftime(buffer, sizeof(buffer), "%X", localtime_r(&t, &r));
+    struct timeval tv;
+    gettimeofday(&tv, 0);
+    char result[100] = {0};
+    sprintf(result, "%s.%03ld", buffer, (long)tv.tv_usec / 1000);
+    return result;
+}
+
+#endif //WIN32
+
+
+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) << ": ";
+    os << std::string(level > logDEBUG ? level - logDEBUG : 0, '\t');
+    return os;
+}
+
+template <typename T> Log<T>::~Log()
+{
+    os << std::endl;
+#ifdef REST
+    T::Output( os.str());
+#else
+    T::Output( os.str(),lev);
+#endif
+}
+
+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", "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;
+    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(GRAY,"%s",msg.c_str());break;
+   // case logINFO:		cprintf(DARKGRAY BOLD,"%s",msg.c_str());break;
+    default: 			fprintf(pStream,"%s",msg.c_str()); 		break;
+    }
+    fflush(pStream);
+}
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#   if defined (BUILDING_FILELOG_DLL)
+#       define FILELOG_DECLSPEC   __declspec (dllexport)
+#   elif defined (USING_FILELOG_DLL)
+#       define FILELOG_DECLSPEC   __declspec (dllimport)
+#   else
+#       define FILELOG_DECLSPEC
+#   endif // BUILDING_DBSIMPLE_DLL
+#else
+#   define FILELOG_DECLSPEC
+#endif // _WIN32
+
+
+
+//#endif //__LOG_H__

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_ ]

slsReceiverSoftware/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_ ]

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/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_

slsReceiverSoftware/include/receiver_defs.h

@@ -0,0 +1,199 @@
+#ifndef RECEIVER_DEFS_H
+#define RECEIVER_DEFS_H
+
+#include "sls_receiver_defs.h"
+
+#include <stdint.h> 
+
+
+/**
+ * structure of an eiger packet header
+ * subframenum subframe number for 32 bit mode (already written by firmware)
+ * missingpacket explicitly put to 0xFF to recognize it in file read (written by software)
+ * portnum 0 for the first port and 1 for the second port (written by software to file)
+ * dynamicrange dynamic range or bits per pixel (written by software to file)
+ */
+typedef struct {
+	unsigned char subFrameNumber[4];
+	unsigned char missingPacket[2];
+	unsigned char portIndex[1];
+	unsigned char dynamicRange[1];
+} eiger_packet_header_t;
+/**
+ * structure of an eiger packet footer
+ * framenum 48 bit frame number (already written by firmware)
+ * packetnum packet number (already written by firmware)
+ */
+typedef struct	{
+	unsigned char frameNumber[6];
+	unsigned char packetNumber[2];
+} eiger_packet_footer_t;
+
+/**
+ * structure of an jungfrau packet header
+ * empty header
+ * framenumber
+ * packetnumber
+ */
+typedef struct {
+	unsigned char emptyHeader[6];
+	unsigned char reserved[4];
+	unsigned char packetNumber[1];
+	unsigned char frameNumber[3];
+	unsigned char bunchid[8];
+} jfrau_packet_header_t;
+
+
+#define GOODBYE 							-200
+
+#define DO_NOTHING		0
+#define CREATE_FILES	1
+#define DO_EVERYTHING	2
+
+#define BUF_SIZE        		(16*1024*1024) //16mb
+#define SAMPLE_TIME_IN_NS		100000000//100ms
+#define MAX_JOBS_PER_THREAD		1000
+#define HEADER_SIZE_NUM_TOT_PACKETS	4
+#define HEADER_SIZE_NUM_FRAMES	2
+#define HEADER_SIZE_NUM_PACKETS	1
+#define ALL_MASK_32				0xFFFFFFFF
+
+#define FILE_FRAME_HEADER_LENGTH	16
+#define FILE_HEADER_BUNCHID_OFFSET	8
+
+
+//all max frames defined in sls_receiver_defs.h.  20000 gotthard, 100000 for short gotthard, 1000 for moench, eiger 20000
+
+
+
+#define GOTTHARD_FIFO_SIZE					25000 //cannot be less than max jobs per thread = 1000
+/*#define GOTTHARD_ALIGNED_FRAME_SIZE		4096*/
+#define GOTTHARD_PACKETS_PER_FRAME			2
+#define GOTTHARD_ONE_PACKET_SIZE			1286
+#define GOTTHARD_ONE_DATA_SIZE				1280
+#define GOTTHARD_BUFFER_SIZE 				(GOTTHARD_ONE_PACKET_SIZE*GOTTHARD_PACKETS_PER_FRAME) 	//1286*2
+#define GOTTHARD_DATA_BYTES	 				(GOTTHARD_ONE_DATA_SIZE*GOTTHARD_PACKETS_PER_FRAME)		//1280*2
+
+#define GOTTHARD_FRAME_INDEX_MASK			0xFFFFFFFE
+#define GOTTHARD_FRAME_INDEX_OFFSET			1
+#define GOTTHARD_PACKET_INDEX_MASK			0x1
+
+#define GOTTHARD_PIXELS_IN_ROW				1280
+#define GOTTHARD_PIXELS_IN_COL				1
+
+
+#define GOTTHARD_SHORT_PACKETS_PER_FRAME	1
+#define GOTTHARD_SHORT_ONE_PACKET_SIZE		518
+#define GOTTHARD_SHORT_BUFFER_SIZE			518
+#define GOTTHARD_SHORT_DATABYTES			512
+#define GOTTHARD_SHORT_FRAME_INDEX_MASK		0xFFFFFFFF
+#define GOTTHARD_SHORT_FRAME_INDEX_OFFSET	0
+#define GOTTHARD_SHORT_PACKET_INDEX_MASK	0
+#define GOTTHARD_SHORT_PIXELS_IN_ROW		256
+#define GOTTHARD_SHORT_PIXELS_IN_COL		1
+
+
+
+
+
+#define PROPIX_PIXELS_IN_ROW				22
+#define PROPIX_PIXELS_IN_COL				22
+#define PROPIX_DATABYTES_PER_PIXEL			2
+
+#define PROPIX_FIFO_SIZE					25000 //cannot be less than max jobs per thread = 1000
+#define PROPIX_PACKETS_PER_FRAME			2
+#define PROPIX_ONE_PACKET_SIZE				1286
+#define PROPIX_BUFFER_SIZE 					(PROPIX_ONE_PACKET_SIZE*PROPIX_PACKETS_PER_FRAME) 	//1286*2
+//#define PROPIX_DATA_BYTES 					(1280*PROPIX_PACKETS_PER_FRAME) 	//1280*2
+#define PROPIX_DATA_BYTES	 				(PROPIX_PIXELS_IN_ROW * PROPIX_PIXELS_IN_COL * PROPIX_DATABYTES_PER_PIXEL) //22 * 22 * 2
+
+#define PROPIX_FRAME_INDEX_MASK				0xFFFFFFFE
+#define PROPIX_FRAME_INDEX_OFFSET			1
+#define PROPIX_PACKET_INDEX_MASK			0x1
+
+
+
+
+
+#define MOENCH_FIFO_SIZE					2500 //cannot be less than max jobs per thread = 1000
+/*#define MOENCH_ALIGNED_FRAME_SIZE			65536*/
+#define MOENCH_PACKETS_PER_FRAME			40
+#define MOENCH_ONE_PACKET_SIZE				1286
+#define MOENCH_ONE_DATA_SIZE				1280
+#define MOENCH_BUFFER_SIZE 					(MOENCH_ONE_PACKET_SIZE*MOENCH_PACKETS_PER_FRAME) 	//1286*40
+#define MOENCH_DATA_BYTES	 				(MOENCH_ONE_DATA_SIZE*MOENCH_PACKETS_PER_FRAME)		//1280*40
+
+#define MOENCH_FRAME_INDEX_MASK				0xFFFFFF00
+#define MOENCH_FRAME_INDEX_OFFSET			8
+#define MOENCH_PACKET_INDEX_MASK			0xFF
+
+#define MOENCH_BYTES_PER_ADC				(40*2)
+#define MOENCH_PIXELS_IN_ONE_ROW			160
+#define MOENCH_BYTES_IN_ONE_ROW				(MOENCH_PIXELS_IN_ONE_ROW*2)
+
+
+
+#define JFRAU_FIFO_SIZE						2500 //cannot be less than max jobs per thread = 1000
+#define JFRAU_PACKETS_PER_FRAME				128
+#define JFRAU_HEADER_LENGTH					22
+#define JFRAU_ONE_DATA_SIZE					8192
+#define JFRAU_ONE_PACKET_SIZE				(JFRAU_HEADER_LENGTH+JFRAU_ONE_DATA_SIZE) //8214
+#define JFRAU_DATA_BYTES	 				(JFRAU_ONE_DATA_SIZE*JFRAU_PACKETS_PER_FRAME)		//8192*128
+#define JFRAU_BUFFER_SIZE 					(JFRAU_ONE_PACKET_SIZE*JFRAU_PACKETS_PER_FRAME) 	//8214*128
+
+
+#define JFRAU_FRAME_INDEX_MASK				0xffffff //mask after using struct (48 bit)
+#define JFRAU_FRAME_INDEX_OFFSET			0x0 //Not Applicable, use struct
+#define JFRAU_PACKET_INDEX_MASK				0x0//Not Applicable, use struct
+
+#define JFRAU_PIXELS_IN_ONE_ROW				(256*4)
+#define JFRAU_PIXELS_IN_ONE_COL				(256*2)
+#define JFRAU_BYTES_IN_ONE_ROW				(JFRAU_PIXELS_IN_ONE_ROW*2)
+
+
+
+#define JCTB_FIFO_SIZE						2500 //cannot be less than max jobs per thread = 1000
+/*#define MOENCH_ALIGNED_FRAME_SIZE			65536*/
+#define JCTB_PACKETS_PER_FRAME			        1
+#define JCTB_ONE_PACKET_SIZE				8224
+#define JCTB_BUFFER_SIZE 				(JCTB_ONE_PACKET_SIZE*40) 	
+#define JCTB_DATA_BYTES	 				(8192*JCTB_PACKETS_PER_FRAME)					
+
+#define JCTB_FRAME_INDEX_MASK			0xFFFFFFFF
+#define JCTB_FRAME_INDEX_OFFSET			6+8
+#define JCTB_PACKET_INDEX_MASK			0xFFFFFFFF
+
+
+#define JCTB_BYTES_PER_ADC		        	(2)
+#define JCTB_PIXELS_IN_ONE_ROW				32
+#define JCTB_BYTES_IN_ONE_ROW		       (JCTB_PIXELS_IN_ONE_ROW*2)
+
+
+
+
+#define EIGER_MAX_PORTS 					2
+#define EIGER_HEADER_PACKET_LENGTH			48
+
+#define EIGER_FIFO_SIZE						100
+/*#define EIGER_ALIGNED_FRAME_SIZE			65536*/
+#define EIGER_ONE_GIGA_CONSTANT				16
+#define EIGER_TEN_GIGA_CONSTANT				4
+//#define EIGER_PACKETS_PER_FRAME_COSTANT		(16*EIGER_MAX_PORTS)//*bit mode  4*16=64, 8*16=128, 16*16=256, 32*16=512
+#define EIGER_ONE_GIGA_ONE_PACKET_SIZE		1040
+#define EIGER_ONE_GIGA_ONE_DATA_SIZE		1024
+#define EIGER_TEN_GIGA_ONE_PACKET_SIZE		4112
+#define EIGER_TEN_GIGA_ONE_DATA_SIZE		4096
+#define EIGER_DATA_PACKET_HEADER_SIZE		8
+//#define EIGER_BUFFER_SIZE_CONSTANT			(EIGER_ONE_PACKET_SIZE*EIGER_PACKETS_PER_FRAME_COSTANT)//1040*16*2//*bit mode
+//#define EIGER_DATA_BYTES_CONSTANT 			(EIGER_ONE_DATA_SIZE*EIGER_PACKETS_PER_FRAME_COSTANT)	//1024*16*2//*bit mode
+
+#define EIGER_FRAME_INDEX_MASK				0xFFFFFFFF //32 bit for now
+#define EIGER_FRAME_INDEX_OFFSET			0
+#define EIGER_PACKET_INDEX_MASK				0x0
+
+//for each thread
+#define EIGER_PIXELS_IN_ONE_ROW				(256*2)
+#define EIGER_PIXELS_IN_ONE_COL				(256)
+
+
+#endif

slsReceiverSoftware/include/slsReceiver.h

@@ -0,0 +1,91 @@
+/********************************************//**
+ * @file slsReceiver.h
+ * @short creates the UDP and TCP class objects
+ ***********************************************/
+#ifndef SLS_RECEIVER_H
+#define SLS_RECEIVER_H
+
+
+#include "slsReceiverTCPIPInterface.h"
+#include "UDPInterface.h"
+
+#include "receiver_defs.h"
+#include "MySocketTCP.h"
+//#include "utilities.h"
+
+
+/**
+ *@short creates the UDP and TCP class objects
+ */
+
+class slsReceiver : private virtual slsReceiverDefs {
+	
+ public:
+	/**
+	 * Constructor
+	 * creates the tcp interface and the udp class
+	 * @param argc from command line
+	 * @param argv from command line
+	 * @param succecc socket creation was successfull
+	 */
+	slsReceiver(int argc, char *argv[], int &success);
+
+	/**
+	 * Destructor
+	 */
+	~slsReceiver();
+
+	/**
+	 * starts listening on the TCP port for client comminication
+	 \return 0 for success or 1 for FAIL in creating TCP server
+	 */
+	int start();
+
+	/**
+	 * stops listening to the TCP & UDP port and exit receiver program
+	 */
+	void stop();
+
+	/**
+	 * Close File and exits receiver server
+	 */
+	void closeFile(int p);
+
+	/**
+	 * get get Receiver Version
+	 \returns id
+	 */
+	int64_t getReceiverVersion();
+
+	/**
+	 @sort register calbback for starting the acquisition
+	 @param func  callback to be called when starting the acquisition. Its arguments are filepath filename fileindex data size
+	 \returns	   0 callback takes care of open,close,write file; 	   1 callback writes file, we have to open, close it; 2 we open, close, write file, callback does not do anything
+	 */
+	void registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg);
+
+
+	/**
+	  callback argument is
+	  toatal farmes caught
+	 */
+	void registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg);
+
+	/**
+	  args to raw data ready callback are
+	  framenum
+	  datapointer
+	  datasize in bytes
+	  file descriptor
+	  guidatapointer (NULL, no data required)
+	 */
+	void registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg);
+
+
+ private:
+	slsReceiverTCPIPInterface* tcpipInterface;
+	UDPInterface* udp_interface;
+};
+
+
+#endif

slsReceiverSoftware/include/slsReceiverTCPIPInterface.h

@@ -0,0 +1,338 @@
+/********************************************//**
+ * @file slsReceiverTCPIPInterface.h
+ * @short interface between receiver and client
+ ***********************************************/
+#ifndef SLS_RECEIVER_TCP_IP_INTERFACE_H
+#define SLS_RECEIVER_TCP_IP_INTERFACE_H
+
+
+#include "sls_receiver_defs.h"
+#include "receiver_defs.h"
+#include "MySocketTCP.h"
+#include "UDPInterface.h"
+
+
+
+/**
+ *@short interface between receiver and client
+ */
+
+class slsReceiverTCPIPInterface : private virtual slsReceiverDefs {
+	
+ public:
+	/**
+	 * Constructor
+	 * reads config file, creates socket, assigns function table
+	 * @param succecc socket creation was successfull
+	 * @param rbase pointer to the receiver base
+	 * @param pn port number (defaults to default port number)
+	 */
+
+  slsReceiverTCPIPInterface(int &success, UDPInterface* rbase, int pn=-1);
+
+	/**
+	 * Sets the port number to listen to. 
+	 Take care that the client must know to whcih port it has to listen to, so normally it is better to use a fixes port from the instatiation or change it from the client.
+	 @param pn port number (-1 only get)
+	 \returns actual port number
+	*/
+	int setPortNumber(int pn=-1);
+	
+	/**
+	 * Starts listening on the TCP port for client comminication
+	 \returns OK or FAIL
+	 */
+	int start();
+
+	/** stop listening on the TCP & UDP port for client comminication */
+	void stop();
+
+	/** Destructor */
+	virtual ~slsReceiverTCPIPInterface();
+
+	/** Close all threaded Files and exit */
+	void closeFile(int p);
+
+	/** gets version */
+	int64_t getReceiverVersion();
+
+	//***callback functions***
+	/**
+	 * Call back for start acquisition
+	 * callback arguments are
+	 * filepath
+	 * filename
+	 * fileindex
+	 * datasize
+	 *
+	 * return value is the action which decides what the user and default responsibilities to save data are
+	 * 0 callback takes care of open,close,wrie file
+	 * 1 callback writes file, we have to open, close it
+	 * 2 we open, close, write file, callback does not do anything
+	 */
+	void registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg);
+
+	/**
+	 * Call back for acquisition finished
+	 * callback argument is
+	 * total frames caught
+	 */
+	void registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg);
+
+	/**
+	 * Call back for raw data
+	 * args to raw data ready callback are
+	 * framenum
+	 * datapointer
+	 * datasize in bytes
+	 * file descriptor
+	 * guidatapointer (NULL, no data required)
+	 */
+	void registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg);
+
+private:
+
+	/**
+	 * Static function - Thread started which is a TCP server
+	 * Called by start()
+	 * @param this_pointer pointer to this object
+	 */
+	static void* startTCPServerThread(void *this_pointer);
+
+
+	/**
+	 * Thread started which is a TCP server
+	 * Called by start()
+	 */
+	void startTCPServer();
+
+	/** assigns functions to the fnum enum */
+	int function_table();
+
+	/** Decodes Function */
+	int decode_function();
+
+	/** Unrecognized Function */
+	int M_nofunc();
+
+	/** Set detector type */
+	int set_detector_type();
+
+	/** Set File name without frame index, file index and extension */
+	int set_file_name();
+
+	/** Set File path */
+	int set_file_dir();
+
+	/** Set up UDP Details */
+	int setup_udp();
+
+	/** Set File index */
+	int set_file_index();
+
+	/** Set Frame index */
+	int set_frame_index();
+
+	/** Start Receiver - starts listening to udp packets from detector */
+	int start_receiver();
+
+	/** Stop Receiver - stops listening to udp packets from detector*/
+	int stop_receiver();
+
+	/** Gets receiver status */
+	int	get_status();
+
+	/** Gets Total Frames Caught */
+	int	get_frames_caught();
+
+	/** Gets frame index for each acquisition */
+	int	get_frame_index();
+
+	/** Resets Total Frames Caught */
+	int	reset_frames_caught();
+
+	/** set short frame */
+	int set_short_frame();
+
+	/** Reads Frame/ buffer */
+	int	read_frame();
+
+	/** gotthard specific read frame */
+	int gotthard_read_frame();
+
+	/** propix specific read frame */
+	int propix_read_frame();
+
+	/** moench specific read frame */
+	int moench_read_frame();
+
+	/** eiger specific read frame */
+	int eiger_read_frame();
+
+	/** jungfrau specific read frame */
+	int jungfrau_read_frame();
+
+	/** Sets the receiver to send every nth frame to gui, or only upon gui request */
+	int set_read_frequency();
+
+	/** Sets the timer between frames streamed by receiver when frequency is set to 0 */
+	int set_read_receiver_timer();
+
+	/* Set the data stream enable */
+	int set_data_stream_enable();
+
+	/** Enable File Write*/
+	int enable_file_write();
+
+	/** get version, calls get_version */
+	int get_id();
+
+	/** set status to transmitting and
+	 * when fifo is empty later, sets status to run_finished */
+	int start_readout();
+
+	/** set acquisition period, frame number etc */
+	int set_timer();
+
+	/** enable compression */
+	int enable_compression();
+
+	/** set detector hostname  */
+	int set_detector_hostname();
+
+	/** set dynamic range  */
+	int set_dynamic_range();
+
+	/** enable overwrite  */
+	int enable_overwrite();
+
+	/** enable 10Gbe */
+	int enable_tengiga();
+
+	/** set fifo depth */
+	int set_fifo_depth();
+
+	/** activate/ deactivate */
+	int set_activate();
+
+	/** enable flipped data */
+	int set_flipped_data();
+
+
+	//General Functions
+	/** Locks Receiver */
+	int	lock_receiver();
+
+	/** Set port */
+	int set_port();
+
+	/** Get Last Client IP*/
+	int	get_last_client_ip();
+
+	/** Updates Client if different clients connect */
+	int	update_client();
+
+	/** Sends the updated parameters to client */
+	int send_update();
+
+	/** Exit Receiver Server */
+	int	exit_server();
+
+	/** Execute command */
+	int	exec_command();
+
+
+
+	//private:
+	/** detector type */
+	detectorType myDetectorType;
+
+	/** slsReceiverBase object */
+	UDPInterface *receiverBase;
+
+	/** Number of functions */
+	static const int numberOfFunctions = 256;
+
+	/** Function List */
+	int (slsReceiverTCPIPInterface::*flist[numberOfFunctions])();
+
+	/** Message */
+	char mess[MAX_STR_LENGTH];
+
+	/** success/failure */
+	int ret;
+
+	/** Lock Status if server locked to a client */
+	int lockStatus;
+
+	/** Short frame */
+	int shortFrame;
+
+	/** Packets per  frame */
+	int packetsPerFrame;
+
+	/** Dynamic Range */
+	int dynamicrange;
+
+	/** kill tcp server thread */
+	int killTCPServerThread;
+
+	/** thread for TCP server */
+	pthread_t   TCPServer_thread;
+
+	/** size of one frame*/
+	int tenGigaEnable;
+
+	/** port number */
+	int portNumber;
+
+	/** Receiver not setup error message */
+	char SET_RECEIVER_ERR_MESSAGE[MAX_STR_LENGTH];
+
+
+	//***callback parameters***
+	/**
+	 * function being called back for start acquisition
+	 * callback arguments are
+	 * filepath
+	 * filename
+	 * fileindex
+	 * datasize
+	 *
+	 * return value is
+	 * 0 callback takes care of open,close,wrie file
+	 * 1 callback writes file, we have to open, close it
+	 * 2 we open, close, write file, callback does not do anything
+	 */
+	int (*startAcquisitionCallBack)(char*, char*,int, int, void*);
+	void *pStartAcquisition;
+
+	/**
+	 * function being called back for acquisition finished
+	 * callback argument is
+	 * total frames caught
+	 */
+	void (*acquisitionFinishedCallBack)(int, void*);
+	void *pAcquisitionFinished;
+
+
+	/**
+	 * function being called back for raw data
+	 * args to raw data ready callback are
+	 * framenum
+	 * datapointer
+	 * datasize in bytes
+	 * file descriptor
+	 * guidatapointer (NULL, no data required)
+	 */
+	void (*rawDataReadyCallBack)(int, char*, int, FILE*, char*, void*);
+	void *pRawDataReady;
+
+
+protected:
+	/** Socket */
+	MySocketTCP* mySock;
+};
+
+
+#endif

slsReceiverSoftware/include/slsReceiverUsers.h

@@ -0,0 +1,91 @@
+#ifndef SLS_RECEIVER_USERS_H
+#define SLS_RECEIVER_USERS_H
+
+#include <stdio.h>
+#include <stdint.h>
+
+
+class slsReceiver;
+
+  /** 
+@short Class for implementing the SLS data receiver in the users application. Callbacks can be defined for processing and/or saving data
+  */
+/** 
+
+
+ @libdoc slsReceiverUsers is a class that can be instantiated in the users software to receive the data from the detectors. Callbacks can be defined for processing and/or saving data
+
+
+ ***********************************************/
+
+class slsReceiverUsers {
+
+public:
+	/**
+	 * Constructor
+	 * reads config file, creates socket, assigns function table
+	 * @param argc from command line
+	 * @param argv from command line
+	 * @param succecc socket creation was successfull
+	 */
+	slsReceiverUsers(int argc, char *argv[], int &success);
+
+
+	/** Destructor */
+	~slsReceiverUsers();
+
+	/** Close File and exits receiver server */
+	void closeFile(int p);
+
+	/**
+	 * starts listening on the TCP port for client comminication
+	 \return 0 for success or 1 for FAIL in creating TCP server
+	 */
+	int start();
+
+	/** stops listening to the TCP & UDP port and exit receiver program*/
+	void stop();
+
+	/**
+	 get get Receiver Version
+	 \returns id
+	 */
+	int64_t getReceiverVersion();
+
+	/**
+
+	@sort register calbback for starting the acquisition 
+	 \param func  callback to be called when starting the acquisition. Its arguments are filepath filename fileindex data size
+	   
+	  \returns	   0 callback takes care of open,close,write file; 	   1 callback writes file, we have to open, close it; 2 we open, close, write file, callback does not do anything
+
+	*/
+	
+	void registerCallBackStartAcquisition(int (*func)(char* filepath, char* filename,int fileindex, int datasize, void*),void *arg);
+
+
+	/**	
+	   @sort register callback for end of acquisition 
+	  \param func end of acquisition callback. Argument nf is total frames caught
+	  \returns nothing
+	*/
+	
+	
+	void registerCallBackAcquisitionFinished(void (*func)(int nf, void*),void *arg);
+	
+
+
+	/**
+	   @sort register callback to be called when data are available (to process and/or save the data).
+	   \param func raw data ready callback. arguments are framenum datapointer  datasize file descriptor guidatapointer (NULL, no data required)
+	  \returns nothing
+	*/
+	
+	void registerCallBackRawDataReady(void (*func)(int framenumber, char* datapointer, int datasize, FILE* filedescriptor, char* guidatapointer, void*),void *arg);
+
+	//receiver object
+	slsReceiver* receiver;
+};
+
+
+#endif

slsReceiverSoftware/include/sls_receiver_defs.h

@@ -0,0 +1,195 @@
+#ifndef SLS_RECEIVER_DEFS_H
+#define SLS_RECEIVER_DEFS_H
+
+
+#ifdef __CINT__
+#define MYROOT
+#define __cplusplus
+#endif
+
+#include <stdint.h> 
+#ifdef __cplusplus
+#include <string>
+#endif
+#include "ansi.h"
+
+
+typedef  double double32_t;
+typedef  float float32_t;
+typedef  int int32_t;
+
+/** 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	1000
+#define EIGER_MAX_FRAMES_PER_FILE	2000
+#define JFRAU_MAX_FRAMES_PER_FILE 	10000
+#define JFCTB_MAX_FRAMES_PER_FILE   100000
+
+
+/** 
+    \file sls_receiver_defs.h
+This file contains all the basic definitions common to the slsReceiver class
+and to the server programs running on the receiver
+ * @author Anna Bergamaschi
+ * @version 0.1alpha (any string)
+ * @see slsDetector
+$Revision: 809 $
+ */
+
+
+#ifdef __cplusplus
+
+/** @short class containing all the constants and enum definitions */
+class slsReceiverDefs {
+public:
+
+	slsReceiverDefs(){};
+
+#endif
+
+	/**
+       Type of the detector
+	 */
+	enum detectorType {
+		GET_DETECTOR_TYPE=-1,   /**< the detector will return its type */
+		GENERIC,  /**< generic sls detector */
+		MYTHEN, /**< mythen */
+		PILATUS, /**< pilatus */
+		EIGER, /**< eiger */
+		GOTTHARD, /**< gotthard */
+		PICASSO, /**< picasso */
+		AGIPD, /**< agipd */
+		MOENCH, /**< moench */
+		JUNGFRAU, /**< jungfrau */
+		JUNGFRAUCTB, /**< jungfrauCTBversion */
+		PROPIX /**< propix */
+	};
+
+
+	/**
+      return values
+	 */
+	enum  {
+		OK, /**< function succeeded */
+		FAIL, /**< function failed */
+		FINISHED, /**< acquisition finished */
+		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) */
+		PROBES_NUMBER, /**< number of probe types in pump-probe 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_JCTB,
+		SUBFRAME_ACQUISITION_TIME, /**< subframe exposure time */
+		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 */
+	};
+
+#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 Mythen, Pilatus, Eiger, Gotthard, Agipd, Unknown
+	      \returns MYTHEN, PILATUS, EIGER, GOTTHARD, AGIPD, MÖNCH, GENERIC
+	  */
+	  static std::string getDetectorType(detectorType t){	\
+	    switch (t) {										\
+	    case MYTHEN:    	return std::string("Mythen");	\
+	    case PILATUS:   	return std::string("Pilatus");	\
+	    case EIGER:    		return std::string("Eiger");	\
+	    case GOTTHARD:    	return std::string("Gotthard");	\
+	    case AGIPD:    		return std::string("Agipd");	\
+	    case MOENCH:    	return std::string("Moench");	\
+	    case JUNGFRAU:    	return std::string("Jungfrau");	\
+	    case JUNGFRAUCTB:   return std::string("JungfrauCTB");	\
+	    case PROPIX:    	return std::string("Propix");	\
+	    default:    		return std::string("Unknown");	\
+	    }};
+
+	  /** returns detector type index from detector type string
+	      \param type can be MYTHEN, PILATUS, EIGER, GOTTHARD, AGIPD, GENERIC
+	      \returns Mythen, Pilatus, Eiger, Gotthard, Agipd, Mönch, Unknown
+	  */
+	  static detectorType getDetectorType(std::string const type){\
+	    if (type=="Mythen")      	return MYTHEN;		\
+	    if (type=="Pilatus")      	return PILATUS;		\
+	    if (type=="Eiger")    		return EIGER;		\
+	    if (type=="Gotthard")    	return GOTTHARD;	\
+	    if (type=="Agipd")    		return AGIPD;		\
+	    if (type=="Moench")    		return MOENCH;		\
+	    if (type=="Jungfrau")    	return JUNGFRAU;	\
+	    if (type=="JungfrauCTB") 	return JUNGFRAUCTB;	\
+	    if (type=="Propix")    		return PROPIX;		\
+	    							return GENERIC;		\
+	  };
+
+
+	  /** returns string from run status index
+	      \param s can be ERROR, WAITING, RUNNING, TRANSMITTING, RUN_FINISHED
+	      \returns string error, waiting, running, data, finished
+	  */
+	  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");		\
+	    }};
+
+#endif
+
+#ifdef __cplusplus
+protected:
+#endif
+
+#ifndef MYROOT
+#include "sls_receiver_funcs.h"
+#endif
+
+#ifdef __cplusplus
+};
+#endif
+;
+#endif
+;

slsReceiverSoftware/include/sls_receiver_funcs.h

@@ -0,0 +1,65 @@
+/** 
+   @internal
+   function indexes to call on the server
+   All set functions with argument -1 work as get, when possible 
+ */
+#ifndef SLS_RECEIVER_FUNCS_H
+#define SLS_RECEIVER_FUNCS_H
+
+enum {
+	//General functions
+	F_EXEC_RECEIVER_COMMAND=128, 		/**< 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 */
+
+	// Identification
+	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 */
+
+	//network functions
+	F_RECEIVER_SHORT_FRAME, 		/**< Sets receiver to receive short frames */
+	F_SETUP_RECEIVER_UDP,			/**< sets the receiver udp connection and returns receiver mac address */
+
+	//Acquisition setup functions
+	F_SET_RECEIVER_TIMER,  			/**< set/get timer value */
+	F_SET_RECEIVER_DYNAMIC_RANGE,  	/**< set/get detector dynamic range */
+	F_READ_RECEIVER_FREQUENCY, 		/**< sets the frequency of receiver sending frames to gui */
+
+	// Acquisition functions
+	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_START_RECEIVER_READOUT, 		/**< acquisition has stopped. start remaining readout in receiver */
+	F_READ_RECEIVER_FRAME,  		/**< read one frame to gui*/
+
+	//file functions
+	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_SET_RECEIVER_FRAME_INDEX,		/**< sets the receiver frame 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_COMPRESSION,	/**< enable compression in receiver */
+	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_ACTIVATE,						/** < activate/deactivate readout */
+	F_STREAM_DATA_FROM_RECEIVER,		/**< stream data from receiver to client */
+
+	F_READ_RECEIVER_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) */
+
+	/* Always append functions hereafter!!! */
+};
+
+#endif
+/** @endinternal */

slsReceiverSoftware/include/utilities.h

@@ -0,0 +1,15 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <map>
+
+using namespace std;
+#include "sls_receiver_defs.h"
+
+/* uncomment next line to enable debug output */
+//#define EIGER_DEBUG
+
+
+int read_config_file(string fname, int *tcpip_port_no, map<string, string> * configuration_map);
+

slsReceiverSoftware/include/zmq.h

@@ -0,0 +1,416 @@
+/*
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+    *************************************************************************
+    NOTE to contributors. This file comprises the principal public contract
+    for ZeroMQ API users (along with zmq_utils.h). Any change to this file
+    supplied in a stable release SHOULD not break existing applications.
+    In practice this means that the value of constants must not change, and
+    that old values may not be reused for new constants.
+    *************************************************************************
+*/
+
+#ifndef __ZMQ_H_INCLUDED__
+#define __ZMQ_H_INCLUDED__
+
+/*  Version macros for compile-time API version detection                     */
+#define ZMQ_VERSION_MAJOR 4
+#define ZMQ_VERSION_MINOR 0
+#define ZMQ_VERSION_PATCH 4
+
+#define ZMQ_MAKE_VERSION(major, minor, patch) \
+    ((major) * 10000 + (minor) * 100 + (patch))
+#define ZMQ_VERSION \
+    ZMQ_MAKE_VERSION(ZMQ_VERSION_MAJOR, ZMQ_VERSION_MINOR, ZMQ_VERSION_PATCH)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined _WIN32_WCE
+#include <errno.h>
+#endif
+#include <stddef.h>
+#include <stdio.h>
+#if defined _WIN32
+#include <winsock2.h>
+#endif
+
+/*  Handle DSO symbol visibility                                             */
+#if defined _WIN32
+#   if defined ZMQ_STATIC
+#       define ZMQ_EXPORT
+#   elif defined DLL_EXPORT
+#       define ZMQ_EXPORT __declspec(dllexport)
+#   else
+#       define ZMQ_EXPORT __declspec(dllimport)
+#   endif
+#else
+#   if defined __SUNPRO_C  || defined __SUNPRO_CC
+#       define ZMQ_EXPORT __global
+#   elif (defined __GNUC__ && __GNUC__ >= 4) || defined __INTEL_COMPILER
+#       define ZMQ_EXPORT __attribute__ ((visibility("default")))
+#   else
+#       define ZMQ_EXPORT
+#   endif
+#endif
+
+/*  Define integer types needed for event interface                          */
+#if defined ZMQ_HAVE_SOLARIS || defined ZMQ_HAVE_OPENVMS
+#   include <inttypes.h>
+#elif defined _MSC_VER && _MSC_VER < 1600
+#   ifndef int32_t
+typedef __int32 int32_t;
+#   endif
+#   ifndef uint16_t
+typedef unsigned __int16 uint16_t;
+#   endif
+#   ifndef uint8_t
+typedef unsigned __int8 uint8_t;
+#   endif
+#else
+#   include <stdint.h>
+#endif
+
+
+/******************************************************************************/
+/*  0MQ errors.                                                               */
+/******************************************************************************/
+
+/*  A number random enough not to collide with different errno ranges on      */
+/*  different OSes. The assumption is that error_t is at least 32-bit type.   */
+#define ZMQ_HAUSNUMERO 156384712
+
+/*  On Windows platform some of the standard POSIX errnos are not defined.    */
+#ifndef ENOTSUP
+#define ENOTSUP (ZMQ_HAUSNUMERO + 1)
+#endif
+#ifndef EPROTONOSUPPORT
+#define EPROTONOSUPPORT (ZMQ_HAUSNUMERO + 2)
+#endif
+#ifndef ENOBUFS
+#define ENOBUFS (ZMQ_HAUSNUMERO + 3)
+#endif
+#ifndef ENETDOWN
+#define ENETDOWN (ZMQ_HAUSNUMERO + 4)
+#endif
+#ifndef EADDRINUSE
+#define EADDRINUSE (ZMQ_HAUSNUMERO + 5)
+#endif
+#ifndef EADDRNOTAVAIL
+#define EADDRNOTAVAIL (ZMQ_HAUSNUMERO + 6)
+#endif
+#ifndef ECONNREFUSED
+#define ECONNREFUSED (ZMQ_HAUSNUMERO + 7)
+#endif
+#ifndef EINPROGRESS
+#define EINPROGRESS (ZMQ_HAUSNUMERO + 8)
+#endif
+#ifndef ENOTSOCK
+#define ENOTSOCK (ZMQ_HAUSNUMERO + 9)
+#endif
+#ifndef EMSGSIZE
+#define EMSGSIZE (ZMQ_HAUSNUMERO + 10)
+#endif
+#ifndef EAFNOSUPPORT
+#define EAFNOSUPPORT (ZMQ_HAUSNUMERO + 11)
+#endif
+#ifndef ENETUNREACH
+#define ENETUNREACH (ZMQ_HAUSNUMERO + 12)
+#endif
+#ifndef ECONNABORTED
+#define ECONNABORTED (ZMQ_HAUSNUMERO + 13)
+#endif
+#ifndef ECONNRESET
+#define ECONNRESET (ZMQ_HAUSNUMERO + 14)
+#endif
+#ifndef ENOTCONN
+#define ENOTCONN (ZMQ_HAUSNUMERO + 15)
+#endif
+#ifndef ETIMEDOUT
+#define ETIMEDOUT (ZMQ_HAUSNUMERO + 16)
+#endif
+#ifndef EHOSTUNREACH
+#define EHOSTUNREACH (ZMQ_HAUSNUMERO + 17)
+#endif
+#ifndef ENETRESET
+#define ENETRESET (ZMQ_HAUSNUMERO + 18)
+#endif
+
+/*  Native 0MQ error codes.                                                   */
+#define EFSM (ZMQ_HAUSNUMERO + 51)
+#define ENOCOMPATPROTO (ZMQ_HAUSNUMERO + 52)
+#define ETERM (ZMQ_HAUSNUMERO + 53)
+#define EMTHREAD (ZMQ_HAUSNUMERO + 54)
+
+/*  Run-time API version detection                                            */
+ZMQ_EXPORT void zmq_version (int *major, int *minor, int *patch);
+
+/*  This function retrieves the errno as it is known to 0MQ library. The goal */
+/*  of this function is to make the code 100% portable, including where 0MQ   */
+/*  compiled with certain CRT library (on Windows) is linked to an            */
+/*  application that uses different CRT library.                              */
+ZMQ_EXPORT int zmq_errno (void);
+
+/*  Resolves system errors and 0MQ errors to human-readable string.           */
+ZMQ_EXPORT const char *zmq_strerror (int errnum);
+
+/******************************************************************************/
+/*  0MQ infrastructure (a.k.a. context) initialisation & termination.         */
+/******************************************************************************/
+
+/*  New API                                                                   */
+/*  Context options                                                           */
+#define ZMQ_IO_THREADS  1
+#define ZMQ_MAX_SOCKETS 2
+
+/*  Default for new contexts                                                  */
+#define ZMQ_IO_THREADS_DFLT  1
+#define ZMQ_MAX_SOCKETS_DFLT 1023
+
+ZMQ_EXPORT void *zmq_ctx_new (void);
+ZMQ_EXPORT int zmq_ctx_term (void *context);
+ZMQ_EXPORT int zmq_ctx_shutdown (void *ctx_);
+ZMQ_EXPORT int zmq_ctx_set (void *context, int option, int optval);
+ZMQ_EXPORT int zmq_ctx_get (void *context, int option);
+
+/*  Old (legacy) API                                                          */
+ZMQ_EXPORT void *zmq_init (int io_threads);
+ZMQ_EXPORT int zmq_term (void *context);
+ZMQ_EXPORT int zmq_ctx_destroy (void *context);
+
+
+/******************************************************************************/
+/*  0MQ message definition.                                                   */
+/******************************************************************************/
+
+typedef struct zmq_msg_t {unsigned char _ [32];} zmq_msg_t;
+
+typedef void (zmq_free_fn) (void *data, void *hint);
+
+ZMQ_EXPORT int zmq_msg_init (zmq_msg_t *msg);
+ZMQ_EXPORT int zmq_msg_init_size (zmq_msg_t *msg, size_t size);
+ZMQ_EXPORT int zmq_msg_init_data (zmq_msg_t *msg, void *data,
+    size_t size, zmq_free_fn *ffn, void *hint);
+ZMQ_EXPORT int zmq_msg_send (zmq_msg_t *msg, void *s, int flags);
+ZMQ_EXPORT int zmq_msg_recv (zmq_msg_t *msg, void *s, int flags);
+ZMQ_EXPORT int zmq_msg_close (zmq_msg_t *msg);
+ZMQ_EXPORT int zmq_msg_move (zmq_msg_t *dest, zmq_msg_t *src);
+ZMQ_EXPORT int zmq_msg_copy (zmq_msg_t *dest, zmq_msg_t *src);
+ZMQ_EXPORT void *zmq_msg_data (zmq_msg_t *msg);
+ZMQ_EXPORT size_t zmq_msg_size (zmq_msg_t *msg);
+ZMQ_EXPORT int zmq_msg_more (zmq_msg_t *msg);
+ZMQ_EXPORT int zmq_msg_get (zmq_msg_t *msg, int option);
+ZMQ_EXPORT int zmq_msg_set (zmq_msg_t *msg, int option, int optval);
+
+
+/******************************************************************************/
+/*  0MQ socket definition.                                                    */
+/******************************************************************************/
+
+/*  Socket types.                                                             */
+#define ZMQ_PAIR 0
+#define ZMQ_PUB 1
+#define ZMQ_SUB 2
+#define ZMQ_REQ 3
+#define ZMQ_REP 4
+#define ZMQ_DEALER 5
+#define ZMQ_ROUTER 6
+#define ZMQ_PULL 7
+#define ZMQ_PUSH 8
+#define ZMQ_XPUB 9
+#define ZMQ_XSUB 10
+#define ZMQ_STREAM 11
+
+/*  Deprecated aliases                                                        */
+#define ZMQ_XREQ ZMQ_DEALER
+#define ZMQ_XREP ZMQ_ROUTER
+
+/*  Socket options.                                                           */
+#define ZMQ_AFFINITY 4
+#define ZMQ_IDENTITY 5
+#define ZMQ_SUBSCRIBE 6
+#define ZMQ_UNSUBSCRIBE 7
+#define ZMQ_RATE 8
+#define ZMQ_RECOVERY_IVL 9
+#define ZMQ_SNDBUF 11
+#define ZMQ_RCVBUF 12
+#define ZMQ_RCVMORE 13
+#define ZMQ_FD 14
+#define ZMQ_EVENTS 15
+#define ZMQ_TYPE 16
+#define ZMQ_LINGER 17
+#define ZMQ_RECONNECT_IVL 18
+#define ZMQ_BACKLOG 19
+#define ZMQ_RECONNECT_IVL_MAX 21
+#define ZMQ_MAXMSGSIZE 22
+#define ZMQ_SNDHWM 23
+#define ZMQ_RCVHWM 24
+#define ZMQ_MULTICAST_HOPS 25
+#define ZMQ_RCVTIMEO 27
+#define ZMQ_SNDTIMEO 28
+#define ZMQ_LAST_ENDPOINT 32
+#define ZMQ_ROUTER_MANDATORY 33
+#define ZMQ_TCP_KEEPALIVE 34
+#define ZMQ_TCP_KEEPALIVE_CNT 35
+#define ZMQ_TCP_KEEPALIVE_IDLE 36
+#define ZMQ_TCP_KEEPALIVE_INTVL 37
+#define ZMQ_TCP_ACCEPT_FILTER 38
+#define ZMQ_IMMEDIATE 39
+#define ZMQ_XPUB_VERBOSE 40
+#define ZMQ_ROUTER_RAW 41
+#define ZMQ_IPV6 42
+#define ZMQ_MECHANISM 43
+#define ZMQ_PLAIN_SERVER 44
+#define ZMQ_PLAIN_USERNAME 45
+#define ZMQ_PLAIN_PASSWORD 46
+#define ZMQ_CURVE_SERVER 47
+#define ZMQ_CURVE_PUBLICKEY 48
+#define ZMQ_CURVE_SECRETKEY 49
+#define ZMQ_CURVE_SERVERKEY 50
+#define ZMQ_PROBE_ROUTER 51
+#define ZMQ_REQ_CORRELATE 52
+#define ZMQ_REQ_RELAXED 53
+#define ZMQ_CONFLATE 54
+#define ZMQ_ZAP_DOMAIN 55
+
+/*  Message options                                                           */
+#define ZMQ_MORE 1
+
+/*  Send/recv options.                                                        */
+#define ZMQ_DONTWAIT 1
+#define ZMQ_SNDMORE 2
+
+/*  Security mechanisms                                                       */
+#define ZMQ_NULL 0
+#define ZMQ_PLAIN 1
+#define ZMQ_CURVE 2
+
+/*  Deprecated options and aliases                                            */
+#define ZMQ_IPV4ONLY                31
+#define ZMQ_DELAY_ATTACH_ON_CONNECT ZMQ_IMMEDIATE
+#define ZMQ_NOBLOCK                 ZMQ_DONTWAIT
+#define ZMQ_FAIL_UNROUTABLE         ZMQ_ROUTER_MANDATORY
+#define ZMQ_ROUTER_BEHAVIOR         ZMQ_ROUTER_MANDATORY
+
+/******************************************************************************/
+/*  0MQ socket events and monitoring                                          */
+/******************************************************************************/
+
+/*  Socket transport events (tcp and ipc only)                                */
+#define ZMQ_EVENT_CONNECTED 1
+#define ZMQ_EVENT_CONNECT_DELAYED 2
+#define ZMQ_EVENT_CONNECT_RETRIED 4
+
+#define ZMQ_EVENT_LISTENING 8
+#define ZMQ_EVENT_BIND_FAILED 16
+
+#define ZMQ_EVENT_ACCEPTED 32
+#define ZMQ_EVENT_ACCEPT_FAILED 64
+
+#define ZMQ_EVENT_CLOSED 128
+#define ZMQ_EVENT_CLOSE_FAILED 256
+#define ZMQ_EVENT_DISCONNECTED 512
+#define ZMQ_EVENT_MONITOR_STOPPED 1024
+
+#define ZMQ_EVENT_ALL ( ZMQ_EVENT_CONNECTED | ZMQ_EVENT_CONNECT_DELAYED | \
+                        ZMQ_EVENT_CONNECT_RETRIED | ZMQ_EVENT_LISTENING | \
+                        ZMQ_EVENT_BIND_FAILED | ZMQ_EVENT_ACCEPTED | \
+                        ZMQ_EVENT_ACCEPT_FAILED | ZMQ_EVENT_CLOSED | \
+                        ZMQ_EVENT_CLOSE_FAILED | ZMQ_EVENT_DISCONNECTED | \
+                        ZMQ_EVENT_MONITOR_STOPPED)
+
+/*  Socket event data  */
+typedef struct {
+    uint16_t event;  // id of the event as bitfield
+    int32_t  value ; // value is either error code, fd or reconnect interval
+} zmq_event_t;
+
+ZMQ_EXPORT void *zmq_socket (void *, int type);
+ZMQ_EXPORT int zmq_close (void *s);
+ZMQ_EXPORT int zmq_setsockopt (void *s, int option, const void *optval,
+    size_t optvallen);
+ZMQ_EXPORT int zmq_getsockopt (void *s, int option, void *optval,
+    size_t *optvallen);
+ZMQ_EXPORT int zmq_bind (void *s, const char *addr);
+ZMQ_EXPORT int zmq_connect (void *s, const char *addr);
+ZMQ_EXPORT int zmq_unbind (void *s, const char *addr);
+ZMQ_EXPORT int zmq_disconnect (void *s, const char *addr);
+ZMQ_EXPORT int zmq_send (void *s, const void *buf, size_t len, int flags);
+ZMQ_EXPORT int zmq_send_const (void *s, const void *buf, size_t len, int flags);
+ZMQ_EXPORT int zmq_recv (void *s, void *buf, size_t len, int flags);
+ZMQ_EXPORT int zmq_socket_monitor (void *s, const char *addr, int events);
+
+ZMQ_EXPORT int zmq_sendmsg (void *s, zmq_msg_t *msg, int flags);
+ZMQ_EXPORT int zmq_recvmsg (void *s, zmq_msg_t *msg, int flags);
+
+/*  Experimental                                                              */
+struct iovec;
+
+ZMQ_EXPORT int zmq_sendiov (void *s, struct iovec *iov, size_t count, int flags);
+ZMQ_EXPORT int zmq_recviov (void *s, struct iovec *iov, size_t *count, int flags);
+
+/******************************************************************************/
+/*  I/O multiplexing.                                                         */
+/******************************************************************************/
+
+#define ZMQ_POLLIN 1
+#define ZMQ_POLLOUT 2
+#define ZMQ_POLLERR 4
+
+typedef struct
+{
+    void *socket;
+#if defined _WIN32
+    SOCKET fd;
+#else
+    int fd;
+#endif
+    short events;
+    short revents;
+} zmq_pollitem_t;
+
+#define ZMQ_POLLITEMS_DFLT 16
+
+ZMQ_EXPORT int zmq_poll (zmq_pollitem_t *items, int nitems, long timeout);
+
+/*  Built-in message proxy (3-way) */
+
+ZMQ_EXPORT int zmq_proxy (void *frontend, void *backend, void *capture);
+
+/*  Encode a binary key as printable text using ZMQ RFC 32  */
+ZMQ_EXPORT char *zmq_z85_encode (char *dest, uint8_t *data, size_t size);
+
+/*  Encode a binary key from printable text per ZMQ RFC 32  */
+ZMQ_EXPORT uint8_t *zmq_z85_decode (uint8_t *dest, char *string);
+
+/*  Deprecated aliases */
+#define ZMQ_STREAMER 1
+#define ZMQ_FORWARDER 2
+#define ZMQ_QUEUE 3
+/*  Deprecated method */
+ZMQ_EXPORT int zmq_device (int type, void *frontend, void *backend);
+
+#undef ZMQ_EXPORT
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

slsReceiverSoftware/slsReceiverUsers.doxy

@@ -0,0 +1,86 @@
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = YES
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+INTERNAL_DOCS = NO
+
+SHOW_INCLUDE_FILES = NO
+
+SHOW_FILES = NO
+
+SHOW_NAMESPACES = NO
+
+COMPACT_LATEX = YES
+
+PAPER_TYPE = a4
+
+PDF_HYPERLINKS = YES
+
+USE_PDFLATEX = YES
+
+LATEX_HIDE_INDICES = YES
+
+
+PREDEFINED           = __cplusplus
+
+INPUT            = slsReceiver/slsReceiverBase.h 
+
+OUTPUT_DIRECTORY = slsReceiverUsersDocs

slsReceiverSoftware/src/.cproject

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?fileVersion 4.0.0?>
+
+<cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
+	<storageModule moduleId="org.eclipse.cdt.core.settings">
+		<cconfiguration id="0.1592123610">
+			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="0.1592123610" moduleId="org.eclipse.cdt.core.settings" name="Default">
+				<externalSettings/>
+				<extensions>
+					<extension id="org.eclipse.cdt.core.VCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GASErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+					<extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/>
+				</extensions>
+			</storageModule>
+			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+				<configuration buildProperties="" description="" id="0.1592123610" name="Default" parent="org.eclipse.cdt.build.core.prefbase.cfg">
+					<folderInfo id="0.1592123610." name="/" resourcePath="">
+						<toolChain id="org.eclipse.cdt.build.core.prefbase.toolchain.2043853512" name="No ToolChain" resourceTypeBasedDiscovery="false" superClass="org.eclipse.cdt.build.core.prefbase.toolchain">
+							<targetPlatform id="org.eclipse.cdt.build.core.prefbase.toolchain.2043853512.1428560959" name=""/>
+							<builder id="org.eclipse.cdt.build.core.settings.default.builder.1228246701" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="org.eclipse.cdt.build.core.settings.default.builder"/>
+							<tool id="org.eclipse.cdt.build.core.settings.holder.libs.891716849" name="holder for library settings" superClass="org.eclipse.cdt.build.core.settings.holder.libs"/>
+							<tool id="org.eclipse.cdt.build.core.settings.holder.1775606856" name="Assembly" superClass="org.eclipse.cdt.build.core.settings.holder">
+								<inputType id="org.eclipse.cdt.build.core.settings.holder.inType.98773194" languageId="org.eclipse.cdt.core.assembly" languageName="Assembly" sourceContentType="org.eclipse.cdt.core.asmSource" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
+							</tool>
+							<tool id="org.eclipse.cdt.build.core.settings.holder.41809089" name="GNU C++" superClass="org.eclipse.cdt.build.core.settings.holder">
+								<inputType id="org.eclipse.cdt.build.core.settings.holder.inType.817253715" languageId="org.eclipse.cdt.core.g++" languageName="GNU C++" sourceContentType="org.eclipse.cdt.core.cxxSource,org.eclipse.cdt.core.cxxHeader" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
+							</tool>
+							<tool id="org.eclipse.cdt.build.core.settings.holder.1467561536" name="GNU C" superClass="org.eclipse.cdt.build.core.settings.holder">
+								<inputType id="org.eclipse.cdt.build.core.settings.holder.inType.210475521" languageId="org.eclipse.cdt.core.gcc" languageName="GNU C" sourceContentType="org.eclipse.cdt.core.cSource,org.eclipse.cdt.core.cHeader" superClass="org.eclipse.cdt.build.core.settings.holder.inType"/>
+							</tool>
+						</toolChain>
+					</folderInfo>
+				</configuration>
+			</storageModule>
+			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
+		</cconfiguration>
+	</storageModule>
+	<storageModule moduleId="cdtBuildSystem" version="4.0.0">
+		<project id="slsReceiver.null.670781774" name="slsReceiver"/>
+	</storageModule>
+	<storageModule moduleId="scannerConfiguration">
+		<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		<scannerConfigBuildInfo instanceId="0.1592123610">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+	</storageModule>
+	<storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
+</cproject>

slsReceiverSoftware/src/.project

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Receiver</name>
+	<comment></comment>
+	<projects>
+		<project>newMythenSoftware</project>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+			<triggers>clean,full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
+			<triggers>full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.cdt.core.cnature</nature>
+		<nature>org.eclipse.cdt.core.ccnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+	</natures>
+</projectDescription>

slsReceiverSoftware/src/MySocketTCP.cpp

@@ -0,0 +1,53 @@
+
+//version 1.0, base development, Ian 19/01/09
+
+
+#include "MySocketTCP.h"
+#include <string.h>
+#include <iostream>
+#include <cstdio>
+
+using namespace std;
+
+
+
+
+
+
+
+
+
+int MySocketTCP::SendData(void* buf,int length){//length in characters
+  int ndata = SendDataAndKeepConnection(buf,length);
+  Disconnect();
+  return ndata;
+}
+
+int MySocketTCP::SendDataAndKeepConnection(void* buf,int length){//length in characters
+  if(last_keep_connection_open_action_was_a_send) Disconnect(); //to keep a structured data flow;
+
+  Connect();
+  int total_sent=SendDataOnly(buf,length);
+  last_keep_connection_open_action_was_a_send=1;
+  return total_sent;
+}
+
+
+
+
+int MySocketTCP::ReceiveData(void* buf,int length){//length in characters
+  int ndata = ReceiveDataAndKeepConnection(buf,length);
+  Disconnect();
+  return ndata;
+}
+
+int MySocketTCP::ReceiveDataAndKeepConnection(void* buf,int length){//length in characters
+  if(!last_keep_connection_open_action_was_a_send) Disconnect(); //to a keep structured data flow;
+
+  Connect();
+  //  should preform two reads one to receive incomming char count
+  int total_received=ReceiveDataOnly(buf,length);
+  last_keep_connection_open_action_was_a_send=0;
+  return total_received;
+}
+

slsReceiverSoftware/src/UDPBaseImplementation.cpp

@@ -0,0 +1,526 @@
+//#ifdef SLS_RECEIVER_UDP_FUNCTIONS
+/********************************************//**
+ * @file UDPBaseImplementation.cpp
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ ***********************************************/
+
+#include "UDPBaseImplementation.h"
+#include "genericSocket.h"
+
+#include <sys/stat.h> 		// stat
+#include <iostream>
+#include <string.h>
+using namespace std;
+
+
+
+/*************************************************************************
+ * Constructor & Destructor **********************************************
+ * They access local cache of configuration or detector parameters *******
+ *************************************************************************/
+UDPBaseImplementation::UDPBaseImplementation(){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	initializeMembers();
+
+	//***callback parameters***
+	startAcquisitionCallBack = NULL;
+	pStartAcquisition = NULL;
+	acquisitionFinishedCallBack = NULL;
+	pAcquisitionFinished = NULL;
+	rawDataReadyCallBack = NULL;
+	pRawDataReady = NULL;
+}
+
+void UDPBaseImplementation::initializeMembers(){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	FILE_LOG(logDEBUG) << "Info: Initializing base members";
+	//**detector parameters***
+	myDetectorType = GENERIC;
+	strcpy(detHostname,"");
+	packetsPerFrame = 0;
+	acquisitionPeriod = 0;
+	acquisitionTime = 0;
+	numberOfFrames = 0;
+	dynamicRange = 16;
+	tengigaEnable = false;
+	fifoDepth = 0;
+	flippedData[0] = 0;
+	flippedData[1] = 0;
+
+	//***receiver parameters***
+	status = IDLE;
+	activated = true;
+
+	//***connection parameters***
+	strcpy(eth,"");
+	for(int i=0;i<MAX_NUMBER_OF_LISTENING_THREADS;i++){
+		udpPortNum[i] = DEFAULT_UDP_PORTNO + i;
+	}
+
+	//***file parameters***
+	strcpy(fileName,"run");
+	strcpy(filePath,"");
+	fileIndex = 0;
+	scanTag = 0;
+	frameIndexEnable = false;
+	fileWriteEnable = true;
+	overwriteEnable = true;
+	dataCompressionEnable = false;
+
+	//***acquisition count parameters***
+	totalPacketsCaught = 0;
+	packetsCaught = 0;
+
+	//***acquisition indices parameters***
+	acquisitionIndex = 0;
+
+	//***acquisition parameters***
+	shortFrameEnable = -1;
+	frameToGuiFrequency = 0;
+	frameToGuiTimerinMS = DEFAULT_STREAMING_TIMER;
+	dataStreamEnable = false;
+}
+
+UDPBaseImplementation::~UDPBaseImplementation(){}
+
+
+/*************************************************************************
+ * Getters ***************************************************************
+ * They access local cache of configuration or detector parameters *******
+ *************************************************************************/
+
+/**initial parameters***/
+char *UDPBaseImplementation::getDetectorHostname() const{
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	//not initialized
+	if(!strlen(detHostname))
+		return NULL;
+
+	char* output = new char[MAX_STR_LENGTH]();
+	strcpy(output,detHostname);
+	//freed by calling function
+	return output;
+}
+
+int UDPBaseImplementation::getFlippedData(int axis) const{
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+	if(axis<0 || axis > 1) return -1;
+	return flippedData[axis];
+}
+
+
+/***file parameters***/
+char *UDPBaseImplementation::getFileName() const{
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	//not initialized
+	if(!strlen(fileName))
+		return NULL;
+
+	char* output = new char[MAX_STR_LENGTH]();
+	strcpy(output,fileName);
+	//freed by calling function
+	return output;
+}
+
+char *UDPBaseImplementation::getFilePath() const{
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	//not initialized
+	if(!strlen(filePath))
+		return NULL;
+
+	char* output = new char[MAX_STR_LENGTH]();
+	strcpy(output,filePath);
+	//freed by calling function
+	return output;
+}
+
+uint64_t UDPBaseImplementation::getFileIndex() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return fileIndex;}
+
+int UDPBaseImplementation::getScanTag() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return scanTag;}
+
+bool UDPBaseImplementation::getFrameIndexEnable() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return frameIndexEnable;}
+
+bool UDPBaseImplementation::getFileWriteEnable() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return fileWriteEnable;}
+
+bool UDPBaseImplementation::getOverwriteEnable() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return overwriteEnable;}
+
+bool UDPBaseImplementation::getDataCompressionEnable() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return dataCompressionEnable;}
+
+/***acquisition count parameters***/
+uint64_t UDPBaseImplementation::getTotalFramesCaught() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return (totalPacketsCaught/packetsPerFrame);}
+
+uint64_t UDPBaseImplementation::getFramesCaught() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return (packetsCaught/packetsPerFrame);}
+
+int64_t UDPBaseImplementation::getAcquisitionIndex() const{
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	if(!totalPacketsCaught)
+		return -1;
+	return acquisitionIndex;
+}
+
+
+/***connection parameters***/
+uint32_t UDPBaseImplementation::getUDPPortNumber() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return udpPortNum[0];}
+
+uint32_t UDPBaseImplementation::getUDPPortNumber2() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return udpPortNum[1];}
+
+char *UDPBaseImplementation::getEthernetInterface() const{
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	char* output = new char[MAX_STR_LENGTH]();
+	strcpy(output,eth);
+	//freed by calling function
+	return output;
+}
+
+
+/***acquisition parameters***/
+int UDPBaseImplementation::getShortFrameEnable() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return shortFrameEnable;}
+
+uint32_t UDPBaseImplementation::getFrameToGuiFrequency() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return frameToGuiFrequency;}
+
+uint32_t UDPBaseImplementation::getFrameToGuiTimer() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return frameToGuiTimerinMS;}
+
+uint32_t UDPBaseImplementation::getDataStreamEnable() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return dataStreamEnable;}
+
+uint64_t UDPBaseImplementation::getAcquisitionPeriod() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return acquisitionPeriod;}
+
+uint64_t UDPBaseImplementation::getAcquisitionTime() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return acquisitionTime;}
+
+uint64_t UDPBaseImplementation::getNumberOfFrames() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return numberOfFrames;}
+
+uint32_t UDPBaseImplementation::getDynamicRange() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return dynamicRange;}
+
+bool UDPBaseImplementation::getTenGigaEnable() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return tengigaEnable;}
+
+uint32_t UDPBaseImplementation::getFifoDepth() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return fifoDepth;}
+
+/***receiver status***/
+slsReceiverDefs::runStatus UDPBaseImplementation::getStatus() const{	FILE_LOG(logDEBUG) << __AT__ << " starting";	return status;}
+
+int UDPBaseImplementation::getActivate() const{FILE_LOG(logDEBUG) << __AT__ << " starting"; return activated;}
+
+
+/*************************************************************************
+ * Setters ***************************************************************
+ * They modify the local cache of configuration or detector parameters ***
+ *************************************************************************/
+
+/**initial parameters***/
+void UDPBaseImplementation::configure(map<string, string> config_map){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+}
+
+void UDPBaseImplementation::setFlippedData(int axis, int enable){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+	if(axis<0 || axis>1) return;
+	flippedData[axis] = enable==0?0:1;
+	FILE_LOG(logINFO)  << "Flipped Data: " << flippedData[0] << " , " << flippedData[1];
+}
+
+
+/***file parameters***/
+void UDPBaseImplementation::setFileName(const char c[]){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	if(strlen(c))
+		strcpy(fileName, c);
+	FILE_LOG(logINFO) << "File name:" << fileName;
+}
+
+void UDPBaseImplementation::setFilePath(const char c[]){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	if(strlen(c)){
+		//check if filepath exists
+		struct stat st;
+		if(stat(c,&st) == 0)
+			strcpy(filePath,c);
+		else{
+			strcpy(filePath,"");
+			FILE_LOG(logWARNING) << "FilePath does not exist:" << filePath;
+		}
+		strcpy(filePath, c);
+	}
+	FILE_LOG(logDEBUG) << "Info: File path:" << filePath;
+}
+
+void UDPBaseImplementation::setFileIndex(const uint64_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	fileIndex = i;
+	FILE_LOG(logINFO) << "File Index:" << fileIndex;
+}
+
+//FIXME: needed?
+void UDPBaseImplementation::setScanTag(const int i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	scanTag = i;
+	FILE_LOG(logINFO) << "Scan Tag:" << scanTag;
+
+}
+
+void UDPBaseImplementation::setFrameIndexEnable(const bool b){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	frameIndexEnable = b;
+	FILE_LOG(logINFO) << "Frame Index Enable: " << stringEnable(frameIndexEnable);
+}
+
+void UDPBaseImplementation::setFileWriteEnable(const bool b){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	fileWriteEnable = b;
+	FILE_LOG(logINFO) << "File Write Enable: " << stringEnable(fileWriteEnable);
+}
+
+void UDPBaseImplementation::setOverwriteEnable(const bool b){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	overwriteEnable = b;
+	FILE_LOG(logINFO) << "Overwrite Enable: " << stringEnable(overwriteEnable);
+}
+
+int UDPBaseImplementation::setDataCompressionEnable(const bool b){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	dataCompressionEnable = b;
+	FILE_LOG(logINFO) << "Data Compression : " << stringEnable(dataCompressionEnable);
+
+	//overridden methods might return FAIL
+	return OK;
+}
+
+
+/***connection parameters***/
+void UDPBaseImplementation::setUDPPortNumber(const uint32_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	udpPortNum[0] = i;
+	FILE_LOG(logINFO) << "UDP Port Number[0]:" << udpPortNum[0];
+}
+
+void UDPBaseImplementation::setUDPPortNumber2(const uint32_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	udpPortNum[1] = i;
+	FILE_LOG(logINFO) << "UDP Port Number[1]:" << udpPortNum[1];
+}
+
+void UDPBaseImplementation::setEthernetInterface(const char* c){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	strcpy(eth, c);
+	FILE_LOG(logINFO) << "Ethernet Interface: " << eth;
+}
+
+
+/***acquisition parameters***/
+void UDPBaseImplementation::setShortFrameEnable(const int i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	shortFrameEnable = i;
+	FILE_LOG(logINFO) << "Short Frame Enable: " << stringEnable(shortFrameEnable);
+}
+
+int UDPBaseImplementation::setFrameToGuiFrequency(const uint32_t freq){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	frameToGuiFrequency = freq;
+	FILE_LOG(logINFO) << "Frame To Gui Frequency:" << frameToGuiFrequency;
+
+	//overrridden child classes might return FAIL
+	return OK;
+}
+
+void UDPBaseImplementation::setFrameToGuiTimer(const uint32_t time_in_ms){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	frameToGuiTimerinMS = time_in_ms;
+	FILE_LOG(logINFO) << "Frame To Gui Timer:" << frameToGuiTimerinMS;
+}
+
+
+uint32_t UDPBaseImplementation::setDataStreamEnable(const uint32_t enable){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	dataStreamEnable = enable;
+	FILE_LOG(logINFO) << "Streaming Data from Receiver:" << dataStreamEnable;
+
+	//overrridden child classes might return FAIL
+	return OK;
+}
+
+
+int UDPBaseImplementation::setAcquisitionPeriod(const uint64_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	acquisitionPeriod = i;
+	FILE_LOG(logINFO) << "Acquisition Period:" <<  (double)acquisitionPeriod/(1E9) << "s";
+
+	//overrridden child classes might return FAIL
+	return OK;
+}
+
+int UDPBaseImplementation::setAcquisitionTime(const uint64_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	acquisitionTime = i;
+	FILE_LOG(logINFO) << "Acquisition Time:" <<  (double)acquisitionTime/(1E9) << "s";
+
+	//overrridden child classes might return FAIL
+	return OK;
+}
+
+int UDPBaseImplementation::setNumberOfFrames(const uint64_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	numberOfFrames = i;
+	FILE_LOG(logINFO) << "Number of Frames:" << numberOfFrames;
+
+	//overrridden child classes might return FAIL
+	return OK;
+}
+
+int UDPBaseImplementation::setDynamicRange(const uint32_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	dynamicRange = i;
+	FILE_LOG(logINFO) << "Dynamic Range:" << dynamicRange;
+
+	//overrridden child classes might return FAIL
+	return OK;
+}
+
+int UDPBaseImplementation::setTenGigaEnable(const bool b){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	tengigaEnable = b;
+	FILE_LOG(logINFO) << "Ten Giga Enable: " << stringEnable(tengigaEnable);
+
+	//overridden functions might return FAIL
+	return OK;
+}
+
+int UDPBaseImplementation::setFifoDepth(const uint32_t i){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	fifoDepth = i;
+	FILE_LOG(logINFO) << "Fifo Depth: " << i;
+
+	//overridden functions might return FAIL
+	return OK;
+}
+
+/*************************************************************************
+ * Behavioral functions***************************************************
+ * They may modify the status of the receiver ****************************
+ *************************************************************************/
+
+
+/***initial functions***/
+int UDPBaseImplementation::setDetectorType(const detectorType d){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	myDetectorType = d;
+	//if eiger, set numberofListeningThreads = 2;
+	FILE_LOG(logINFO) << "Detector Type:" << getDetectorType(d);
+	return OK;
+}
+
+void UDPBaseImplementation::initialize(const char *c){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	if(strlen(c))
+		strcpy(detHostname, c);
+	FILE_LOG(logINFO) << "Detector Hostname:" << detHostname;
+}
+
+
+/***acquisition functions***/
+void UDPBaseImplementation::resetAcquisitionCount(){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	totalPacketsCaught = 0;
+	FILE_LOG(logINFO) << "totalPacketsCaught:" << totalPacketsCaught;
+}
+
+int UDPBaseImplementation::startReceiver(char *c){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+	return OK;
+}
+
+void UDPBaseImplementation::stopReceiver(){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+}
+
+void UDPBaseImplementation::startReadout(){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+}
+
+int UDPBaseImplementation::shutDownUDPSockets(){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+
+	//overridden functions might return FAIL
+	return OK;
+}
+
+void UDPBaseImplementation::readFrame(int ithread, char* c,char** raw, int64_t &startAcquisitionIndex, int64_t &startFrameIndex){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+}
+
+
+//FIXME: needed, isnt stopReceiver enough?
+void UDPBaseImplementation::abort(){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+}
+
+void UDPBaseImplementation::closeFile(int ithread){
+	FILE_LOG(logWARNING) << __AT__ << " doing nothing...";
+	FILE_LOG(logERROR) << __AT__ << " must be overridden by child classes";
+}
+
+
+int UDPBaseImplementation::setActivate(int enable){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	if(enable != -1){
+		activated = enable;
+		FILE_LOG(logINFO) << "Activation: " << stringEnable(activated);
+	}
+
+	return activated;
+}
+
+/***callback functions***/
+void UDPBaseImplementation::registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg){
+	startAcquisitionCallBack=func;
+	pStartAcquisition=arg;
+}
+
+void UDPBaseImplementation::registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg){
+	acquisitionFinishedCallBack=func;
+	pAcquisitionFinished=arg;
+}
+
+void UDPBaseImplementation::registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg){
+	rawDataReadyCallBack=func;
+	pRawDataReady=arg;
+}
+
+
+//#endif

slsReceiverSoftware/src/UDPInterface.cpp

@@ -0,0 +1,42 @@
+//#ifdef SLS_RECEIVER_UDP_FUNCTIONS
+/********************************************//**
+ * @file slsReceiverUDPFunctions.cpp
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ ***********************************************/
+
+
+#include <iostream>
+#include <string.h>
+using namespace std;
+
+
+#include "UDPInterface.h"
+#include "UDPBaseImplementation.h"
+#include "UDPStandardImplementation.h"
+#ifdef REST
+#include "UDPRESTImplementation.h"
+#endif
+
+
+using namespace std;
+
+UDPInterface * UDPInterface::create(string receiver_type){
+	
+	if (receiver_type == "standard"){
+		FILE_LOG(logINFO) << "Starting " << receiver_type;
+		return new UDPStandardImplementation();
+	}
+#ifdef REST
+	else if (receiver_type == "REST"){
+		FILE_LOG(logINFO) << "Starting " << receiver_type;
+		return new UDPRESTImplementation();
+	}
+#endif
+	else{
+		FILE_LOG(logWARNING) << "[ERROR] UDP interface not supported, using standard implementation";
+		return new UDPBaseImplementation();
+	}
+}
+
+
+//#endif

slsReceiverSoftware/src/UDPRESTImplementation.cpp

@@ -0,0 +1,361 @@
+#ifdef SLS_RECEIVER_UDP_FUNCTIONS
+/********************************************//**
+ * @file UDPRESTImplementation.cpp
+ * @short does all the functions for a receiver, set/get parameters, start/stop etc.
+ ***********************************************/
+
+#include "UDPRESTImplementation.h"
+
+#include <stdlib.h>		// exit()
+#include <iomanip>		// set precision
+#include <map>			// map
+#include <iostream>
+#include <string.h>
+#include <stdint.h>
+#include <sstream>
+//#include "utilities.h"
+using namespace std;
+
+/*
+ TODO
+ + filePath != getFilePath
+ + better state handling. Now it is only IDLE - RUNNING - IDLE
+ */
+
+
+UDPRESTImplementation::UDPRESTImplementation(){
+	FILE_LOG(logDEBUG) <<  "PID: " << getpid() << __AT__ << " called";
+
+	//TODO I do not really know what to do with bottom...
+	// Default values
+	isInitialized = true;
+	rest = NULL;
+	rest_hostname = "localhost";
+	rest_port = 8080;
+	is_main_receiver = false;
+}
+
+
+UDPRESTImplementation::~UDPRESTImplementation(){
+	delete rest;
+}
+
+
+void UDPRESTImplementation::configure(map<string, string> config_map){
+  // am I ever getting there?
+	FILE_LOG(logWARNING) << __AT__ << " called";
+
+	map<string, string>::const_iterator pos;
+
+	pos = config_map.find("rest_hostname");
+	if (pos != config_map.end() ){
+		string host_port_str = pos->second;
+		std::size_t pos = host_port_str.find(":");      // position of "live" in str
+		if(pos != string::npos){
+			istringstream (host_port_str.substr (pos)) >> rest_port;
+			rest_hostname = host_port_str.substr(0, pos);
+		}	
+	}
+
+	/*
+	for(map<string, string>::const_iterator i=config_map.begin(); i != config_map.end(); i++){
+		std::cout << i->first << " " << i->second<< std::endl;
+	}
+	 */
+
+}
+
+
+string UDPRESTImplementation::get_rest_state(RestHelper * rest/*, string *rest_state*/){
+
+	JsonBox::Value answer;
+	string rest_state = "";
+	
+	int code = rest->get_json("v1/state", &answer);
+	if ( code != -1 ){ 
+	  rest_state = answer["global_state"].getString();
+	}
+	//rest_state = *prs;
+
+	return rest_state;
+}
+
+
+void UDPRESTImplementation::initialize_REST(){
+
+	FILE_LOG(logDEBUG) << __AT__ << " called";
+	FILE_LOG(logDEBUG) << __AT__ << " REST status is initialized: " << isInitialized;
+
+	
+	string rest_state = "";
+	std::string answer = "";
+
+	// HORRIBLE FIX to get the main receiver
+	string filename = getFileName();
+	if (filename.substr(filename.length() - 2) == "d0"){
+	  is_main_receiver = true;
+	}
+	
+	if (rest_hostname.empty()) {
+	  FILE_LOG(logDEBUG) << __AT__ <<"can't initialize with empty string or NULL for detectorHostname";
+	  throw;
+	} 
+	rest = new RestHelper() ;
+	rest->init(rest_hostname, rest_port);
+	rest->set_connection_params(1, 3);
+	
+	int code;
+
+	if (!is_main_receiver){
+	  isInitialized = true;
+	  status = slsReceiverDefs::IDLE;
+	  return;
+	}
+
+	if (isInitialized == true) {
+	  FILE_LOG(logDEBUG) << __AT__ << "already initialized, can't initialize several times";
+	} 
+	else {
+	  FILE_LOG(logDEBUG) << __AT__ << "with receiverHostName=" << rest_hostname << ":" << rest_port;
+	  
+	  try{
+	    rest_state = get_rest_state(rest);
+	    
+	    if (rest_state == ""){
+	      FILE_LOG(logERROR) << __AT__ << " REST state returned: " << rest_state;
+	      throw;
+	    }
+	    else{
+	      isInitialized = true;
+	      status = slsReceiverDefs::IDLE;
+	    }
+	    FILE_LOG(logDEBUG) << __func__ << "Answer: " <<  answer;
+	  }
+	  catch(std::string e){
+	    FILE_LOG(logERROR) <<  __func__ << ": " << e;
+	    throw;
+	  }
+	  
+	  
+	  //JsonBox::Object json_object;
+	  //json_object["configfile"] = JsonBox::Value("FILENAME");
+	  JsonBox::Value json_request;
+	  //json_request["configfile"] = "config.py";
+	  json_request["path"] = filePath;
+	  
+	  stringstream ss;
+	  string test;
+	  //std::cout << "GetSTring: " << json_request << std::endl;
+	  json_request.writeToStream(ss, false);
+	  //ss << json_request;
+	  ss >> test;
+	  
+	  rest_state = get_rest_state(rest);
+	  
+	  //code = rest->get_json("v1/state", &answer);
+	  FILE_LOG(logDEBUG) << __AT__ << " state got " << code << " " << answer << "\n";
+	  if (rest_state != "INITIALIZED"){
+	    test =  "{\"path\":\"" + string( getFilePath() ) + "\", \"n_frames\":10}";
+	    code = rest->post_json("v1/state/initialize", &answer, test);
+	  }
+	  else{
+	    test =  "{\"path\":\"" + string( getFilePath() ) + "\"}";
+	    test =  "{\"path\":\"" + string( getFilePath() ) + "\", \"n_frames\":10}";
+	    code = rest->post_json("v1/state/configure", &answer, test);
+	  }
+	  FILE_LOG(logDEBUG) << __AT__ << " state/configure got " << code;
+	  
+	  rest_state = get_rest_state(rest);
+	  
+	  FILE_LOG(logDEBUG) << __AT__ << " state got " << rest_state << "\n";
+	  
+	  
+	  /*
+	    std::std::cout << string << std::endl; << "---- REST test 3: true, json object "<< std::endl;
+	    JsonBox::Value json_value;
+	      code = rest.get_json("status", &json_value);
+	      std::cout << "JSON " << json_value["status"] << std::endl;
+	  */
+	}
+	FILE_LOG(logDEBUG) << __func__ << ": initialize() done";
+}
+
+
+
+
+
+/** acquisition functions */
+
+
+int UDPRESTImplementation::startReceiver(char message[]){
+	int i;
+
+	FILE_LOG(logDEBUG) << __FILE__ << "::" << __func__ << " starting";
+	initialize_REST();
+	FILE_LOG(logDEBUG) << __FILE__ << "::" << __func__ << " initialized";
+
+	std::string answer;
+	int code;
+	//char *intStr = itoa(a);
+	//string str = string(intStr);
+	// TODO: remove hardcode!!!
+	stringstream ss;
+	ss << getDynamicRange();
+	string str_dr = ss.str();
+	stringstream ss2;
+	ss2 << getNumberOfFrames();
+	string str_n = ss2.str();
+
+
+	string rest_state = "";
+	std::string request_body =  "{\"settings\": {\"bit_depth\": " + str_dr + ", \"n_frames\": " + str_n + "}}";
+	//std::string request_body =  "{\"settings\": {\"nimages\":1, \"scanid\":999, \"bit_depth\":16}}";
+	if(is_main_receiver){
+	  FILE_LOG(logDEBUG) << __FILE__ << "::" << " sending this configuration body: " << request_body;
+	  code = rest->post_json("v1/state/configure", &answer, request_body);
+	  code = rest->get_json("v1/state", &answer);
+	  FILE_LOG(logDEBUG) << __FILE__ << "::" << " got: " << answer;
+	  
+	  rest_state = get_rest_state(rest);
+
+	  code = rest->post_json("v1/state/open", &answer);
+	}
+
+	status = RUNNING;
+	
+	return OK;
+}
+
+
+
+
+void UDPRESTImplementation::stopReceiver(){
+
+	FILE_LOG(logDEBUG) << __AT__ << "called";
+
+	if(status == RUNNING)
+		startReadout();
+
+	while(status == TRANSMITTING)
+		usleep(5000);
+
+	//change status
+	status = IDLE;
+
+	FILE_LOG(logDEBUG) << __AT__ << "exited, status " << endl;
+
+}
+
+
+
+
+
+void UDPRESTImplementation::startReadout(){
+	FILE_LOG(logDEBUG) << __AT__ << " starting";
+
+	status = TRANSMITTING;
+
+	//kill udp socket to tell the listening thread to push last packet
+	shutDownUDPSockets();
+	FILE_LOG(logDEBUG) << __FILE__ << "::" << __func__ << " done";
+
+}
+
+
+
+
+
+/* FIXME
+ * Its also called by TCP in case of illegal shut down such as Ctrl + c.
+ * Upto you what you want to do with it.
+ */
+int UDPRESTImplementation::shutDownUDPSockets(){
+
+	FILE_LOG(logDEBUG) << __AT__ << "called";
+
+	// this is just to be sure, it could be removed
+	/*
+	for(int i=0;i<numListeningThreads;i++){
+		if(udpSocket[i]){
+			FILE_LOG(logDEBUG) << __AT__ << " closing UDP socket #" << i;
+			udpSocket[i]->ShutDownSocket();
+			delete udpSocket[i];
+			udpSocket[i] = NULL;
+		}
+	}
+	*/
+	JsonBox::Value answer;
+	int code;
+	string rest_state = "";
+
+	//FILE_LOG(logDEBUG) << __AT__ << " numListeningThreads=" << numListeningThreads;
+	if (rest == NULL){
+		FILE_LOG(logWARNING) << __AT__ << "No REST object initialized, closing...";
+		return OK;
+	}
+
+	// getting the state
+	if (is_main_receiver){
+	  
+	  FILE_LOG(logWARNING) << "PLEASE WAIT WHILE CHECKING AND SHUTTING DOWN ALL CONNECTIONS!";
+	  rest_state = get_rest_state(rest);
+	  
+	  while (rest_state != "OPEN"){
+	    rest_state = get_rest_state(rest);
+	    usleep(10000);
+	  }
+	  //while (rest_state != "TRANSIENT"){
+	  //  rest_state = get_rest_state(rest);
+	  //  usleep(10000);
+	  //}
+	  
+	  code = rest->post_json("v1/state/close", &answer);
+	  code = rest->post_json("v1/state/reset", &answer);
+	  
+	  //rest_state = get_rest_state(rest);
+	  //std::cout << rest_state << std::endl;
+	}
+	status = slsReceiverDefs::RUN_FINISHED;
+	
+	//LEO: not sure it's needed
+	//delete rest;
+
+	FILE_LOG(logDEBUG) << __AT__ << "finished";
+	return OK;
+}
+
+
+
+/* FIXME
+ * do you really need this, this is called if registerDataCallback() is activated
+ * in your gui to get data from receiver. you probably have a different way
+ * of reconstructing complete data set from all receivers
+ */
+void UDPRESTImplementation::readFrame(char* c,char** raw, uint64_t &startAcq, uint64_t &startFrame){
+	FILE_LOG(logDEBUG) << __AT__ << " called";
+	strcpy(c,"");
+	*raw = NULL;
+}
+
+
+
+
+
+/* FIXME
+ * Its called by TCP in case of illegal shut down such as Ctrl + c.
+ * Upto you what you want to do with it.
+ */
+void UDPRESTImplementation::closeFile(int ithr){
+	FILE_LOG(logDEBUG) << __AT__ << "called for thread " << ithr;
+	FILE_LOG(logDEBUG) << __AT__ << "exited for thread " << ithr;
+}
+
+
+uint64_t UDPRESTImplementation::getTotalFramesCaught() const{   
+  FILE_LOG(logDEBUG) << __AT__ << " starting";    
+  return (0);
+}
+
+
+
+#endif

slsReceiverSoftware/src/dummyMain.cpp

@@ -0,0 +1,48 @@
+/* A simple server in the internet domain using TCP
+   The port number is passed as an argument */
+
+#include "sls_receiver_defs.h"
+#include "dummyUDPInterface.h"
+#include "slsReceiverTCPIPInterface.h"
+
+#include <iostream>
+#include <string.h>
+
+
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+  int success; 
+  int tcpip_port_no;
+  bool bottom = false; 
+  cout << "CCCCCC" << endl;
+  dummyUDPInterface *udp=new dummyUDPInterface();
+//   slsReceiverTCPIPInterface *tcpipInterface = new slsReceiverTCPIPInterface(success, udp, tcpip_port_no, bottom);
+
+  
+  
+  
+// 	if(tcpipInterface->start() == slsReceiverDefs::OK){
+// 		cout << "DONE!" << endl;
+// 		string str;
+// 		cin>>str;
+// 		//wait and look for an exit keyword
+// 		while(str.find("exit") == string::npos)
+// 			cin>>str;
+// 		//stop tcp server thread, stop udp socket
+// 		tcpipInterface->stop();
+// 	}
+
+//   if (tcpipInterface)
+//     delete tcpipInterface;
+
+  udp->startReceiver();
+   if(udp)
+     delete udp;
+  return 0;
+
+
+
+}
+

slsReceiverSoftware/src/main.cpp

@@ -0,0 +1,121 @@
+/* A simple server in the internet domain using TCP
+   The port number is passed as an argument */
+
+#include "sls_receiver_defs.h"
+#include "slsReceiverUsers.h"
+
+#include <iostream>
+#include <string.h>
+#include  <signal.h>	//SIGINT
+#include <cstdlib>		//system
+
+#include "utilities.h"
+#include "logger.h"
+using namespace std;
+
+slsReceiverUsers *receiver;
+
+void deleteReceiver(slsReceiverUsers* r){
+	if(r){delete r;r=0;}
+}
+
+void closeFile(int p){
+	deleteReceiver(receiver);
+}
+
+/*
+int startAcquisitionCallBack(char* filePath, char* fileName, int fileIndex, int bufferSize, void* context) {
+  cout << "#### startAcquisitionCallBack ####" << endl;
+  cout << "* filePath: " << filePath << endl;
+  cout << "* fileName: " << fileName << endl;
+  cout << "* fileIndex: " << fileIndex << endl;
+  cout << "* bufferSize: " << bufferSize << endl;
+  return 1;
+}
+
+void acquisitionFinishedCallBack(int totalFramesCaught, void* context) {
+  cout << "#### acquisitionFinishedCallBack ####" << endl;
+  cout << "* totalFramesCaught: " << totalFramesCaught << endl;
+}
+
+void rawDataReadyCallBack(int currFrameNum, char* dataPointer, int dataSize, FILE* file, char* guiDataPointer, void* context) {
+  cout << "#### rawDataReadyCallBack ####" << endl;
+  cout << "* currFrameNum: " << currFrameNum << endl;
+  cout << "* dataSize: " << dataSize << endl;
+}
+*/
+
+int main(int argc, char *argv[]) {
+
+	//Catch signal SIGINT to close files properly
+	signal(SIGINT,closeFile);
+
+	//system("setterm -linux term -background white -clear");
+
+	int ret = slsReceiverDefs::OK;
+	receiver = new slsReceiverUsers(argc, argv, ret);
+
+	if(ret==slsReceiverDefs::FAIL){
+		deleteReceiver(receiver);
+		return -1;
+	}
+
+
+	//register callbacks
+
+	/**
+	   callback arguments are
+	   filepath
+	   filename
+	   fileindex
+	   datasize
+
+	   return value is 
+	   0 raw data ready callback takes care of open,close,write file
+	   1 callback writes file, we have to open, close it
+	   2 we open, close, write file, callback does not do anything
+
+	   registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg);
+	 */
+	//receiver->registerCallBackStartAcquisition(startAcquisitionCallBack,NULL);
+
+
+	/**
+	  callback argument is
+	  total farmes caught
+	  registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg);
+	 */
+	//receiver->registerCallBackAcquisitionFinished(acquisitionFinishedCallBack,NULL);
+
+
+	/**
+	  args to raw data ready callback are
+	  framenum
+	  datapointer
+	  file descriptor
+	  guidatapointer (NULL, no data required)
+	  NEVER DELETE THE DATA POINTER
+	  REMEMBER THAT THE CALLBACK IS BLOCKING
+	  registerCallBackRawDataReady(void (*func)(int, char*, FILE*, char*, void*),void *arg);
+	 */
+	//receiver->registerCallBackRawDataReady(rawDataReadyCallBack,NULL);
+
+
+
+	//start tcp server thread
+	if(receiver->start() == slsReceiverDefs::OK){
+		FILE_LOG(logDEBUG1) << "DONE!" << endl;
+		string str;
+		cin>>str;
+		//wait and look for an exit keyword
+		while(str.find("exit") == string::npos)
+			cin>>str;
+		//stop tcp server thread, stop udp socket
+		receiver->stop();
+	}
+
+	deleteReceiver(receiver);
+	cout << "Goodbye!" << endl;
+	return 0;
+}
+

slsReceiverSoftware/src/slsReceiver.cpp

@@ -0,0 +1,190 @@
+/********************************************//**
+ * @file slsReceiver.cpp
+ * @short creates the UDP and TCP class objects
+ ***********************************************/
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <stdlib.h>
+#include <map>
+#include <getopt.h>
+
+#include "slsReceiver.h"
+//#include "UDPInterface.h"
+
+using namespace std;
+
+
+
+slsReceiver::slsReceiver(int argc, char *argv[], int &success){
+
+	/** 
+	 * Constructor method to start up a Receiver server. Reads configuration file, options, and 
+	 * assembles a Receiver using TCP and UDP detector interfaces
+	 * 
+	 * @param iarg 
+	 * 
+	 * @return 
+	 */
+	
+	udp_interface = NULL;
+	tcpipInterface = NULL;
+
+	//creating base receiver
+	map<string, string> configuration_map;
+	int tcpip_port_no = 1954;
+	success=OK;
+	string fname = "";
+	string udp_interface_type = "standard";
+	string rest_hostname = "localhost:8081";
+	udp_interface = NULL;
+
+	//parse command line for config
+	static struct option long_options[] = {
+		/* These options set a flag. */
+		//{"verbose", no_argument,       &verbose_flag, 1},
+		/* These options don’t set a flag.
+		   We distinguish them by their indices. */
+		{"type",     required_argument,       0, 't'},
+		{"config",     required_argument,       0, 'f'},
+		{"rx_tcpport",  required_argument,       0, 'b'},
+		{"rest_hostname",  required_argument,       0, 'r'},
+		{"help",  no_argument,       0, 'h'},
+		{0, 0, 0, 0}
+        };
+	/* getopt_long stores the option index here. */
+	int option_index = 0;
+	int c=0;
+	optind = 1;
+
+	while ( c != -1 ){
+		c = getopt_long (argc, argv, "bfhtr", long_options, &option_index);
+		
+		/* Detect the end of the options. */
+		if (c == -1)
+			break;
+	
+		switch(c){
+
+		case 'f':
+			fname = optarg;
+			//cout << long_options[option_index].name << " " << optarg << endl;
+			break;
+
+		case 'b':
+			sscanf(optarg, "%d", &tcpip_port_no);
+			break;
+			
+		case 't':
+			udp_interface_type = optarg;
+			break;
+
+		case 'r':
+			rest_hostname = optarg;
+			break;
+
+		case 'h':
+			string help_message = """\nSLS Receiver Server\n\n""";
+			help_message += """usage: slsReceiver --config config_fname [--rx_tcpport port]\n\n""";
+			help_message += """\t--config:\t configuration filename for SLS Detector receiver\n""";
+			help_message += """\t--rx_tcpport:\t TCP Communication Port with the client. Default: 1954.\n\n""";
+			help_message += """\t--rest_hostname:\t Receiver hostname:port. It applies only to REST receivers, and indicates the hostname of the REST backend. Default: localhost:8081.\n\n""";
+
+			help_message += """\t--type:\t Type of the receiver. Possible arguments are: standard, REST. Default: standard.\n\n""";
+
+			cout << help_message << endl;
+			break;
+		       
+		}
+	}
+
+	// if required fname parameter not available, fail
+	//if (fname == "")
+	//	success = FAIL;
+
+	if( !fname.empty() ){
+		try{
+			FILE_LOG(logINFO) << "config file name " << fname;
+			success = read_config_file(fname, &tcpip_port_no, &configuration_map);
+			//VERBOSE_PRINT("Read configuration file of " + iline + " lines");
+		}
+		catch(...){
+			FILE_LOG(logERROR) << "Error opening configuration file " << fname ;
+		success = FAIL;
+		}
+	}
+
+
+	if(success != OK){
+		FILE_LOG(logERROR) << "Failed: see output above for more information " ;
+	}
+
+	if (success==OK){
+		FILE_LOG(logINFO) << "SLS Receiver starting " << udp_interface_type << " on port " << tcpip_port_no << endl;
+#ifdef REST
+		udp_interface = UDPInterface::create(udp_interface_type);
+		udp_interface->configure(configuration_map);
+#endif
+		tcpipInterface = new slsReceiverTCPIPInterface(success, udp_interface, tcpip_port_no);
+	}
+}
+
+
+slsReceiver::~slsReceiver() {
+	if(udp_interface) 
+		delete udp_interface; 
+	if(tcpipInterface) 
+		delete tcpipInterface;
+}
+
+
+int slsReceiver::start() {
+	return tcpipInterface->start();
+}
+
+
+void slsReceiver::stop() {
+	tcpipInterface->stop();
+}
+
+
+void slsReceiver::closeFile(int p) {
+	tcpipInterface->closeFile(p);
+}
+
+
+int64_t slsReceiver::getReceiverVersion(){
+	return tcpipInterface->getReceiverVersion();
+}
+
+
+void slsReceiver::registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg){
+  //tcpipInterface
+	if(udp_interface)
+		udp_interface->registerCallBackStartAcquisition(func,arg);
+	else
+		tcpipInterface->registerCallBackStartAcquisition(func,arg);
+}
+
+
+
+void slsReceiver::registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg){
+  //tcpipInterface
+	if(udp_interface)
+		udp_interface->registerCallBackAcquisitionFinished(func,arg);
+	else
+		tcpipInterface->registerCallBackAcquisitionFinished(func,arg);
+}
+
+
+void slsReceiver::registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg){
+	//tcpipInterface
+	if(udp_interface)
+		udp_interface->registerCallBackRawDataReady(func,arg);
+	else
+		tcpipInterface->registerCallBackRawDataReady(func,arg);
+}
+
+

slsReceiverSoftware/src/slsReceiverUsers.cpp

@@ -0,0 +1,45 @@
+#include "slsReceiverUsers.h"
+#include "slsReceiver.h"
+
+slsReceiverUsers::slsReceiverUsers(int argc, char *argv[], int &success) {
+	receiver=new slsReceiver(argc, argv, success);
+}
+
+slsReceiverUsers::~slsReceiverUsers() {
+  delete receiver;
+}
+
+int slsReceiverUsers::start() {
+	return receiver->start();
+}
+
+void slsReceiverUsers::stop() {
+	receiver->stop();
+}
+
+
+void slsReceiverUsers::closeFile(int p) {
+	receiver->closeFile(p);
+}
+
+int64_t slsReceiverUsers::getReceiverVersion(){
+	return receiver->getReceiverVersion();
+}
+
+
+void slsReceiverUsers::registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg){
+	receiver->registerCallBackStartAcquisition(func,arg);
+}
+
+  
+
+void slsReceiverUsers::registerCallBackAcquisitionFinished(void (*func)(int, void*),void *arg){
+	receiver->registerCallBackAcquisitionFinished(func,arg);
+}
+	
+
+void slsReceiverUsers::registerCallBackRawDataReady(void (*func)(int, char*, int, FILE*, char*, void*),void *arg){
+	receiver->registerCallBackRawDataReady(func,arg);
+}
+
+

slsReceiverSoftware/src/utilities.cpp

@@ -0,0 +1,74 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <stdio.h>
+#include <fstream>
+
+#include <map>
+
+#include "utilities.h"
+
+
+using namespace std;
+
+
+int read_config_file(string fname, int *tcpip_port_no, map<string, string> * configuration_map ){
+	
+	ifstream infile;
+	string sLine,sargname, sargvalue;
+	int iline = 0;
+	int success = slsReceiverDefs::OK;
+
+
+
+	infile.open(fname.c_str(), ios_base::in);
+	if (infile.is_open()) {
+		while(infile.good()){
+			getline(infile,sLine);
+			iline++;
+			
+			//VERBOSE_PRINT(sLine);
+			
+			if(sLine.find('#') != string::npos)
+				continue;
+
+			else if(sLine.length()<2)
+				continue;
+
+			else{
+				istringstream sstr(sLine);
+				
+				//parameter name
+				if(sstr.good()){
+					sstr >> sargname;
+				
+					if (! sstr.good())
+						continue;
+
+					sstr >> sargvalue;
+					(*configuration_map)[sargname] = sargvalue;
+				}
+				//tcp port
+				if(sargname=="rx_tcpport"){
+					if(sstr.good()) {
+						sstr >> sargname;
+						if(sscanf(sargname.c_str(),"%d",tcpip_port_no))
+							cout<<"dataport:"<<tcpip_port_no<<endl;
+						else{
+							cout << "could not decode port in config file. Exiting." << endl;
+							success = slsReceiverDefs::FAIL;
+						}
+					}
+				}
+			}
+		}
+		infile.close();
+	}
+	
+	return success;
+}
+
+
+
+

slsReceiverSoftware/test/rec.cxx

@@ -0,0 +1,31 @@
+
+//version 1.0, base development ij 19/01/09
+
+#include <iostream>
+#include "MySocketTCP.h"
+
+using namespace std;
+
+int main(){
+
+  char data[50000];
+  int  length=50000;
+
+  unsigned short int portnum = 1952;
+  MySocketTCP* sock = new MySocketTCP(portnum);
+
+    cout<<"\tReceived :"<<sock->ReceiveDataAndKeepConnection(data,23000)<<endl;
+    cout<<"\tReceived :"<<sock->ReceiveData(data,32200)<<endl;
+    cout<<"\tReceived :"<<sock->ReceiveData(data,33300)<<endl;
+
+
+    
+    cout<<"\tReceived :"<<sock->ReceiveData(data,30000)<<endl;
+
+
+    cout<<"\tReceived :"<<sock->ReceiveData(data,3222)<<endl;
+
+  delete sock;
+
+  return 0;
+}

slsReceiverSoftware/test/send.cxx

@@ -0,0 +1,40 @@
+
+//version 1.0, base development ij 19/01/09
+ 
+#include <iostream>
+#include "MySocketTCP.h"
+
+using namespace std;
+
+int main(int argc, char *argv[]){
+
+  if(argc!=2){
+    cout<<"Usage: send ip_addess/hostName"<<endl;
+    return 1;
+  }
+  cout<<"rec function must be first called."<<endl;
+
+  char ip_address[200];
+    sprintf(ip_address,"%s",argv[1]);
+  unsigned short int portnum = 1952;
+
+
+  char data[50000];
+  int  length=50000;
+
+  MySocketTCP* sock = new MySocketTCP(ip_address,portnum);
+
+    cout<<"\tSending :"<<sock->SendDataAndKeepConnection(data,2000)<<endl;
+    cout<<"\tSending :"<<sock->SendData(data,2200)<<endl;
+    cout<<"\tSending :"<<sock->SendData(data,1200)<<endl;
+
+
+    cout<<"\tSending :"<<sock->SendData(data,25000)<<endl;
+
+    cout<<"\tSending :"<<sock->SendData(data,222)<<endl;
+
+  delete sock;
+
+
+  return 0;
+}