C++ MemoryBlock::append方法代码示例

void CtrlrMIDITransaction::constructConfirmation()
{
	MemoryBlock request;

	MemoryBlock prefix 	= getFormulaAsMemoryBlock(getProperty(Ids::transConfFormulaPrefix));
	MemoryBlock data   	= getConfirmationDataAsMemoryBlock();
	MemoryBlock suffix 	= getFormulaAsMemoryBlock(getProperty(Ids::transConfFormulaSuffix));

	if (prefix.getSize() > 0)
	{
		request.append (prefix.getData(), prefix.getSize());
	}

	if (data.getSize() > 0)
	{
		request.append (data.getData(), data.getSize());
	}

	if (suffix.getSize() > 0)
	{
		request.append (suffix.getData(), suffix.getSize());
	}

	setRequest (request);
}

void CtrlrMIDITransaction::constructResponseMask()
{
	MemoryBlock responseMask;

	MemoryBlock prefix 	= getFormulaAsMemoryBlock(getProperty(Ids::transRespFormulaPrefix));
	MemoryBlock data((int)getProperty(Ids::transRespDataLen), true);
	MemoryBlock suffix 	= getFormulaAsMemoryBlock(getProperty(Ids::transRespFormulaSuffix));
	MemoryBlock name	= getNameAsMemoryBlock();

	if (data.getSize() < name.getSize())
	{
		TRANS("["+getName()+"] CtrlrMIDITransaction::constructResponseMask data block will not fit name");
	}

	if (prefix.getSize() > 0)
	{
		responseMask.append (prefix.getData(), prefix.getSize());
	}

	if (data.getSize() > 0)
	{
		responseMask.append (data.getData(), data.getSize());
	}

	if (suffix.getSize() > 0)
	{
		responseMask.append (suffix.getData(), suffix.getSize());
	}

	setResponseMask (responseMask);
}

void CtrlrMIDITransaction::constructRequest()
{
	MemoryBlock request;

	MemoryBlock prefix 	= getFormulaAsMemoryBlock(getProperty(Ids::transReqFormulaPrefix));
	MemoryBlock data   	= getRequestDataAsMemoryBlock();
	MemoryBlock suffix 	= getFormulaAsMemoryBlock(getProperty(Ids::transReqFormulaSuffix));
	MemoryBlock name 	= getNameAsMemoryBlock();

	if (data.getSize() < name.getSize())
	{
		TRANS("["+getName()+"] CtrlrMIDITransaction::constructRequest data block will not fit name");
	}

	if (prefix.getSize() > 0)
	{
		request.append (prefix.getData(), prefix.getSize());
	}

	if (data.getSize() > 0)
	{
		request.append (data.getData(), data.getSize());
	}

	if (suffix.getSize() > 0)
	{
		request.append (suffix.getData(), suffix.getSize());
	}

	setRequest (request);
}

void HelmPlugin::getStateInformation(MemoryBlock& dest_data) {
  var state = LoadSave::stateToVar(&synth_, gui_state_, getCallbackLock());
  String data_string = JSON::toString(state);
  MemoryOutputStream stream;
  stream.writeString(data_string);
  dest_data.append(stream.getData(), stream.getDataSize());
}

//==============================================================================
void LumaPlug::getStateInformation (MemoryBlock& destData)
{
	/*
    // you can store your parameters as binary data if you want to or if you've got
    // a load of binary to put in there, but if you're not doing anything too heavy,
    // XML is a much cleaner way of doing it - here's an example of how to store your
    // params as XML..

    // create an outer XML element..
    XmlElement xmlState (T("MYPLUGINSETTINGS"));

    // add some attributes to it..
    xmlState.setAttribute (T("pluginVersion"), 1);
    //xmlState.setAttribute (T("gainLevel"), gain);
    xmlState.setAttribute (T("uiWidth"), lastUIWidth);
    xmlState.setAttribute (T("uiHeight"), lastUIHeight);

    // you could also add as many child elements as you need to here..


    // then use this helper function to stuff it into the binary blob and return it..
    copyXmlToBinary (xmlState, destData);
	*/
	
	const char* data = scriptText_.toUTF8();
	if (strlen(data) > 0)
	{
		destData.append(data, strlen(data));
	}
}

static int beginRequestHandler(struct mg_connection *conn) {
    enum BeginRequestHandlerReturnValues { HANDLED = 1, NOT_HANDLED = 0 };

    struct mg_request_info *info = mg_get_request_info(conn);
    String uri(info->uri);
    if (!uri.endsWithIgnoreCase(".json") && !uri.endsWithIgnoreCase(".wav")) {
        // DBG << "Not handling as audio request" << endl;
        return NOT_HANDLED;
    }

    // DBG << "Handling URI: " << uri << endl;

    var parsed;
    // First try to look in the query string
    String queryString = urldecode(info->query_string);
    // DBG << queryString << endl;
    parsed = JSON::parse(queryString);
    // Otherwise look in the POST data
    if (!parsed) {
        MemoryBlock postDataBlock;
        char postBuffer[1024];
        int didRead;
        while ((didRead = mg_read(conn, postBuffer, sizeof(postBuffer)))) {
            postDataBlock.append(postBuffer, didRead);
        }
        MemoryInputStream postStream(postDataBlock, false);
        parsed = JSON::parse(postStream);
    }

    DBG << "Request JSON: " << JSON::toString(parsed, true) << endl;

    PluginRequestParameters params(parsed);
    if (uri.endsWithIgnoreCase(".json")) {
        params.listParameters = true;
    }

    MemoryBlock block;
    MemoryOutputStream ostream(block, false);

    // DBG << "Rendering plugin request" << endl;
    int64 startTime = Time::currentTimeMillis();
    bool result = handlePluginRequest(params, ostream);
    if (!result) {
        DBG << "-> Unable to handle plugin request!" << endl;
        mg_printf(conn, "HTTP/1.0 500 ERROR\r\n\r\n");
        return HANDLED;
    }
    DBG << "-> Rendered plugin request in " << (Time::currentTimeMillis() - startTime) << "ms" << endl;

    // Note: MemoryOutputStream::getDataSize() is the actual number of bytes written.
    // Do not use MemoryBlock::getSize() since this reports the memory allocated (but not initialized!)
    mg_printf(conn, "HTTP/1.0 200 OK\r\n"
              "Content-Length: %d\r\n"
              "Content-Type: %s\r\n"
              "\r\n",
              (int)ostream.getDataSize(), params.getContentType());
    mg_write(conn, ostream.getData(), ostream.getDataSize());

    return HANDLED;
}

LMemoryBlock LMemoryBlock::getRange(const int startingPosition, const int numBytes) const
{
	MemoryBlock bl;

	if (getSize() >= (startingPosition + numBytes))
	{
		bl.append ((uint8 *)getData() + startingPosition, numBytes);
	}
	return (bl);
}

//==============================================================================
void CfpluginAudioProcessor::getStateInformation (MemoryBlock& destData)
{
	if (!follower_) { return; }

	auto options = OptionsReader();

	std::ostringstream ss;
    boost::archive::text_oarchive oa(ss);
	oa << *options;

	std::string str = ss.str();
	destData.append(str.data(), str.length());
}