void testAppendDoubleFloat()
{
printf("\n==== Enter testAppendDoubleFloat ====\n");
{
Double d = Math::DOUBLE_MAX_VALUE;
StringBuffer sb;
String str;
// sb.AppendDouble(d);
// str = sb.ToString();
// printf(" >> Append Double %e, %s\n", d, str.string());
//
// d = Math::DOUBLE_MIN_VALUE;
// sb.Reset();
// sb.AppendDouble(d);
// str = sb.ToString();
// printf(" >> Append Double %e, %s\n", d, str.string());
//
// d = 9999912345.54321;
// sb.Reset();
// sb.AppendDouble(d);
// str = sb.ToString();
// printf(" >> Append Double %e, %s\n", d, str.string());
d = 2013.0806;
sb.Reset();
sb.AppendDouble(d);
str = sb.ToString();
printf(" >> Append Double %e, %s\n", d, str.string());
float f = 2013.0806;
sb.Reset();
sb.AppendFloat(f);
str = sb.ToString();
printf(" >> Append Float %e, %s\n", f, str.string());
// Float f = Math::FLOAT_MAX_VALUE;
// sb.Reset();
// sb.AppendFloat(f);
// str = sb.ToString();
// printf(" >> Append Float %e, %s\n", f, str.string());
//
// f = Math::FLOAT_MIN_VALUE;
// sb.Reset();
// sb.AppendFloat(f);
// str = sb.ToString();
// printf(" >> Append Float %e, %s\n", f, str.string());
//
// f = 12345.54321F;
// sb.Reset();
// sb.AppendFloat(f);
// str = sb.ToString();
// printf(" >> Append Float %f, %s\n", f, str.string());
}
printf("==== Leave testAppendDoubleFloat ====\n");
}
// @Override
ECode CWifiInfo::ToString(
/* [out] */ String* str)
{
StringBuffer sb;
String none("<none>");
sb.Append("SSID: ");
String sidStr;
mWifiSsid->ToString(&sidStr);
sb.Append(mWifiSsid == NULL ? IWifiSsid::NONE : sidStr);
sb.Append(", BSSID: ");
sb.Append(mBSSID.IsNull() ? none : mBSSID);
sb.Append(", MAC: ");
sb.Append(mMacAddress.IsNull() ? none : mMacAddress);
sb.Append(", Supplicant state: ");
if (mSupplicantState == NULL) sb.Append(none);
sb.Append(mSupplicantState);
sb.Append(", RSSI: ");
sb.Append(mRssi);
sb.Append(", Link speed: ");
sb.Append(mLinkSpeed);
sb.Append(", Net ID: ");
sb.Append(mNetworkId);
sb.Append(", Metered hint: ");
sb.AppendBoolean(mMeteredHint);
*str = sb.ToString();
return NOERROR;
}
//@Override
ECode CBatchedScanSettings::ToString(
/* [out] */ String* str)
{
VALIDATE_NOT_NULL(str);
StringBuffer sb;
String none("<none>");
sb.Append("BatchScanSettings [maxScansPerBatch: ");
if (mMaxScansPerBatch == UNSPECIFIED) {
sb.Append(none);
}
else {
sb.Append(mMaxScansPerBatch);
}
sb.Append(", maxApPerScan: ");
if (mMaxScansPerBatch == UNSPECIFIED) {
sb.Append(none);
}
else {
sb.Append(mMaxApPerScan);
}
sb.Append(", scanIntervalSec: ");
if (mMaxScansPerBatch == UNSPECIFIED) {
sb.Append(none);
}
else {
sb.Append(mScanIntervalSec);
}
sb.Append(", maxApForDistance: ");
if (mMaxScansPerBatch == UNSPECIFIED) {
sb.Append(none);
}
else {
sb.Append(mMaxApForDistance);
}
sb.Append(", channelSet: ");
if (mChannelSet == NULL) {
sb.Append("ALL");
}
else {
sb.Append("<");
AutoPtr<IIterator> iter;
mChannelSet->GetIterator((IIterator**)&iter);
Boolean bNext;
iter->HasNext(&bNext);
for (; bNext; iter->HasNext(&bNext)) {
AutoPtr<ICharSequence> channel;
iter->GetNext((IInterface**)&channel);
String str;
channel->ToString(&str);
sb.Append(" ");
sb.Append(str);
}
sb.Append(">");
}
sb.Append("]");
return sb.ToString(str);
}
ECode UsbAccessory::ToString(
/* [out] */ String* str)
{
VALIDATE_NOT_NULL(str);
StringBuffer buf;
buf += "UsbAccessory[mManufacturer=";
buf += mManufacturer;
buf += ", mModel=";
buf += mModel;
buf += ", mDescription=";
buf += mDescription;
buf += ", mVersion=";
buf += mVersion;
buf += ", mUri=";
buf += mUri;
buf += ", mSerial=";
buf += mSerial;
buf += "]";
buf.ToString(str);
return NOERROR;
}
ECode CUsbDevice::ToString(
/* [out] */ String* str)
{
VALIDATE_NOT_NULL(str);
StringBuffer buf;
buf += "UsbDevice[mName=";
buf += mName;
buf += ",mVendorId=";
buf += mVendorId;
buf += ",mProductId=";
buf += mProductId;
buf += ",mClass=";
buf += mClass;
buf += ",mSubclass=";
buf += mSubclass;
buf += ",mProtocol=";
buf += mProtocol;
buf += "]";
buf.ToString(str);
return NOERROR;
}
/**
* Trim leading zeros from IPv4 address strings
* Our base libraries will interpret that as octel..
* Must leave non v4 addresses and host names alone.
* For example, 192.168.000.010 -> 192.168.0.10
* TODO - fix base libraries and remove this function
* @param addr a string representing an ip addr
* @return a string propertly trimmed
*/
String NetworkUtils::TrimV4AddrZeros(
/* [in] */ const String& addr)
{
if (addr.IsNull()) {
return String(NULL);
}
AutoPtr<ArrayOf<String> > octets;
StringUtils::Split(addr, String("\\."), (ArrayOf<String>**)&octets);
if (octets->GetLength() != 4) {
return addr;
}
StringBuffer buff;
for (Int32 i = 0; i < 4; i++) {
// try {
if ((*octets)[i].GetLength() > 3) {
return addr;
}
buff += (*octets)[i];
// } catch (NumberFormatException e) {
// return addr;
// }
if (i < 3)
buff += String(".");
}
return buff.ToString();
}
ECode AttributedString::constructor(
/* [in] */ IAttributedCharacterIterator* iterator)
{
VALIDATE_NOT_NULL(iterator)
ICharacterIterator* ci = ICharacterIterator::Probe(iterator);
Int32 bi, ei;
ci->GetBeginIndex(&bi);
ci->GetEndIndex(&ei);
if (bi > ei) {
ALOGE("AttributedString::constructor(): IllegalArgumentException, invalid substring range.");
//throw new IllegalArgumentException("Invalid substring range");
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
StringBuffer buffer;
for (Int32 i = bi; i < ei; i++) {
Char32 cv, nv;
ci->GetCurrent(&cv);
buffer += cv;
ci->GetNext(&nv);
}
buffer.ToString(&mText);
AutoPtr<ISet> attributes;
iterator->GetAllAttributeKeys((ISet**)&attributes);
if (attributes == NULL) {
return NOERROR;
}
AutoPtr<IIterator> it;
attributes->GetIterator((IIterator**)&it);
Boolean hasNext;
IAttributedCharacterIteratorAttribute* attr;
Char32 ch, cv;
Int32 start, limit;
while(it->HasNext(&hasNext), hasNext) {
AutoPtr<IInterface> obj;
it->GetNext((IInterface**)&obj);
attr = IAttributedCharacterIteratorAttribute::Probe(obj);
ci->SetIndex(0, &ch);
while (ci->GetCurrent(&cv), cv != (Char32)ICharacterIterator::DONE) {
iterator->GetRunStart(attr, &start);
iterator->GetRunLimit(attr, &limit);
AutoPtr<IInterface> value;
iterator->GetAttribute(attr, (IInterface**)&value);
if (value != NULL) {
AddAttribute(attr, value, start, limit);
}
ci->SetIndex(limit, &ch);
}
}
return NOERROR;
}
ECode CDispList::OnShowNext()
{
// get the current showing item's index in the array.
Int32 index = -1;
AutoPtr<CDispListHelper> helper = GetHelper();
AutoPtr<ArrayOf<IInteger32*> > array = helper->mShortCutArray;
for(Int32 i = 0; i < array->GetLength(); i++)
{
AutoPtr<IInteger32> temp = (*array)[i];
Int32 v;
temp->GetValue(&v);
if(v == mCurItem)
{
index = i;
break;
}
}
{
String str;
StringBuffer sb;
sb += "current index = ";
sb += index;
sb.ToString(&str);
Logger::D(IDispList::TAG, str);
}
if( index == -1 )
return NOERROR;
// get the index of the next item to be shown
index++;
if( index == array->GetLength() )
index = 0;
AutoPtr<IInteger32> key = (*array)[index];
AutoPtr<IDispListDispFormat> format;
HashMap<AutoPtr<IInteger32>, AutoPtr<IDispListDispFormat> >::Iterator it =
helper->mShortCutFormatMap.Find(key);
if(it != helper->mShortCutFormatMap.End())
{
format = it->mSecond;
}
return OnShowItem(format);
}
ECode CDispList::OnShowItem(
/* [in] */ IDispListDispFormat* item)
{
// get a item's string id
AutoPtr<CDispListHelper> helper = GetHelper();
Int32 advType;
helper->GetAdvancedDisplayType(item, &advType);
AutoPtr<IInteger32> key;
CInteger32::New(advType, (IInteger32**)&key);
AutoPtr<IInteger32> str_id;
HashMap<AutoPtr<IInteger32>, AutoPtr<IInteger32> >::Iterator it =
helper->mShortCutStrMap.Find(key);
if(it != helper->mShortCutStrMap.End())
{
str_id = it->mSecond;
}
if( str_id == NULL ){
String itemStr;
item->ToString(&itemStr);
StringBuffer sb;
sb += "Fail in searching item = ";
sb += itemStr;
sb.ToString(&itemStr);
Logger::D(IDispList::TAG, itemStr);
return NOERROR;
}
// redraw TextView and show toast
Int32 value;
str_id->GetValue(&value);
mToast->SetText(value);
mToast->Show();
// record the current showing item
mCurItem = advType;
return NOERROR;
}
ECode AttributedString::constructor(
/* [in] */ IAttributedCharacterIterator* iterator,
/* [in] */ Int32 start,
/* [in] */ Int32 end,
/* [in] */ ISet* attributes)
{
VALIDATE_NOT_NULL(iterator)
ICharacterIterator* ci = ICharacterIterator::Probe(iterator);
Int32 beginIndex, endIndex;
ci->GetBeginIndex(&beginIndex);
ci->GetEndIndex(&endIndex);
if (start < beginIndex || end > endIndex || start > end) {
return E_ILLEGAL_ARGUMENT_EXCEPTION;
// throw new IllegalArgumentException();
}
if (attributes == NULL) {
return NOERROR;
}
StringBuffer buffer;
Char32 newIndex;
ci->SetIndex(start, &newIndex);
Int32 index;
while (ci->GetIndex(&index) ,index < end) {
Char32 c;
ci->GetCurrent(&c);
buffer += c;
Char32 nextC;
ci->GetNext(&nextC);
}
buffer.ToString(&mText);
AutoPtr<IIterator> it;
attributes->GetIterator((IIterator**)&it);
Boolean hasNext;
IAttributedCharacterIteratorAttribute* attr;
Char32 c, newChar;
Int32 id, runStart, limit;
while(it->HasNext(&hasNext), hasNext) {
AutoPtr<IInterface> obj;
it->GetNext((IInterface**)&obj);
attr = IAttributedCharacterIteratorAttribute::Probe(obj);
ci->SetIndex(start, &c);
while (ci->GetIndex(&id) ,index < end) {
AutoPtr<IInterface> value;
iterator->GetAttribute(attr, (IInterface**)&value);
iterator->GetRunStart(attr, &runStart);
iterator->GetRunLimit(attr, &limit);
if ((IAnnotation::Probe(value) != NULL
&& runStart >= start && limit <= end)
|| (value != NULL && (IAnnotation::Probe(value) == NULL))) {
AddAttribute(attr, value,
(runStart < start ? start : runStart) - start, (limit > end ? end : limit) - start);
}
ci->SetIndex(limit, &newChar);
}
}
return NOERROR;
}
void testMisc()
{
printf("\n==== Leave testAutoPtr ====\n");
{
StringBuffer sb(20);
String str;
for (Int32 i = 0; i < 20; i++) {
sb.AppendChar('A' + i);
}
str = sb.ToString();
printf(" >> Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.TrimToSize();
printf(" >> Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
}
{
StringBuffer sb;
String str;
for (Int32 i = 0; i < 20; i++) {
sb.AppendChar('A' + i);
}
sb.InsertString(0, String("0123456789"));
str = sb.ToString();
printf("\n >> InsertString Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
}
{
StringBuffer sb;
String str;
sb.AppendNULL();
str = sb.ToString();
printf("\n >> AppendNULL Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
}
{
StringBuffer sb(5);
String str;
for (Int32 i = 0; i < 5; ++i) {
sb.AppendChar('1' + i);
}
str = sb.ToString();
printf("\n >> BeforeReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(0, 5, String("ABCDE"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(0, 4, String("444"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(0, 3, String("UVWXYZ"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(0, 7, String("1234567"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(0, 0, String("ABC"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(0, 10, String("0123456789"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(10, 10, String("ABC"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(14, 18, String("XYZ"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
sb.Replace(12, 13, String("0"));
str = sb.ToString();
printf(" >> AfterReplace Capacity %d, length %d, str: %s\n", sb.mCapacity, sb.GetLength(), str.string());
}
printf("==== Leave testAutoPtr ====\n");
}
void testStringBuffer()
{
printf("==== Enter testStringBuffer ====\n");
printf("\n === Construct === \n");
StringBuffer sbc(String("Construct from String"));
String str = sbc.ToString();
printf(" > Construct:\n%s\n", (const char*)str);
printf("\n === Append === \n");
Char32 a = 'A';
StringBuffer sb;
ECode ec = sb.ToString(&str);
printf(">> Get string from emtpy StringBuffer %s, %08x - %08x\n", str.string(), NOERROR, ec);
sb.AppendCStr(">>Start\n");
sb.AppendNULL();
sb.AppendChar('_');
sb.AppendChar(a);
sb.AppendChar('_');
sb.AppendBoolean(TRUE);
sb.AppendChar('_');
sb.AppendBoolean(FALSE);
sb.AppendChar('_');
sb.AppendInt32(32);
sb.AppendChar('_');
sb.AppendInt32(-32);
sb.AppendChar('_');
sb.AppendInt64(64);
sb.AppendChar('_');
sb.AppendInt64(-64);
sb.AppendChar('_');
sb.AppendFloat(10.0f);
sb.AppendChar('_');
sb.AppendDouble(101010.1010);
sb.AppendChar('_');
sb.AppendString(String("String"));
sb.AppendCStr("\n<<End");
str = sb.ToString();
printf(" > AppendTest:\n%s\n", (const char*)str);
printf("\n === Index ===\n");
Int32 index = 0;
String subStr("32");
sb.IndexOf(subStr, &index);
printf(" > IndexOf %s is %d\n", (const char*)subStr, index);
subStr = String("_NOT_");
sb.IndexOf(subStr, &index);
printf(" > IndexOf %s is %d\n", (const char*)subStr, index);
subStr = String("32");
sb.LastIndexOf(subStr, &index);
printf(" > LastIndexOf %s is %d\n", (const char*)subStr, index);
subStr = String("_NOT_");
sb.LastIndexOf(subStr, &index);
printf(" > LastIndexOf %s is %d\n", (const char*)subStr, index);
printf("\n === Substring ===\n");
Int32 start = 30, end = 32;
sb.Substring(start, &subStr);
printf(" > Substring from %d is : %s\n", start, (const char*)subStr);
sb.SubstringEx(start, end, &subStr);
printf(" > Substring from %d to %d is : %s\n", start, end, (const char*)subStr);
printf("\n === Get ===\n");
Char32 ch = 0;
sb.GetChar(start, &ch);
printf(" > GetChar at %d is : %c\n", start, ch);
sb.GetLength(&end);
printf(" > GetLength is : %d\n", end);
sb.GetByteCount(&end);
printf(" > GetByteCount is : %d\n", end);
sb.GetCapacity(&end);
printf(" > GetCapacity is : %d\n", end);
printf("\n === Set/Replace/Insert ===\n");
sb.SetChar(13, 'B');
sb.ToString(&str);
printf(" > SetCharAt:\n%s\n", (const char*)str);
sb.Replace(15, 15 + 4, String("Replace"));
sb.ToString(&str);
printf(" > Replace:\n%s\n", (const char*)str);
sb.InsertString(15, String("Insert_"));
sb.ToString(&str);
printf(" > InsertString:\n%s\n", (const char*)str);
sb.InsertString(0, String("HeadInsert_"));
sb.ToString(&str);
printf(" > InsertString in head:\n%s\n", (const char*)str);
sb.InsertChar(19, '_');
sb.ToString(&str);
printf(" > InsertChar:\n%s\n", (const char*)str);
sb.InsertBoolean(19, TRUE);
sb.ToString(&str);
printf(" > InsertBoolean:\n%s\n", (const char*)str);
sb.InsertInt32(19, 32);
sb.ToString(&str);
printf(" > InsertInt32:\n%s\n", (const char*)str);
sb.InsertInt64(19, 64);
sb.ToString(&str);
printf(" > InsertInt64:\n%s\n", (const char*)str);
sb.InsertFloat(19, 128.0);
sb.ToString(&str);
printf(" > InsertFloat:\n%s\n", (const char*)str);
sb.InsertDouble(19, 10000.00001);
sb.ToString(&str);
printf(" > InsertDouble:\n%s\n", (const char*)str);
ArrayOf<Char32>* chars = ArrayOf<Char32>::Alloc(10);
for (Int32 i = 0; i < chars->GetLength(); ++i) {
(*chars)[i] = 'A' + i;
}
sb.InsertChars(19, *chars);
sb.ToString(&str);
printf(" > InsertChars:\n%s\n", (const char*)str);
sb.InsertCharsEx(19, *chars, 5, 5);
sb.ToString(&str);
printf(" > InsertCharsEx:\n%s\n", (const char*)str);
printf("\n === Delete ===\n");
sb.Delete(19, 24);
sb.ToString(&str);
printf(" > Delete:\n%s\n", (const char*)str);
sb.DeleteChar(1);
sb.ToString(&str);
printf(" > DeleteChar:\n%s\n", (const char*)str);
printf("\n === Reverse ===\n");
sb.Reverse();
sb.ToString(&str);
printf(" > Reverse:\n%s\n", (const char*)str);
printf("==== Leave testStringBuffer ====\n");
}