simparr.h

HEX编辑器

	return TRUE;
}

//-------------------------------------------------------------------
void SetGrowBy(int nGrowBy)
{
	if(nGrowBy > 0) m_nGrowBy = nGrowBy;
}

//-------------------------------------------------------------------
void ClearAll()
{
	if(m_pT != NULL)
		delete [] m_pT;
	m_pT = NULL;
	m_nSize = 0;
	m_nUpperBound = ARR_EMPTY;
}

//-------------------------------------------------------------------
BOOL blContainsRef(T& argT)
{
	int i;
	for(i = 0; i <= m_nUpperBound; i++)
		if(argT == m_pT[i])
			return TRUE;
	return FALSE;
}

//-------------------------------------------------------------------
BOOL blContains(T argT)
{
	int i;
	for(i = 0; i <= m_nUpperBound; i++)
		if(argT == m_pT[i])
			return TRUE;
	return FALSE;
}

//-------------------------------------------------------------------
int nContainsAt(T argT)
{
	int i;
	for(i = 0; i <= m_nUpperBound; i++)
		if(argT == m_pT[i])
			return i;
	return ARR_EMPTY;
}

//-------------------------------------------------------------------
// Make a copy of the other SimpleArray.
SimpleArray<T>& operator=( SimpleArray<T>& spa )
{
	// Can't assign to itself: "sa1 = sa1;" not allowed.
	if( &spa != this )
	{
		// If this array is not empty then delete it.
		ClearAll();
		// Allocate memory.
		m_pT = new T[ m_nSize ];
		// Copy the valid elements.
		if( m_pT != NULL )
		{
			// This array now is just large enough to contain the valid elements of spa.
			m_nUpperBound = spa.m_nUpperBound;
			m_nSize = m_nUpperBound + 1;
			// GrowBy rate is also copied.
			m_nGrowBy = spa.m_nGrowBy;
			int k;
			for(k = 0; k <= m_nUpperBound; k++)
				m_pT[k] = spa.m_pT[k];
		}
		// If no memory could be allocated, then this array remains empty.
	}
	return *this;
}

//-------------------------------------------------------------------
void AppendRef(T& argT)
{
	SetAt(m_nUpperBound+1, argT);
}

//-------------------------------------------------------------------
void Append(T argT)
{
	SetAtGrow(m_nUpperBound+1, argT);
}

//-------------------------------------------------------------------
T& GetRefAt(int nIndex)
{
	return m_pT[nIndex];
}

//-------------------------------------------------------------------
BOOL blCompare(SimpleArray<T>& spa)
{
	if(m_nUpperBound != spa.GetUpperBound() ) return FALSE;
	int k;
	for(k = 0; k <= m_nUpperBound; k++)
	{
		if(m_pT[k] != spa[k]) return FALSE;
	}
	return TRUE;
}

//-------------------------------------------------------------------
operator==(SimpleArray<T>& spa)
{
	return blCompare(spa);
}

//-------------------------------------------------------------------
operator!=(SimpleArray<T>& spa)
{
	return !blCompare(spa);
}

//-------------------------------------------------------------------
BOOL blIsEmpty()
{
	return (GetUpperBound() < 0) ? TRUE : FALSE;
}

//-------------------------------------------------------------------
void Exchange(int nIndex1, int nIndex2)
{
	T temp(GetRefAt(nIndex2));
	GetRefAt(nIndex2) = GetRefAt(nIndex1);
	GetRefAt(nIndex1) = temp;
}

//-------------------------------------------------------------------
BOOL Adopt(T* ptArray, int upbound, int size)
{
#ifdef _DEBUG
	if(ptArray == NULL || upbound<0 || size<=0 || upbound >= size)
		return FALSE;
#endif
	if(m_pT!=NULL)
		delete [] m_pT;
	m_pT = ptArray;
	m_nSize = size;
	m_nUpperBound = upbound;
	return TRUE;
}

//-------------------------------------------------------------------
void SetUpperBound(int upbnd)
{
	if(upbnd < m_nSize)
		m_nUpperBound = upbnd;
}

//-------------------------------------------------------------------
BOOL AppendArray( T* pSrc, int srclen )
{
	if( srclen <= 0 )
		return FALSE;

	if( m_nUpperBound + 1 + srclen > m_nSize )
	{
		// Not enough space, so get some.
		if( !AddSpace( srclen ) )
			return FALSE;
	}
	// Enough space to append without growing. Copy the data.
	int i;
	for( i=0; i<srclen; i++ )
	{
		m_pT[ m_nUpperBound + 1 + i ] = pSrc[i];
	}
	m_nUpperBound += srclen;
	return TRUE;
}

//-------------------------------------------------------------------
BOOL ExpandToSize()
{
	m_nUpperBound = m_nSize - 1;
	return TRUE;
}

//-------------------------------------------------------------------
BOOL CopyFrom( int index, T* pSrc, int srclen )
{
	if( m_nSize - index >= srclen )
	{
		// Enough space to copy into.
		int i;
		for( i = 0; i < srclen; i++ )
			m_pT[ index + i ] = pSrc[ i ];
		if( index + srclen - 1 > m_nUpperBound )
			m_nUpperBound = index + srclen - 1;
		return TRUE;
	}
	else
		return FALSE;
}
//-------------------------------------------------------------------
BOOL Replace( int ToReplaceIndex, int ToReplaceLength, T* pReplaceWith, int ReplaceWithLength )
{
	if( m_pT != NULL && ToReplaceLength > 0 )
	{
		// Number of elements from start to end of array large enough for request?
		if( m_nUpperBound - ToReplaceIndex + 1 >= ToReplaceLength )
		{
			if( ToReplaceLength < ReplaceWithLength )
			{
				int i;
				T dummy;

				// Next line might cause problems if used with non-pure-binary
				// objects.
				dummy = 0;

				InsertAtGrow( ToReplaceIndex, dummy, ReplaceWithLength - ToReplaceLength );
				for( i = 0; i < ReplaceWithLength; i++ )
				{
					m_pT[ ToReplaceIndex + i ] = pReplaceWith[ i ];
				}

				return TRUE;
			}
			else if( ToReplaceLength == ReplaceWithLength )
			{
				int i;
				for( i = 0; i < ReplaceWithLength; i++ )
				{
					m_pT[ ToReplaceIndex + i ] = pReplaceWith[ i ];
				}
				return TRUE;
			}
			else // if( ToReplaceLength > ReplaceWithLength )
			{
				int i;
				for( i = 0; i < ReplaceWithLength; i++ )
				{
					m_pT[ ToReplaceIndex + i ] = pReplaceWith[ i ];
				}

				RemoveAt( ToReplaceIndex + ReplaceWithLength, ToReplaceLength - ReplaceWithLength );
				return TRUE;
			}
		}
		else
		{
			return FALSE;
		}
	}
	else
	{
		return FALSE;
	}
}
protected:
	T* m_pT;
	int m_nSize;
	int m_nUpperBound;
	int m_nGrowBy;
};

// A string class.
class SimpleString : public SimpleArray<char>
{
public:

//-------------------------------------------------------------------
int SimpleString::AppendString( char* ps )
{
	if( m_nUpperBound == -1 )
		return SetToString( ps );
	else
	{
		InsertAtGrow( m_nUpperBound, ps, 0, strlen( ps ) );
	}
	return TRUE;
}

//-------------------------------------------------------------------
int SimpleString::SetToString( char* ps )
{
	Clear();
	return AppendString( ps );
}

//-------------------------------------------------------------------
char* SimpleString::operator=( char* ps )
{
	SetToString( ps );
	return ps;
}

//-------------------------------------------------------------------
SimpleString& SimpleString::operator=( SimpleString str )
{
	SetToString( &str[0] );
	return *this;
}

//-------------------------------------------------------------------
char* SimpleString::operator+=( char* ps )
{
	if( m_nUpperBound == -1 )
		SetToString( ps );
	else
	{
		InsertAtGrow( m_nUpperBound, ps, 0, strlen( ps ) );
	}
	return ps;
}

//-------------------------------------------------------------------
int SimpleString::StrLen()
{
	if( m_pT != NULL )
		return strlen( m_pT );
	else
		return 0;
}

//-------------------------------------------------------------------
SimpleString::SimpleString()
{
	// Create a string containing only a zero-byte.
	m_nGrowBy = 64;
	Clear();
}

//-------------------------------------------------------------------
SimpleString::SimpleString( char* ps )
{
	// Create a SimpleString from a normal char array-string.
	m_nGrowBy = 64;
	Clear();
	SetToString( ps );
}

//-------------------------------------------------------------------
void SimpleString::Clear()
{
	ClearAll();
	Append( '\0' );
}

//-------------------------------------------------------------------
SimpleString SimpleString::operator+( SimpleString& str1 )
{
	SimpleString t1;
	t1.SetToString( m_pT );
	t1 += str1;
	return SimpleString( &t1[0] );
}

//-------------------------------------------------------------------
int SimpleString::IsEmpty()
{
	return !StrLen();
}

};

//-------------------------------------------------------------------
inline SimpleString operator+( SimpleString ps1, char* ps2 )
{
	SimpleString s1;
	s1 += ps1;
	s1 += ps2;
	return SimpleString(s1);
}

//-------------------------------------------------------------------
inline SimpleString operator+( char* ps1, SimpleString ps2 )
{
	SimpleString s1;
	s1 += ps1;
	s1 += ps2;
	return SimpleString(s1);
}

#endif // #if !defined(__SIMPLEARRAY_H)