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, 6 insertions, 6 deletions

diff --git a/source/slang/ir-dominators.cpp b/source/slang/ir-dominators.cpp
index ad1639db5..488e67724 100644
--- a/source/slang/ir-dominators.cpp
+++ b/source/slang/ir-dominators.cpp
@@ -245,7 +245,7 @@ struct PostorderComputationContext : public DepthFirstSearchContext
 
     virtual void postVisit(IRBlock* block) SLANG_OVERRIDE
     {
-        order->Add(block);
+        order->add(block);
     }
 };
 
@@ -314,7 +314,7 @@ struct DominatorTreeComputationContext
 
         // We will initialize our map from the block objects to their "name"
         // (index in the traversal order), before moving on.
-        BlockName blockCount = BlockName(postorder.Count());
+        BlockName blockCount = BlockName(postorder.getCount());
         for(BlockName bb = 0; bb < blockCount; ++bb)
         {
             mapBlockToName[postorder[bb]] = bb;
@@ -322,7 +322,7 @@ struct DominatorTreeComputationContext
 
         // Next we initialize the `doms` array that we will iteratively turn
         // into an encoding of the dominator tree.
-        doms.SetSize(blockCount);
+        doms.setCount(blockCount);
         for(BlockName bb = 0; bb < blockCount; ++bb)
         {
             doms[bb] = kUndefined;
@@ -524,11 +524,11 @@ struct DominatorTreeComputationContext
 
         // We will build some intermediate information on each
         // block to help us fill out the tree.
-        BlockName blockCount = BlockName(doms.Count());
+        BlockName blockCount = BlockName(doms.getCount());
         List<BlockInfo> blockInfos;
         for(BlockName bb = 0; bb < blockCount; ++bb)
         {
-            blockInfos.Add(BlockInfo());
+            blockInfos.add(BlockInfo());
         }
 
         // We will propagate layout information in two passes over the tree.
@@ -626,7 +626,7 @@ struct DominatorTreeComputationContext
         //
         RefPtr<IRDominatorTree> dominatorTree = new IRDominatorTree();
         dominatorTree->code = code;
-        dominatorTree->nodes.SetSize(blockCount);
+        dominatorTree->nodes.setCount(blockCount);
 
         // We will iterate over all of the blocks, and fill in the corresponding
         // dominator tree node for each.