void CMenuLogin::readCommands()
{
IGUIElement *temp = _gerHud->getFocus();
//_gerHud->setFocus(NULL);
if(_gerEventos->isKeyDown(KEY_ESCAPE))
{
_nextID = MN_SAIDA;
return;
}
if(_gerEventos->isKeyPressed(KEY_RETURN))
{
_gerHud->setFocus(NULL);
}
if(_gerEventos->isKeyReleased(KEY_RETURN))
{
//_nextID = MN_SAIDA;
//return;
cout << "\nENTER!\n";
}
if(_gerEventos->getEventCallerByElement(EGET_BUTTON_CLICKED))
{
// Trata os cliques em botões
if (_gerEventos->getEventCallerByID() == 101)
{
// Clicou no botão conectar
stringc str1(Login->getText());
strcpy(_login, str1.c_str());
stringc str2(Password->getText());
strcpy(_senha, str2.c_str());
_gameCore->conectar( _login, _senha); // TESTE
if(_gameCore->isConnected())
{
_nextID = MN_SELECAOPERSONAGEM;
return;
}
}
}
_gerHud->setFocus(temp);
}
int main() {
String str1("GeeksQuiz");
String str2 = str1; // CE: deep copies pointer to str1 over to str2 variable using copy constructor defined above
str1.print(); // what gets printed?
str2.print();
str2.change("GeeksforGeeks");
str1.print(); // what gets printed now?
str2.print();
return 0;
}
void Movie::Progress::frames_traversed_gdklocked(int n) {
frames_done += n;
std::ostringstream msg1;
msg1 << "0 passes plotted; maxiter = 0; " << npixels << " pixels live";
std::string str1(msg1.str());
std::ostringstream msg2;
msg2 << frames_done << "/" << nframes << " frames";
moviebar->set_text(msg2.str());
moviebar->set_fraction((double)frames_done / nframes);
pass_complete_gdklocked(str1, 0, 0, npixels, npixels);
}
int SHVStringUTF8C::StrCaseCmp(const SHVChar* s1,const SHVChar* s2)
{
#if defined(__SHIVA_EPOC)
SHVStringUTF8 str1(s1);
SHVStringUTF8 str2(s2);
str1.MakeLower();
str2.MakeLower();
return str1.Compare(str2);
#elif defined(__SHIVA_WIN32)
return _stricmp(s1,s2);
#else
return strcasecmp(s1,s2);
#endif
}
int CTest::test_caseInsensitiveButCasePreserving(int argc, char* argv[])
{
AutoPtr<IRawHeaders> h;
CRawHeaders::New((IRawHeaders**)&h);
String str0("Content-Type");
String str1("text/plain");
h->Add(str0, str1);
// Case-insensitive:
String strOut;
h->Get(str0, &strOut);
Boolean flag = strOut.Equals(str1);
assert(flag == TRUE);
String str2("Content-type");
h->Get(str2, &strOut);
flag = strOut.Equals(str1);
assert(flag == TRUE);
String str3("content-type");
h->Get(str3, &strOut);
flag = strOut.Equals(str1);
assert(flag == TRUE);
String str4("CONTENT-TYPE");
h->Get(str4, &strOut);
flag = strOut.Equals(str1);
assert(flag == TRUE);
// ...but case-preserving:
AutoPtr<IMap> innerMap;
h->ToMultimap((IMap**)&innerMap);
AutoPtr<ISet> keyset;
innerMap->KeySet((ISet**)&keyset);
AutoPtr<ArrayOf<IInterface*> > array;
keyset->ToArray((ArrayOf<IInterface*>**)&array);
AutoPtr<ICharSequence> cs = (ICharSequence*)ICharSequence::Probe((*array)[0]);
String str5(String("Content-Type"));
cs->ToString(&strOut);
flag = strOut.Equals(str5);
assert(flag == TRUE);
// We differ from the RI in that the Map we return is also case-insensitive.
// Our behavior seems more consistent. (And code that works on the RI will work on Android.)
// AutoPtr<ICharSequence> cs1;
// CString::New(String("Content-Type"), (ICharSequence**)&cs1);
// AutoPtr<IInterface> value;
// innerMap->Get(cs1, (IInterface**)&value);
// assertEquals(Arrays.asList("text/plain"), h.toMultimap().get("Content-Type"));
// assertEquals(Arrays.asList("text/plain"), h.toMultimap().get("Content-type")); // RI fails this.
}
void TestChainElement::TestMoveAndBridge()
{
ComparisonContext cContext;
CRTF_String str1(&cContext, Detached);
CRTF_String str2(&cContext, Detached);
str1.MoveAndBridge(&str2);
assertTest(str1.GetRealBridge()==&str2);
assertTest(str2.GetRealBridge()==&str1);
assertTest(str1.m_bMove);
assertTest(str2.m_bMove);
}
//赋值给自己
void Test2(){
printf("Test2 begins:\n");
char* text = "Hello world.";
CMyString str1(text);
str1 = str1;
printf("The expected result is: %s.\n", text);
printf("The actual result is: ");
str1.Print();
printf(".\n");
}
serverForm::serverForm() {
widget.setupUi(this);
widget.infoLabel->setText("");
widget.portEdit->setText("17005");
widget.maxAgentEdit->setText("5");
widget.agentCountLabel->setText("0");
widget.idSpusteniaLabel->setText("");
widget.radiusEdit->setText("5000");
widget.radiusEdit->setEnabled(false);
widget.startMappingButton->setEnabled(false);
widget.stopMappingButton->setEnabled(false);
shm_S_GUI = new komunikacia_shm;
shm_S_GUI->ukonci_ulohu = 0;
shm_S_GUI->mappingNow = 0;
shm_S_GUI->widget = &widget;
server = new Server(shm_S_GUI);
shm_S_GUI->serverForm = (void *) this;
struct ifaddrs * ifAddrStruct=NULL;
struct ifaddrs * ifa=NULL;
void * tmpAddrPtr=NULL;
getifaddrs(&ifAddrStruct);
std::string str1 ("wlan1");
for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next) {
if (!ifa->ifa_addr) {
continue;
}
if (ifa->ifa_addr->sa_family == AF_INET) { // check it is IP4
// is a valid IP4 Address
tmpAddrPtr=&((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
char addressBuffer[INET_ADDRSTRLEN];
inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
printf("%s IP Address %s\n", ifa->ifa_name, addressBuffer);
if (str1.compare(ifa->ifa_name)==0) {
widget.ipLabel->setText(addressBuffer);
}
} else if (ifa->ifa_addr->sa_family == AF_INET6) { // check it is IP6
// is a valid IP6 Address
tmpAddrPtr=&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
char addressBuffer[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN);
printf("%s IP Address %s\n", ifa->ifa_name, addressBuffer);
}
}
if (ifAddrStruct!=NULL) freeifaddrs(ifAddrStruct);
}
void enqueue(queue_t *q, unsigned int val)
{
std::string str1("enqueue"); //ANNOTATION
function_call(str1, INVOCATION, val); //ANNOTATION
int success = 0;
unsigned int node;
pointer tail;
pointer next;
pointer tmp;
node = new_node();
store_32(&q->nodes[node].value, val);
tmp = atomic_load_explicit(&q->nodes[node].next, memory_order_seq_cst);
set_ptr(&tmp, 0); // NULL
atomic_store_explicit(&q->nodes[node].next, tmp, memory_order_seq_cst);
while (!success) {
tail = atomic_load_explicit(&q->tail, memory_order_seq_cst);
next = atomic_load_explicit(&q->nodes[get_ptr(tail)].next, memory_order_seq_cst);
if (tail == atomic_load_explicit(&q->tail, memory_order_seq_cst)) {
/* Check for uninitialized 'next' */
MODEL_ASSERT(get_ptr(next) != POISON_IDX);
if (get_ptr(next) == 0) { // == NULL
pointer value = MAKE_POINTER(node, get_count(next) + 1);
success = atomic_compare_exchange_strong_explicit(&q->nodes[get_ptr(tail)].next,
&next, value, memory_order_seq_cst, memory_order_seq_cst);
}
if (!success) {
unsigned int ptr = get_ptr(atomic_load_explicit(&q->nodes[get_ptr(tail)].next, memory_order_seq_cst));
pointer value = MAKE_POINTER(ptr,
get_count(tail) + 1);
atomic_compare_exchange_strong_explicit(&q->tail,
&tail, value,
memory_order_seq_cst, memory_order_seq_cst);
thrd_yield();
}
}
}
atomic_compare_exchange_strong_explicit(&q->tail,
&tail,
MAKE_POINTER(node, get_count(tail) + 1),
memory_order_seq_cst, memory_order_seq_cst);
function_call(str1, RESPONSE); //ANNOTATION
}
int _tmain(int argc, _TCHAR* argv[])
{
std::vector<String> vecstr;
String str1("tangbin");
String str2("tangbin");
if (str1 == str2)
std::cout << "same" << std::endl;
vecstr.push_back(str2);
vecstr.push_back(str1);
String s5 = baz(); // second avoided
//vecstr.push_back(str2);
//vecstr.push_back(str3);
system("pause");
return 0;
}
I32 IFXString::CompareNoCase(const IFXCHAR* pSource) const
{
if(m_Buffer==NULL && pSource==NULL)
return 0;
else if(m_Buffer==NULL)
return -1;
else if(pSource==NULL)
return 1;
IFXString str1(this), str2(pSource);
str1.ForceLowercase();
str2.ForceLowercase();
return wcscmp(str1.Raw(), str2.Raw());
}
void push(Deque *q, int x) {
std::string str1("push_back"); //ANNOTATION
function_call(str1, INVOCATION, (uint64_t) x); //ANNOTATION
size_t b = atomic_load_explicit(&q->bottom, memory_order_seq_cst);
size_t t = atomic_load_explicit(&q->top, memory_order_seq_cst);
Array *a = (Array *) atomic_load_explicit(&q->array, memory_order_seq_cst);
if (b - t > atomic_load_explicit(&a->size, memory_order_seq_cst) - 1) /* Full queue. */ {
resize(q);
//Bug in paper...should have next line...
a = (Array *) atomic_load_explicit(&q->array, memory_order_seq_cst);
}
atomic_store_explicit(&a->buffer[b % atomic_load_explicit(&a->size, memory_order_seq_cst)], x,memory_order_seq_cst);
atomic_thread_fence(memory_order_seq_cst);
atomic_store_explicit(&q->bottom, b + 1, memory_order_seq_cst); //relaxed
function_call(str1, RESPONSE); //ANNOTATION
}
bool dequeue(queue_t *q, unsigned int *retVal)
{
std::string str1("dequeue"); //ANNOTATION
function_call(str1, INVOCATION); //ANNOTATION
int success = 0;
pointer head;
pointer tail;
pointer next;
while (!success) {
head = atomic_load_explicit(&q->head, memory_order_seq_cst);
tail = atomic_load_explicit(&q->tail, memory_order_seq_cst);
next = atomic_load_explicit(&q->nodes[get_ptr(head)].next, memory_order_seq_cst);
if (atomic_load_explicit(&q->head, memory_order_seq_cst) == head) {
if (get_ptr(head) == get_ptr(tail)) {
/* Check for uninitialized 'next' */
MODEL_ASSERT(get_ptr(next) != POISON_IDX);
if (get_ptr(next) == 0) { // NULL
function_call(str1, RESPONSE); //ANNOTATION
return false; // NULL
}
atomic_compare_exchange_strong_explicit(&q->tail,
&tail,
MAKE_POINTER(get_ptr(next), get_count(tail) + 1),
memory_order_seq_cst, memory_order_seq_cst);
thrd_yield();
} else {
*retVal = load_32(&q->nodes[get_ptr(next)].value);
success = atomic_compare_exchange_strong_explicit(&q->head,
&head,
MAKE_POINTER(get_ptr(next), get_count(head) + 1),
memory_order_seq_cst, memory_order_seq_cst);
if (!success)
thrd_yield();
}
}
}
reclaim(get_ptr(head));
function_call(str1, RESPONSE, *retVal); //ANNOTATION
return true;
}
int main(int argc, char **argv) {
if (argc != 4) {
std::cout << "Usage: " << argv[0] << " <databasefilename> <queryfilename> <tree-type>" << std::endl;
return 0;
}
std::string db_filename(argv[1]);
std::string str1(argv[2]);
std::string str2(argv[3]);
std::cout << "Input file is " << db_filename << " ";
std::cout << "String 1 is " << str1 << " and string 2 is " << str2 << std::endl;
CheckFile(db_filename);
AvlTree<SequenceMap> a_tree;
FillTree(db_filename, a_tree);
a_tree.print_Between(str1, str2);
return 0;
}
//(unicode转String)
QString Gprs::unicodeTo(QString str)
{
int temp[400];
QChar qchar[100];
QString strOut;
bool ok;
int count=str.count();
int len=count/4;
for(int i=0;i<count;i+=4)
{
temp[i]=str.mid(i,4).toInt(&ok,16);//每四位转化为16进制整型
qchar[i/4]=temp[i];
QString str1(qchar, len);
strOut=str1;
}
return strOut;
}
int main()
{
{
string str1("AAAA BBBB CCCC EEEE FFFF");
std::vector<string> vec = str1.split(' ');
assert(str1=="AAAA BBBB CCCC EEEE FFFF");
assert(vec.size() == 5);
assert(vec[0]=="AAAA");
assert(vec[1]=="BBBB");
assert(vec[2]=="CCCC");
assert(vec[3]=="EEEE");
assert(vec[4]=="FFFF");
}
}
//连续赋值
void Test3()
{
cout<<"Test3 begins:"<<endl;
const char *text = "hello world";
My_String str1(text);
My_String str2,str3;
str3 = str2 = str1;
cout<<"The experted result is :"<<text<<endl;
cout<<"The actual result is :";
str2.Print();
cout<<endl;
str3.Print();
cout<<endl;
}
// CDialogNew 消息处理程序
void CDialogNew::OnBnClickedOk()
{
// TODO: 在此添加控件通知处理程序代码
m_EditText.GetWindowTextW(m_Text);
if(m_Text == "0" || m_Text == ""|| m_Text.SpanIncluding( _T(".0123456789"))!= m_Text)
{
CString str1("输入格式不正确，请重新输入！");
CString str2("提示");
MessageBox(str1,str2);
m_Text = "";
}
else
{
int nIndex = m_Combobox.GetCurSel();
m_Combobox.GetLBText(nIndex,m_Unit);
CDialogEx::OnOK();
}
}
void testCountASCIIChars()
{
vmime::string str1("foo");
VASSERT_EQ("1", static_cast <vmime::string::size_type>(3),
stringUtils::countASCIIchars(str1.begin(), str1.end()));
vmime::string str2("f=?oo");
VASSERT_EQ("2", static_cast <vmime::string::size_type>(3 + 1),
stringUtils::countASCIIchars(str2.begin(), str2.end()));
vmime::string str3("foo\x7f");
VASSERT_EQ("3", static_cast <vmime::string::size_type>(4),
stringUtils::countASCIIchars(str3.begin(), str3.end()));
vmime::string str4("foo\x80");
VASSERT_EQ("4", static_cast <vmime::string::size_type>(3),
stringUtils::countASCIIchars(str4.begin(), str4.end()));
}
//---------------------------------------------------------------------------------------------------------------------------------------------------
void ProgressBar::DrawProgress()
{
sprite->Clear(Color::GRAY);
sprite->FillRectangle(0, 0, (int)(width * progress), (int)height, Color::BLUE);
char buffer[100];
sprintf_s(buffer, 99, "%5.1f%%", progress * 100.0f);
textPercents->SetText(String(buffer));
sprintf_s(buffer, 99, "Size: all %5.1fMB, recieved %5.1fMB\n", bytesAll / 1024.0f / 1024.0f, bytesRecieved / 1024.0f / 1024.0f);
String str1(buffer);
sprintf_s(buffer, 99, "Speed %5.1fkB/s, time: passed %5.1fs, elapsed %5.1fs", speed / 1024.0f, timePassed, timeElapsed);
String str2(buffer);
text->SetText(currentFile + String("\n") + str1 + str2);
}
int main(int argc, char** argv)
{
value(1);
int a = 19;
value(std::move(a));
std::string str1("Hello");
std::string str2 = std::move(str1);
std::cout << "after move str:" << str1 <<std::endl; // str1 was cleared
foo t;
t.a = 16;
foo s = t; // call copy constructor
foo v;
v = s; // call operator==
return 0;
}
void CDialogNew::OnBnClickedOk()
{
// TODO: 在此添加控件通知处理程序代码
m_EditRow.GetWindowTextW(m_Row);
m_EditCol.GetWindowTextW(m_Col);
if(m_Row == "" || m_Col == "" || m_Row.SpanIncluding( _T("0123456789"))!= m_Row || m_Col.SpanIncluding( _T("0123456789"))!= m_Col)
{
CString str1("输入格式不正确，请重新输入！");
CString str2("提示");
MessageBox(str1,str2);
m_Row = "";
m_Col = "";
}
else
{
CDialogEx::OnOK();
}
}
//---------------------------------------------------------
int main(int argc, char* argv[])
{
{
std::string str("abc 123 abc 123");
boost::replace_all(str, "123", "abc");
assert(str=="abc abc abc abc");
}
{
std::string str1, str2;
std::vector<std::string> token;
str1="one.two";
boost::split(token, str1, boost::is_any_of("."));
str2=boost::algorithm::join(token, "_");
boost::algorithm::replace_all(str2, "_", ".");
assert(str1==str2);
token.erase(token.begin());
assert(boost::algorithm::join(token, ".")=="two");
}
//trim
{
std::string str1(" 1x x x x1 ");
std::string str2("<>trim<>");
std::string str3("123abs343");
assert(boost::trim_left_copy(str1)=="1x x x x1 ");
boost::trim_right(str1);
assert(boost::trim_left_copy(str1)=="1x x x x1");
assert(boost::trim_copy_if(str2, boost::is_any_of("<>"))=="trim");
assert(boost::trim_copy_if(str3, boost::is_digit())=="abs");
boost::trim_if(str2, boost::is_any_of("<>"));
assert(str2=="trim");
}
{
std::string str("aBc");
boost::to_upper(str);
assert(str=="ABC");
boost::to_lower(str);
assert(str=="abc");
}
return 0;
}
//连续赋值
void Test3(){
printf("Test3 begins:\n");
char* text = "Hello world.";
CMyString str1(text);
CMyString str2, str3;
str3 = str2 = str1;
printf("The expected result is:%s.\n", text);
printf("The actual result is: ");
str2.Print();
printf("\n");
str3.Print();
printf("\n");
}
static
void test_static_string_equal()
{
my_static_string_t str0("hello");
my_static_string_t str0b("hello");
my_static_string_t str1("hello!");
my_static_string_t str2("hell");
my_static_string_t a("a");
my_static_string_t b("b");
UF_TEST(str0 == str0b);
UF_TEST(!(str0 == str1));
UF_TEST(str0 != str1);
UF_TEST(str0 != str2);
UF_TEST( a < b);
UF_TEST(!(a < a));
UF_TEST(!(b < a));
}
int main(int argc, char** argv)
{
std::string str1("good thing");
const char* str2("bad thing");
utils::piece pie1(str1);
utils::piece pie2(str2);
std::cout << "piece1: " << pie1 << " base: " << (void*) pie1.c_str() << std::endl
<< "piece2: " << pie2 << " base: " << (void*) pie2.c_str() << std::endl;
std::cout << "piece1 substr: " << pie1.substr(5) << " base: " << (void*) pie1.substr(5).c_str() << std::endl
<< "piece2 substr: " << pie2.substr(4) << " base: " << (void*) pie2.substr(4).c_str() << std::endl
<< "equal? " << (pie1.substr(5) == pie2.substr(4)) << std::endl;
typedef boost::tokenizer<utils::space_separator, utils::piece::const_iterator, utils::piece> tokenizer_type;
tokenizer_type tokens1(pie1);
tokenizer_type tokens2(pie2);
for (tokenizer_type::iterator iter = tokens1.begin(); iter != tokens1.end(); ++ iter)
std::cout << "token1: " << *iter << " base: " << (void*) (*iter).c_str() << " cast: " << static_cast<std::string>(*iter) << std::endl;
for (tokenizer_type::iterator iter = tokens2.begin(); iter != tokens2.end(); ++ iter)
std::cout << "token2: " << *iter << " base: " << (void*) (*iter).c_str() << " cast: " << static_cast<std::string>(*iter) << std::endl;
const char* str3 = "Good";
const char* str4 = "GOOD";
const char* str5 = "Good-bye";
std::cout << "less: " << (utils::piece(str3) < str4) << std::endl
<< "greater: " << (utils::piece(str3) > str4) << std::endl
<< "equal: " << (utils::piece(str3) == str4) << std::endl;
std::cout << "less: " << (utils::ipiece(str3) < str4) << std::endl
<< "greater: " << (utils::ipiece(str3) > str4) << std::endl
<< "equal: " << (utils::ipiece(str3) == str4) << std::endl;
std::cout << "less: " << (utils::ipiece(str3) < str5) << std::endl
<< "greater: " << (utils::ipiece(str3) > str5) << std::endl
<< "equal: " << (utils::ipiece(str3) == str5) << std::endl;
std::cout << "cast: " << boost::lexical_cast<int>(utils::ipiece("500")) << std::endl;
}
TEST(String, Compare) {
EXPECT_TRUE(String("abc").compare("abc") == 0);
EXPECT_TRUE(String("abc").compare("bbc") < 0);
EXPECT_TRUE(String("bbc").compare("abc") > 0);
EXPECT_TRUE(String("abc").compare(String("abc")) == 0);
EXPECT_TRUE(String("abc").compare(String("bbc")) < 0);
EXPECT_TRUE(String("bbc").compare(String("abc")) > 0);
EXPECT_TRUE(String("abc").compare("abcd") < 0);
EXPECT_TRUE(String("abcd").compare("abc") > 0);
EXPECT_TRUE(String("abc").compare(String("abcd")) < 0);
EXPECT_TRUE(String("abcd").compare(String("abc")) > 0);
// check Strings with embedded nulls
std::string str1("a\0bc", 4);
std::string str2("a\0bb", 4);
EXPECT_TRUE(String(str1).compare(String(str1)) == 0);
EXPECT_TRUE(String(str1).compare(String(str2)) > 0);
EXPECT_TRUE(String(str2).compare(String(str1)) < 0);
}
TEST(EditDistanceBitParallelTest, CalculateEditDistance) {
typedef edit_distance_bit_parallel::EditDistanceBitParallel<uint8_t, uint64_t> TestEditDistanceBitParallel;
TestEditDistanceBitParallel::Char alphabet_size = 4;
TestEditDistanceBitParallel::Char str0_values[] = { 0, 1, 2, 3, 0, 1, 2, 3 };
std::vector<TestEditDistanceBitParallel::Char> str0(&str0_values[0],
&str0_values[0] + sizeof(str0_values) / sizeof(str0_values[0]));
TestEditDistanceBitParallel::Char str1_values[] = { 0, 0, 2, 3, 0, 1, 2, 3 };
std::vector<TestEditDistanceBitParallel::Char> str1(&str1_values[0],
&str1_values[0] + sizeof(str1_values) / sizeof(str1_values[0]));
std::vector<TestEditDistanceBitParallel::Word> str0_p_eq(alphabet_size, 0);
TestEditDistanceBitParallel editdistance_bit_parallel;
editdistance_bit_parallel.BuildPeq(&str0[0], str0.size(), &str0_p_eq[0]);
TestEditDistanceBitParallel::Distance distance = editdistance_bit_parallel.CalculateEditDistance(
&str0_p_eq[0], &str1[0], str1.size());
EXPECT_EQ(1, distance);
}
MathCell* MathParser::ParseCharCode(wxXmlNode* node, int style)
{
TextCell* cell = new TextCell;
wxString str;
if (node != NULL && (str = node->GetContent()) != wxEmptyString)
{
long code;
if (str.ToLong(&code))
str = wxString::Format(wxT("%c"), code);
#if !wxUSE_UNICODE
wxString str1(str.wc_str(wxConvUTF8), *wxConvCurrent);
str = str1;
#endif
cell->SetValue(str);
cell->SetType(m_ParserStyle);
cell->SetStyle(style);
cell->SetHighlight(m_highlight);
}
return cell;
}
int main(int argc, char *argv[])
{
// BinaryCode *bc = new BinaryCode();
auto_ptr<BinaryCode> bc (new BinaryCode());
string str1 ("123210122");
vector<string> str1Response = bc->decode(str1);
cout << "Dla stringa: " << str1 << endl;
cout << "Pierwsza wartość: " << str1Response[0] << endl;
cout << "Druga wartość: " << str1Response[1] << endl << endl;
string str2 ("11");
vector<string> str2Response = bc->decode(str2);
cout << "Dla stringa: " << str2 << endl;
cout << "Pierwsza wartość: " << str2Response[0] << endl;
cout << "Druga wartość: " << str2Response[1] << endl << endl;;
string str3 ("22111");
vector<string> str3Response = bc->decode(str3);
cout << "Dla stringa: " << str3 << endl;
cout << "Pierwsza wartość: " << str3Response[0] << endl;
cout << "Druga wartość: " << str3Response[1] << endl << endl;;
string str4 ("123210120");
vector<string> str4Response = bc->decode(str4);
cout << "Dla stringa: " << str4 << endl;
cout << "Pierwsza wartość: " << str4Response[0] << endl;
cout << "Druga wartość: " << str4Response[1] << endl << endl;;
string str5 ("3");
vector<string> str5Response = bc->decode(str5);
cout << "Dla stringa: " << str5 << endl;
cout << "Pierwsza wartość: " << str5Response[0] << endl;
cout << "Druga wartość: " << str5Response[1] << endl << endl;;
string str6 ("12221112222221112221111111112221111");
vector<string> str6Response = bc->decode(str6);
cout << "Dla stringa: " << str6 << endl;
cout << "Pierwsza wartość: " << str6Response[0] << endl;
cout << "Druga wartość: " << str6Response[1] << endl << endl;;
return 0;
}
