C++ String::data方法代码示例

bool SkypekitTestEngine::CustomCommand(const Sid::String &cmd, Sid::String &result_str) {
	TI_FUNCLOG;
	result_str = "Hi! I got your ";
	result_str += cmd;
	TI_DBG("CustomCommand: got %s, answer: %s", cmd.data(), result_str.data());
	return true;
}

bool iMX27RtpInterface::CustomCommand(const Sid::String& cmd, Sid::String& result_str) {
	RTP_FUNCLOG;
	result_str = "Hi! I got your ";
	result_str += cmd;
	RTP_DBG("CustomCommand: got %s, answer: %s", cmd.data(), result_str.data());
	return true;
}

int main(int argc, const char **argv) {
	OptionsParser parser;
	if (parser.ParseOptions(argc, argv) < 0 || parser.m_Help) {
		parser.Usage(argv[0]);
		return -1;
	}

	Sid::SkypePCMInterfaceServer *pcmif_server = new Sid::SkypePCMInterfaceServer();
	Sid::SkypePCMCallbackInterfaceClient *pcmif_cb_client = new Sid::SkypePCMCallbackInterfaceClient();

	SkypePCMInterface* pcmif = SkypePCMInterfaceGet(pcmif_cb_client);
	pcmif_server->set_if(pcmif);


	Sid::String fromskypekitkey;
	Sid::String toskypekitkey;

	fromskypekitkey.Format( "%spcm_from_skypekit_key", parser.m_IpcPrefix);
	toskypekitkey.Format( "%spcm_to_skypekit_key", parser.m_IpcPrefix);

	pcmif_server->Connect(fromskypekitkey.data(), 0);
	pcmif_cb_client->Connect(toskypekitkey.data(), 500);

	if(parser.m_OutFile)
	{
	  Sid::String cmd;
	  Sid::String response;
	  cmd.Format("OUT:%s",parser.m_OutFile);
	  pcmif->CustomCommand(cmd, response);
	}
	if(parser.m_InFile)
	{
	  Sid::String cmd;
	  Sid::String response;
	  cmd.Format("IN:%s",parser.m_InFile);
	  pcmif->CustomCommand(cmd,response);
	}
	if(parser.m_Loop)
	{
	  Sid::String cmd = "LOOP:1";
	  Sid::String response;
	  pcmif->CustomCommand("LOOP:1", response);
	}
	
	Sid::Protocol::Status status;
	do {
		status =pcmif_server->ProcessCommands();
	} while (status == Sid::Protocol::OK);

	SkypePCMInterfaceRelease(pcmif);
	pcmif_server->Disconnect();
	pcmif_cb_client->Disconnect();

	delete pcmif_server;
	delete pcmif_cb_client;

	printf("PCMServerTransport disconnected, exiting from pcmtesthost\n");
}

void checkConversion(const Sid::String& test, const char* expected)
{
    const char* origData = test.data();
    CPPUNIT_ASSERT_PRINTF(!strcmp(test, expected),
    			"operator const char* did not yield \"%s\" as "
    			"expected, got \"%s\" instead.\n",
    			test.isNull() ? "(NULL)" : (const char*)test,
    			expected);
    CPPUNIT_ASSERT_MESSAGE("operator const char*() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkNotStartWith(const Sid::String& test, const Sid::String& prefix)
{
    const char* origData = test.data();
    CPPUNIT_ASSERT_PRINTF(!test.startWith(prefix),
    			"startsWith() did not return false for "
    			"\n%s\n%s\n",
    			prefix.isNull() ? "(NULL)" : prefix.data(),
    			test.isNull() ? "(NULL)" : test.data());
    CPPUNIT_ASSERT_MESSAGE("startWith() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkToBool(const Sid::String& test, bool expected)
{
    const char* origData = test.data();
    bool res = test.toBool();
    CPPUNIT_ASSERT_PRINTF(res == expected,
                            "toBool() yielded unexpected result for value "
                            "\"%s\", should have been %s\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            expected ? "true" : "false");
    CPPUNIT_ASSERT_MESSAGE("toBool() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkToUInt64(const Sid::String& test, uint64 expected)
{
    const char* origData = test.data();
    uint64 res = test.toUInt64();
    CPPUNIT_ASSERT_PRINTF(res == expected,
                            "toUInt64() yielded unexpected result for value "
                            "\"%s\", should have been %ull, instead got %ull\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            expected,
                            res);
    CPPUNIT_ASSERT_MESSAGE("toUInt64() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkHexRepresentation(const Sid::String& test, const Sid::String& expected)
{
    const char* origData = test.data();
    Sid::String res = test.getHexRepresentation();
    CPPUNIT_ASSERT_PRINTF(res == expected,
                            "getHexRepresentation() yielded unexpected result for value "
                            "\"%s\", should have been \"%s\", instead got \"%s\"\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            expected.isNull() ? "(NULL)" : expected.data(),
                            res.isNull() ? "(NULL)" : res.data());    
    CPPUNIT_ASSERT_MESSAGE("getHexRepresentation() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkUnescaping(const Sid::String& test, const Sid::String& expected)
{
    const char* origData = test.data();
    Sid::String unescaped=test.unescape();
    CPPUNIT_ASSERT_PRINTF(unescaped == expected,
    			"Unescaping \"%s\" did not yield \"%s\" as "
    			"expected, instead yielded \"%s\"\n",
    			!test.isNull() ? test.data() : "(NULL)",
    			!expected.isNull() ? expected.data() : "(NULL)",
    			!unescaped.isNull() ? unescaped.data() : "(NULL)");
    CPPUNIT_ASSERT_MESSAGE("unescape() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkToBinary(const Sid::String& test, const char* expected, size_t expectedSize)
{
    const char* origData = test.data();
    char* res = new char[test.size()+1];
    size_t size = test.toBinary(res);
    CPPUNIT_ASSERT_PRINTF(size == expectedSize,
                            "toBinary() yielded a result that was too long, "
                            "expected %u, got %u\n",
                            expectedSize,
                            size);
    CPPUNIT_ASSERT_PRINTF(!memcmp(expected, res, size),
                            "%s",
                            "toBinary() yielded unexpected result\n");
    CPPUNIT_ASSERT_MESSAGE("toBinary() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkFrom(bool b, const Sid::String& expected)
{
    Sid::String from = Sid::String::from(b);
    CPPUNIT_ASSERT_PRINTF(from == expected,
                            "from((bool)%s) yielded unexpected result \"%s\"\n",
                            b ? "true" : "false",
                            from.isNull() ? "(NULL)" : from.data());
}

void checkRight(const Sid::String& test, 
    	unsigned int len,
    	const Sid::String& expected)
{
    const char* origData = test.data();
    Sid::String right = test.right(len);
    CPPUNIT_ASSERT_PRINTF(right == expected,
    			"right(%d) did not yield expected result for:\n"
    			"%s\n%*s (got)\n%*s (expected)\n",
    			len,
    			test.isNull() ? "(NULL)" : test.data(),
    			test.size(),
    			right.isNull() ? "(NULL)" : right.data(),
    			test.size(),
    			expected.isNull() ? "(NULL)" : expected.data());
    CPPUNIT_ASSERT_MESSAGE("right() causes object to relinquish its reference!",
                            origData == test.data());
}

void checkAssignment(const Sid::String& test,
                        const Sid::String& rhs,
                        const Sid::String& expected)
{
    Sid::String copy(test);
    const char* rhsData = rhs.data();
    copy = rhs;
    CPPUNIT_ASSERT_PRINTF(copy == expected,
                            "Assignment operator yielded unexpected result:\n"
                            "\"%s\" (lhs)\n"
                            "\"%s\" (rhs)\n"
                            "\"%s\" (expected)\n"
                            "\"%s\" (got)\n",
                            test.isNull() ? "(NULL)" : test.data(),
                            rhs.isNull() ? "(NULL)" : rhs.data(),
                            expected.isNull() ? "(NULL)" : rhs.data(),
                            copy.isNull() ? "(NULL)" : copy.data());
    CPPUNIT_ASSERT_MESSAGE("Assignment operator caused rhs to relinquish its reference!",
                            rhs.data() == rhsData);
}

void checkAppend(const Sid::String& lhs, 
                    const char* rhs, 
                    const Sid::String& expected)
{
    Sid::String test(lhs);
    CPPUNIT_ASSERT(test == lhs);
    test += rhs;
    CPPUNIT_ASSERT_PRINTF(test == expected,
                            "operator+=(const char*) yielded unexpected"
                            " result:\n"
                            "lhs was  \"%s\"\n"
                            "rhs was  \"%s\"\n"
                            "expected \"%s\"\n"
                            "got      \"%s\"\n",
                            lhs.isNull() ? "(NULL)" : lhs.data(),
                            rhs ?  rhs : "(NULL)",
                            expected.isNull() ? "(NULL)" : expected.data(),
                            test.isNull() ? "(NULL)" : test.data());

    checkAppend(lhs, Sid::String(rhs), expected);
}

void checkFind(const Sid::String& test, 
    			char toFind,
    			int expected)
{
    int res = test.find(toFind);
    CPPUNIT_ASSERT_PRINTF(res == expected,
    						"find(%u) yielded unexpected result %d for string:\n"
    						"%s\n"
    						"expected %d\n",
    						toFind,
    						res,
    						test.isNull() ? "(NULL)" : test.data(),
    						expected);
}