char* StringImp::ReallocateData(Subscript Bytes_)
{
STRMARKER("start: StringImp::ReallocateData(Subscript)", cout)
StringData* DisOwnedData_;
Boolean InvalidData_ = _StrData->data == StringData::DummyData() || !_StrData->data;
if ((DisOwnedData_ = ShouldDisOwnData()) || InvalidData_)
{
char* OldData_ = _StrData->data;
Subscript OldLen_ = _StrData->Length();
_StrData->data = StringData::AllocateStr(Bytes_);
if (!InvalidData_)
SafeMemMove(_StrData->data, OldData_, OldLen_);
TerminateString(OldLen_);
DisOwnSharedData(DisOwnedData_); // Do disowning only at end
}
else
_StrData->data = StringData::ReallocateStr(_StrData->data, Bytes_);
_StrData->_Size = Bytes_;
STRMARKER("end: StringImp::ReallocateData(Subscript)", cout)
return _StrData->data;
}
void StringImp::Assignment(char Chr_)
{
if (_StrData->_Size < 1)
ReallocateData(1);
_StrData->data[0] = Chr_;
TerminateString(1);
}
void StringImp::Delete(Subscript pos, Subscript len)
{
if (pos >= strlen() || pos < 0 || len <= 0)
return;
Subscript RemLen_ = strlen() - pos;
if (RemLen_ <= len)
{
TerminateString(pos);
return;
}
Subscript Remain_ = strlen() - (pos + len);
char* Base_ = _StrData->data + pos;
memmove(Base_, &Base_[len], Remain_);
TerminateString(pos + Remain_);
}
void StringImp::LeftJustify(Subscript FieldWidth_, char Pad_)
{
if (_StrData->_Size < FieldWidth_)
ReallocateData(FieldWidth_);
Subscript Index_;
for (Index_ = strlen(); Index_ < FieldWidth_; Index_++)
(*_StrData)[Index_] = Pad_;
TerminateString(Index_);
}
void StringImp::Assignment(const char* Str_, Subscript Len_)
{
if (_StrData->data != Str_)
{
if (_StrData->_Size < Len_)
ReallocateData(Len_);
SafeMemMove(_StrData->data, Str_, Len_);
TerminateString(Len_);
}
}
BOOL StringsEqualN( LPTSTR pszStr1, LPTSTR pszStr2, int len )
/************************************************************************/
{
int len1, len2;
FNAME psz1, psz2;
len1 = lstrlen( pszStr1 );
len2 = lstrlen( pszStr2 );
if( len1 < len || len2 < len )
return( NO );
lstrcpy( psz1, pszStr1 );
TerminateString( psz1, len );
lstrcpy( psz2, pszStr2 );
TerminateString( psz2, len );
return StringsEqual( psz1, psz2 );
}
void StringImp::Addition(const StringImp& rhs)
{
int Identical_ = (this == &rhs);
StringImp* StrPtr_ = Identical_ ? (StringImp*)rhs.Clone():((StringImp*)&rhs);
Subscript NewLen_ = strlen() + StrPtr_->strlen();
if (_StrData->_Size < NewLen_)
ReallocateData(NewLen_);
SafeMemMove(_StrData->data + strlen(), StrPtr_->_StrData->data, StrPtr_->strlen());
TerminateString(NewLen_);
if (Identical_)
delete StrPtr_;
}
void StringImp::Duplicate(Subscript Num_)
{
if (_StrData->_Size < strlen() * (Num_ + 1))
ReallocateData(strlen() * (Num_ + 1));
char *Startp_, *Endp_;
Startp_ = _StrData->data;
Endp_ = &_StrData->data[strlen()];
for (Subscript Index_ = 0, Len_ = strlen(); Index_ < Num_; Index_++)
for (Subscript Letter_ = 0; Letter_ < Len_; Letter_++)
*Endp_++ = *Startp_++;
TerminateString(Endp_ - _StrData->data);
}
void StringImp::Subtraction(const StringImp& rhs)
{
int Identical_ = (this == &rhs);
StringImp* StrPtr_ = Identical_ ? (StringImp*)rhs.Clone():((StringImp*)&rhs);
if (strlen() >= StrPtr_->strlen())
{
Subscript Index_ = strlen();
Index_ -= StrPtr_->strlen();
if (!memcmp(&_StrData->data[Index_], StrPtr_->_StrData->data, StrPtr_->strlen()))
TerminateString(Index_);
}
if (Identical_)
delete StrPtr_;
}
void StringImp::Append(const StringImp& rhs, Subscript RunLen_)
{
if (RunLen_ > rhs.strlen())
RunLen_ = rhs.strlen();
int Identical_ = (this == &rhs);
StringImp* StrPtr_ = Identical_ ? (StringImp*)rhs.Clone():((StringImp*)&rhs);
Subscript OldLen_ = strlen();
if (_StrData->_Size < OldLen_ + RunLen_)
ReallocateData(OldLen_ + RunLen_);
SafeMemMove(&_StrData->data[OldLen_], StrPtr_->_StrData->data, RunLen_);
TerminateString(OldLen_ + RunLen_);
if (Identical_)
delete StrPtr_;
}
void StringImp::OverWrite(Subscript pos, const StringImp& Str_)
{
int Identical_ = (this == &Str_);
StringImp* StrPtr_ = Identical_ ? (StringImp*)Str_.Clone():((StringImp*)&Str_);
if (pos > strlen() || pos < 0)
return;
if (_StrData->_Size < pos + StrPtr_->strlen())
ReallocateData(StrPtr_->strlen() + pos);
if (strlen() - pos < StrPtr_->strlen())
TerminateString(pos + StrPtr_->strlen());
SafeMemMove(&_StrData->data[pos], StrPtr_->c_str(), StrPtr_->strlen());
if (Identical_)
delete StrPtr_;
}
void StringImp::CenterJustify(Subscript FieldWidth_, char Pad_)
{
Subscript PadLen_ = (FieldWidth_ - strlen()) / 2;
if (_StrData->_Size < FieldWidth_)
ReallocateData(FieldWidth_);
Subscript WordLen_ = strlen();
SafeMemMove(&_StrData->data[PadLen_], _StrData->data, WordLen_);
Subscript Index_;
for (Index_ = 0; Index_ < PadLen_; Index_++)
(*_StrData)[Index_] = Pad_;
for (Index_ += WordLen_; Index_ < FieldWidth_; Index_++)
(*_StrData)[Index_] = Pad_;
TerminateString(Index_);
}
void StringImp::SetStr(const char* p, Subscript pos, Subscript len)
{
if (!p)
return;
Subscript p_len = strlen();
if (pos > p_len) // error check the start pos
return;
Subscript strLen = p_len - pos;
if (len < strLen) // error check the copy length
strLen = len;
if (_StrData->_Size < strLen) // else create a new buffer
ReallocateData(strLen);
SafeMemMove(_StrData->data, p + pos, strLen);
TerminateString(strLen);
}
void StringImp::Assignment(const StringImp& Str_)
{
if (_StrData->data != Str_._StrData->data)
{
int Identical_ = (this == &Str_);
StringImp* StrPtr_ = Identical_ ? (StringImp*)Str_.Clone():((StringImp*)&Str_);
Subscript NewLen_ = StrPtr_->strlen();
if (_StrData->_Size < NewLen_)
ReallocateData(NewLen_);
SafeMemMove(_StrData->data, StrPtr_->_StrData->data, NewLen_);
TerminateString(NewLen_);
ObjectImp::operator = (*((Object*)StrPtr_));
if (Identical_)
delete StrPtr_;
}
}
void StringImp::Insert(Subscript pos, const StringImp& Str_)
{
int Identical_ = (this == &Str_);
StringImp* StrPtr_ = Identical_ ? (StringImp*)Str_.Clone():((StringImp*)&Str_);
if (pos > strlen() || pos < 0)
return;
if (_StrData->_Size < StrPtr_->strlen() + strlen())
ReallocateData(StrPtr_->strlen() + strlen());
char* Base_ = _StrData->data + pos;
Subscript BaseLen_ = strlen() - pos;
Subscript StopPt_ = BaseLen_ + StrPtr_->strlen();
SafeMemMove(&Base_[StrPtr_->strlen()], Base_, BaseLen_);
SafeMemMove(Base_, StrPtr_->c_str(), StrPtr_->strlen());
TerminateString(pos + StopPt_);
if (Identical_)
delete StrPtr_;
}
