comparison VamPipePluginLibrary.cpp @ 81:5e6ff69b4209

Make base64/text selectable when serialising process and feature blocks; add base64 version as an output format for vampipe-convert; make VamPipePluginLibrary switch to returning base64 encoding as soon as it is fed any as input

 	throw VampJson::Failure("object expected for content field");
     }
     return j;
 }
 
-VamPipePluginLibrary::VamPipePluginLibrary(vector<VamPipeAdapterBase *> pp)
+VamPipePluginLibrary::VamPipePluginLibrary(vector<VamPipeAdapterBase *> pp) :
+    m_useBase64(false)
 {
     for (VamPipeAdapterBase *p: pp) {
 	string key = p->getStaticData().pluginKey;
 	m_adapters[key] = p;
     }
 }
 
 RequestOrResponse
-VamPipePluginLibrary::readRequest(string req) const
+VamPipePluginLibrary::readRequest(string req)
 {
     RequestOrResponse rr;
     rr.direction = RequestOrResponse::Request;
 
     Json j = convertRequestJson(req);
 
     //!!! reduce, reduce
     rr.type = VampJson::getRequestResponseType(j);
+    VampJson::BufferSerialisation serialisation = VampJson::BufferSerialisation::Text;
 
     switch (rr.type) {
 
     case RRType::List:
 	VampJson::toVampRequest_List(j); // type check only

 	break;
     case RRType::Configure:
 	rr.configurationRequest = VampJson::toVampRequest_Configure(j, m_mapper);
 	break;
     case RRType::Process:
-	rr.processRequest = VampJson::toVampRequest_Process(j, m_mapper);
+	rr.processRequest = VampJson::toVampRequest_Process(j, m_mapper, serialisation);
 	break;
     case RRType::Finish:
 	rr.finishPlugin = VampJson::toVampRequest_Finish(j, m_mapper);
 	break;
     case RRType::NotValid:
 	break;
     }
 
+    if (serialisation == VampJson::BufferSerialisation::Base64) {
+        m_useBase64 = true;
+    }
+    
     return rr;
 }
 
 string
 VamPipePluginLibrary::writeResponse(const RequestOrResponse &rr) const
 {
     Json j;
 
+    VampJson::BufferSerialisation serialisation =
+        (m_useBase64 ?
+         VampJson::BufferSerialisation::Base64 :
+         VampJson::BufferSerialisation::Text);
+
     switch (rr.type) {
 
     case RRType::List:
 	j = VampJson::fromVampResponse_List("", rr.listResponse);
 	break;

 	break;
     case RRType::Configure:
 	j = VampJson::fromVampResponse_Configure(rr.configurationResponse);
 	break;
     case RRType::Process:
-	j = VampJson::fromVampResponse_Process(rr.processResponse);
+	j = VampJson::fromVampResponse_Process(rr.processResponse, serialisation);
 	break;
     case RRType::Finish:
-	j = VampJson::fromVampResponse_Finish(rr.finishResponse);
+	j = VampJson::fromVampResponse_Finish(rr.finishResponse, serialisation);
 	break;
     case RRType::NotValid:
 	break;
     }
 

     RequestOrResponse request;
 
     try {
 	request = readRequest(req);
     } catch (const std::exception &e) {
+        std::cerr << "FAILURE" << std::endl;
 	return VampJson::fromException(e, RRType::NotValid).dump();
     }
 
     RequestOrResponse response;
     response.direction = RequestOrResponse::Response;

 		}
 		fbuffers[i] = preq.inputBuffers[i].data();
 	    }
 
 	    response.processResponse.features =
-		preq.plugin->process(fbuffers, preq.timestamp);
+                preq.plugin->process(fbuffers, preq.timestamp);
 	    response.success = true;
 
 	    delete[] fbuffers;
 	    break;
 	}