String/List closer to conventions, and use Index type (#959)

* List made members m_
Tweaked types to closer match conventions.

* Use asserts for checking conditions on List.
Other small improvements.

* List<T>.Count() -> getSize()

* List<T>
Add -> add
First -> getFirst
Last -> getLast
RemoveLast -> removeLast
ReleaseBuffer -> detachBuffer
GetArrayView -> getArrayView

* List<T>::
AddRange -> addRange
Capacity -> getCapacity
Insert -> insert
InsertRange -> insertRange
AddRange -> addRange
RemoveRange -> removeRange
RemoveAt -> removeAt
Remove -> remove
Reverse -> reverse
FastRemove -> fastRemove
FastRemoveAt -> fastRemoveAt
Clear -> clear

* List<T>
FreeBuffer -> _deallocateBuffer
Free -> clearAndDeallocate
SwapWith -> swapWith

* List<T>
SetSize -> setSize
Reserve -> reserve
GrowToSize growToSize

* UnsafeShrinkToSize -> unsafeShrinkToSize
Compress -> compress
FindLast -> findLastIndex
FindLast -> findLastIndex
Simplify Contains

* List<T>
Removed m_allocator (wasn't used)
Swap -> swapElements
Sort -> sort
Contains -> contains
ForEach -> forEach
QuickSort -> quickSort
InsertionSort -> insertionSort
BinarySearch -> binarySearch

Max -> calcMax
Min -> calcMin

* Initializer::Initialize -> initialize
List<T>::
Allocate -> _allocate
Init -> _init
IndexOf -> indexOf

* * Put #include <assert.h> in common.h, and remove unneeded inclusions
* Small refactor of ArrayView - remove stride as not used

* getSize -> getCount
setSize -> setCount
unsafeShrinkToSize->unsafeShrinkToCount
growToSize -> growToCount
m_size -> m_count

* Some tidy up around Allocator.

* Use Index type on List.

* Refactor of IntSet.
First tentative look at using Index.

* Made Index an Int
Did preliminary fixes.
Made String use Index.

* Partial refactor of String.

* String::Buffer -> getBuffer
ToWString -> toWString

* Small improvements to String.
String::
Buffer() -> getBuffer()
Equals() -> equals

* Try to use Index where appropriate.

* Fix warnings on windows x86 builds.

1 files changed, 11 insertions, 11 deletions

diff --git a/source/core/slang-writer.cpp b/source/core/slang-writer.cpp
index a3222b0d2..2c6f99bf9 100644
--- a/source/core/slang-writer.cpp
+++ b/source/core/slang-writer.cpp
@@ -66,17 +66,17 @@ ISlangUnknown* BaseWriter::getInterface(const Guid& guid)
 
 SLANG_NO_THROW char* SLANG_MCALL AppendBufferWriter::beginAppendBuffer(size_t maxNumChars)
 {
-    m_appendBuffer.SetSize(maxNumChars);
-    return m_appendBuffer.Buffer();
+    m_appendBuffer.setCount(maxNumChars);
+    return m_appendBuffer.getBuffer();
 }
 
 SLANG_NO_THROW SlangResult SLANG_MCALL AppendBufferWriter::endAppendBuffer(char* buffer, size_t numChars)
 {
-    SLANG_ASSERT(m_appendBuffer.Buffer() == buffer && buffer + numChars <= m_appendBuffer.end());
+    SLANG_ASSERT(m_appendBuffer.getBuffer() == buffer && buffer + numChars <= m_appendBuffer.end());
     // Do the actual write
     SlangResult res = write(buffer, numChars);
     // Clear so that buffer can't be written from again without assert
-    m_appendBuffer.Clear();
+    m_appendBuffer.clear();
     return res;
 }
 
@@ -85,17 +85,17 @@ SLANG_NO_THROW SlangResult SLANG_MCALL AppendBufferWriter::endAppendBuffer(char*
 SLANG_NO_THROW char* SLANG_MCALL CallbackWriter::beginAppendBuffer(size_t maxNumChars)
 {
     // Add one so there is always space for end termination, we need for the callback.
-    m_appendBuffer.SetSize(maxNumChars + 1);
-    return m_appendBuffer.Buffer();
+    m_appendBuffer.setCount(maxNumChars + 1);
+    return m_appendBuffer.getBuffer();
 }
 
 SlangResult CallbackWriter::write(const char* chars, size_t numChars)
 {
     if (numChars > 0)
     {
-        char* appendBuffer = m_appendBuffer.Buffer();
+        char* appendBuffer = m_appendBuffer.getBuffer();
         // See if it's from an append buffer
-        if (chars >= appendBuffer && (chars + numChars) < (appendBuffer + m_appendBuffer.Count()))
+        if (chars >= appendBuffer && (chars + numChars) < (appendBuffer + m_appendBuffer.getCount()))
         {
             // Set terminating 0
             appendBuffer[(chars + numChars) - appendBuffer] = 0;
@@ -105,11 +105,11 @@ SlangResult CallbackWriter::write(const char* chars, size_t numChars)
         else
         {
             // Use the append buffer to add the terminating 0
-            m_appendBuffer.SetSize(numChars + 1);
-            ::memcpy(m_appendBuffer.Buffer(), chars, numChars);
+            m_appendBuffer.setCount(numChars + 1);
+            ::memcpy(m_appendBuffer.getBuffer(), chars, numChars);
             m_appendBuffer[numChars] = 0;
 
-            m_callback(m_appendBuffer.Buffer(), (void*)m_data);
+            m_callback(m_appendBuffer.getBuffer(), (void*)m_data);
         }
     }