lucy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nwelln...@apache.org
Subject [12/14] lucy git commit: Rename VArray to Vector
Date Wed, 29 Apr 2015 19:56:33 GMT
Rename VArray to Vector


Project: http://git-wip-us.apache.org/repos/asf/lucy/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucy/commit/0c238b13
Tree: http://git-wip-us.apache.org/repos/asf/lucy/tree/0c238b13
Diff: http://git-wip-us.apache.org/repos/asf/lucy/diff/0c238b13

Branch: refs/heads/master
Commit: 0c238b13bb011d73d51de87a067ba8a34e3e04a5
Parents: 40baec8
Author: Nick Wellnhofer <wellnhofer@aevum.de>
Authored: Sun Apr 26 21:10:34 2015 +0200
Committer: Nick Wellnhofer <wellnhofer@aevum.de>
Committed: Sun Apr 26 21:10:34 2015 +0200

----------------------------------------------------------------------
 c/src/Lucy/Index/Inverter.c                     |   6 +-
 core/Lucy/Analysis/Analyzer.c                   |   6 +-
 core/Lucy/Analysis/Analyzer.cfh                 |   2 +-
 core/Lucy/Analysis/PolyAnalyzer.c               |  44 +--
 core/Lucy/Analysis/PolyAnalyzer.cfh             |   8 +-
 core/Lucy/Highlight/HeatMap.c                   |  66 ++--
 core/Lucy/Highlight/HeatMap.cfh                 |  16 +-
 core/Lucy/Highlight/Highlighter.c               |  18 +-
 core/Lucy/Highlight/Highlighter.cfh             |   2 +-
 core/Lucy/Index/BackgroundMerger.c              |  44 +--
 core/Lucy/Index/DataReader.c                    |   8 +-
 core/Lucy/Index/DataReader.cfh                  |   8 +-
 core/Lucy/Index/DeletionsReader.c               |  38 +--
 core/Lucy/Index/DeletionsReader.cfh             |  14 +-
 core/Lucy/Index/DeletionsWriter.c               |  48 +--
 core/Lucy/Index/DeletionsWriter.cfh             |   4 +-
 core/Lucy/Index/DocReader.c                     |  26 +-
 core/Lucy/Index/DocReader.cfh                   |  14 +-
 core/Lucy/Index/DocVector.c                     |   2 +-
 core/Lucy/Index/FilePurger.c                    |  84 ++---
 core/Lucy/Index/HighlightReader.c               |  24 +-
 core/Lucy/Index/HighlightReader.cfh             |  14 +-
 core/Lucy/Index/IndexManager.c                  |  22 +-
 core/Lucy/Index/IndexManager.cfh                |   2 +-
 core/Lucy/Index/IndexReader.c                   |   4 +-
 core/Lucy/Index/IndexReader.cfh                 |   4 +-
 core/Lucy/Index/Indexer.c                       |  50 +--
 core/Lucy/Index/Inverter.c                      |  18 +-
 core/Lucy/Index/Inverter.cfh                    |   4 +-
 core/Lucy/Index/LexIndex.c                      |   2 +-
 core/Lucy/Index/LexiconReader.c                 |  36 +--
 core/Lucy/Index/LexiconReader.cfh               |  16 +-
 core/Lucy/Index/PolyLexicon.c                   |  30 +-
 core/Lucy/Index/PolyLexicon.cfh                 |   6 +-
 core/Lucy/Index/PolyReader.c                    |  72 ++---
 core/Lucy/Index/PolyReader.cfh                  |  10 +-
 core/Lucy/Index/PostingListReader.c             |   8 +-
 core/Lucy/Index/PostingListReader.cfh           |   8 +-
 core/Lucy/Index/PostingListWriter.c             |  24 +-
 core/Lucy/Index/PostingListWriter.cfh           |   2 +-
 core/Lucy/Index/PostingPool.c                   |   4 +-
 core/Lucy/Index/SegReader.c                     |  10 +-
 core/Lucy/Index/SegReader.cfh                   |   6 +-
 core/Lucy/Index/SegWriter.c                     |  26 +-
 core/Lucy/Index/SegWriter.cfh                   |   2 +-
 core/Lucy/Index/Segment.c                       |  18 +-
 core/Lucy/Index/Segment.cfh                     |   2 +-
 core/Lucy/Index/Snapshot.c                      |  32 +-
 core/Lucy/Index/Snapshot.cfh                    |   2 +-
 core/Lucy/Index/SortFieldWriter.c               |   4 +-
 core/Lucy/Index/SortReader.c                    |   8 +-
 core/Lucy/Index/SortReader.cfh                  |   8 +-
 core/Lucy/Index/SortWriter.c                    |  28 +-
 core/Lucy/Index/SortWriter.cfh                  |   2 +-
 core/Lucy/Plan/Architecture.c                   |  12 +-
 core/Lucy/Plan/Schema.c                         |  34 +-
 core/Lucy/Plan/Schema.cfh                       |   4 +-
 core/Lucy/Search/ANDMatcher.c                   |   6 +-
 core/Lucy/Search/ANDMatcher.cfh                 |   4 +-
 core/Lucy/Search/ANDQuery.c                     |  18 +-
 core/Lucy/Search/ANDQuery.cfh                   |   4 +-
 core/Lucy/Search/Collector/SortCollector.c      |  32 +-
 core/Lucy/Search/Collector/SortCollector.cfh    |   4 +-
 core/Lucy/Search/Compiler.c                     |   4 +-
 core/Lucy/Search/Compiler.cfh                   |   2 +-
 core/Lucy/Search/HitQueue.c                     |  12 +-
 core/Lucy/Search/Hits.c                         |   4 +-
 core/Lucy/Search/Hits.cfh                       |   2 +-
 core/Lucy/Search/IndexSearcher.c                |   8 +-
 core/Lucy/Search/IndexSearcher.cfh              |   2 +-
 core/Lucy/Search/MatchDoc.c                     |  12 +-
 core/Lucy/Search/MatchDoc.cfh                   |  10 +-
 core/Lucy/Search/NOTMatcher.c                   |   4 +-
 core/Lucy/Search/NOTQuery.c                     |  12 +-
 core/Lucy/Search/NOTQuery.cfh                   |   2 +-
 core/Lucy/Search/ORMatcher.c                    |  14 +-
 core/Lucy/Search/ORMatcher.cfh                  |   8 +-
 core/Lucy/Search/ORQuery.c                      |  18 +-
 core/Lucy/Search/ORQuery.cfh                    |   4 +-
 core/Lucy/Search/PhraseMatcher.c                |  10 +-
 core/Lucy/Search/PhraseMatcher.cfh              |   4 +-
 core/Lucy/Search/PhraseQuery.c                  |  68 ++--
 core/Lucy/Search/PhraseQuery.cfh                |  10 +-
 core/Lucy/Search/PolyMatcher.c                  |   8 +-
 core/Lucy/Search/PolyMatcher.cfh                |   6 +-
 core/Lucy/Search/PolyQuery.c                    |  56 ++--
 core/Lucy/Search/PolyQuery.cfh                  |  12 +-
 core/Lucy/Search/PolySearcher.c                 |  42 +--
 core/Lucy/Search/PolySearcher.cfh               |   6 +-
 core/Lucy/Search/QueryParser.c                  | 322 +++++++++----------
 core/Lucy/Search/QueryParser.cfh                |  14 +-
 core/Lucy/Search/QueryParser/QueryLexer.c       |   8 +-
 core/Lucy/Search/QueryParser/QueryLexer.cfh     |   2 +-
 core/Lucy/Search/RequiredOptionalMatcher.c      |   6 +-
 core/Lucy/Search/RequiredOptionalQuery.c        |  20 +-
 core/Lucy/Search/SeriesMatcher.c                |   8 +-
 core/Lucy/Search/SeriesMatcher.cfh              |   6 +-
 core/Lucy/Search/SortSpec.c                     |  20 +-
 core/Lucy/Search/SortSpec.cfh                   |   8 +-
 core/Lucy/Search/TermQuery.c                    |   6 +-
 core/Lucy/Search/TermQuery.cfh                  |   2 +-
 core/Lucy/Search/TopDocs.c                      |  12 +-
 core/Lucy/Search/TopDocs.cfh                    |  10 +-
 core/Lucy/Store/CompoundFileReader.c            |  14 +-
 core/Lucy/Store/CompoundFileReader.cfh          |   2 +-
 core/Lucy/Store/CompoundFileWriter.c            |  16 +-
 core/Lucy/Store/FSDirHandle.c                   |   2 +-
 core/Lucy/Store/Folder.c                        |  36 +--
 core/Lucy/Store/Folder.cfh                      |   4 +-
 core/Lucy/Store/RAMDirHandle.c                  |   6 +-
 core/Lucy/Store/RAMDirHandle.cfh                |   2 +-
 core/Lucy/Test/Analysis/TestAnalyzer.c          |   4 +-
 core/Lucy/Test/Analysis/TestCaseFolder.c        |   4 +-
 core/Lucy/Test/Analysis/TestNormalizer.c        |  20 +-
 core/Lucy/Test/Analysis/TestPolyAnalyzer.c      |  66 ++--
 core/Lucy/Test/Analysis/TestSnowballStemmer.c   |  14 +-
 core/Lucy/Test/Analysis/TestStandardTokenizer.c |  24 +-
 core/Lucy/Test/Highlight/TestHeatMap.c          | 124 +++----
 core/Lucy/Test/Highlight/TestHighlighter.c      |  48 +--
 core/Lucy/Test/Index/TestSnapshot.c             |  10 +-
 core/Lucy/Test/Index/TestSortWriter.c           |  18 +-
 core/Lucy/Test/Index/TestSortWriter.cfh         |   2 +-
 core/Lucy/Test/Search/TestQueryParserLogic.c    |   6 +-
 core/Lucy/Test/Search/TestQueryParserSyntax.c   |  12 +-
 core/Lucy/Test/Search/TestSeriesMatcher.c       |   4 +-
 core/Lucy/Test/Search/TestSortSpec.c            | 140 ++++----
 core/Lucy/Test/Store/TestFSFolder.c             |   6 +-
 core/Lucy/Test/Store/TestFolder.c               |  16 +-
 core/Lucy/Test/TestUtils.c                      |  42 +--
 core/Lucy/Test/TestUtils.cfh                    |   6 +-
 core/Lucy/Test/Util/TestFreezer.c               |  10 +-
 core/Lucy/Test/Util/TestJson.c                  |  18 +-
 core/Lucy/Test/Util/TestPriorityQueue.c         |  12 +-
 core/Lucy/Test/Util/TestSortExternal.c          |  90 +++---
 core/Lucy/Util/BBSortEx.c                       |  28 +-
 core/Lucy/Util/BBSortEx.cfh                     |   8 +-
 core/Lucy/Util/Freezer.c                        |  56 ++--
 core/Lucy/Util/Freezer.cfh                      |   8 +-
 core/Lucy/Util/Json.c                           |  22 +-
 core/Lucy/Util/Json.cfh                         |   4 +-
 core/Lucy/Util/Json/JsonParser.y                |  26 +-
 core/Lucy/Util/MemoryPool.c                     |  12 +-
 core/Lucy/Util/MemoryPool.cfh                   |   2 +-
 core/Lucy/Util/PriorityQueue.c                  |   6 +-
 core/Lucy/Util/PriorityQueue.cfh                |   2 +-
 core/Lucy/Util/SortExternal.c                   |  26 +-
 core/Lucy/Util/SortExternal.cfh                 |   2 +-
 core/Lucy/Util/ToolSet.h                        |   2 +-
 core/LucyX/Search/ProximityMatcher.c            |  10 +-
 core/LucyX/Search/ProximityMatcher.cfh          |   4 +-
 core/LucyX/Search/ProximityQuery.c              |  68 ++--
 core/LucyX/Search/ProximityQuery.cfh            |  10 +-
 go/lucy/index.go                                |   6 +-
 perl/t/213-segment_merging.t                    |   2 +-
 perl/t/505-hit_queue.t                          |   2 +-
 perl/t/518-or_scorer.t                          |   2 +-
 perl/t/520-match_doc.t                          |   2 +-
 perl/xs/Lucy/Index/Inverter.c                   |   4 +-
 158 files changed, 1480 insertions(+), 1480 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/c/src/Lucy/Index/Inverter.c
----------------------------------------------------------------------
diff --git a/c/src/Lucy/Index/Inverter.c b/c/src/Lucy/Index/Inverter.c
index 1719c4c..8393455 100644
--- a/c/src/Lucy/Index/Inverter.c
+++ b/c/src/Lucy/Index/Inverter.c
@@ -26,7 +26,7 @@
 #include "Clownfish/Hash.h"
 #include "Clownfish/HashIterator.h"
 #include "Clownfish/Num.h"
-#include "Clownfish/VArray.h"
+#include "Clownfish/Vector.h"
 #include "Lucy/Document/Doc.h"
 #include "Lucy/Index/Segment.h"
 #include "Lucy/Plan/FieldType.h"
@@ -51,10 +51,10 @@ S_fetch_entry(InverterIVARS *ivars, String *field) {
     }
 
     InverterEntry *entry
-        = (InverterEntry*)VA_Fetch(ivars->entry_pool, field_num);
+        = (InverterEntry*)Vec_Fetch(ivars->entry_pool, field_num);
     if (!entry) {
         entry = InvEntry_new(schema, (String*)field, field_num);
-        VA_Store(ivars->entry_pool, field_num, (Obj*)entry);
+        Vec_Store(ivars->entry_pool, field_num, (Obj*)entry);
     }
     return entry;
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Analysis/Analyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Analyzer.c b/core/Lucy/Analysis/Analyzer.c
index ca37005..5ffccc7 100644
--- a/core/Lucy/Analysis/Analyzer.c
+++ b/core/Lucy/Analysis/Analyzer.c
@@ -40,17 +40,17 @@ Analyzer_Transform_Text_IMP(Analyzer *self, String *text) {
     return retval;
 }
 
-VArray*
+Vector*
 Analyzer_Split_IMP(Analyzer *self, String *text) {
     Inversion  *inversion = Analyzer_Transform_Text(self, text);
-    VArray     *out       = VA_new(0);
+    Vector     *out       = Vec_new(0);
     Token      *token;
 
     while ((token = Inversion_Next(inversion)) != NULL) {
         TokenIVARS *const token_ivars = Token_IVARS(token);
         String *string
             = Str_new_from_trusted_utf8(token_ivars->text, token_ivars->len);
-        VA_Push(out, (Obj*)string);
+        Vec_Push(out, (Obj*)string);
     }
 
     DECREF(inversion);

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Analysis/Analyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/Analyzer.cfh b/core/Lucy/Analysis/Analyzer.cfh
index 21b8d67..1580efa 100644
--- a/core/Lucy/Analysis/Analyzer.cfh
+++ b/core/Lucy/Analysis/Analyzer.cfh
@@ -46,7 +46,7 @@ public abstract class Lucy::Analysis::Analyzer inherits Clownfish::Obj {
 
     /** Analyze text and return an array of token texts.
      */
-    public incremented VArray*
+    public incremented Vector*
     Split(Analyzer *self, String *text);
 
     public incremented Obj*

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Analysis/PolyAnalyzer.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/PolyAnalyzer.c b/core/Lucy/Analysis/PolyAnalyzer.c
index 9a549d8..8013937 100644
--- a/core/Lucy/Analysis/PolyAnalyzer.c
+++ b/core/Lucy/Analysis/PolyAnalyzer.c
@@ -26,28 +26,28 @@
 #include "Lucy/Util/Freezer.h"
 
 PolyAnalyzer*
-PolyAnalyzer_new(String *language, VArray *analyzers) {
+PolyAnalyzer_new(String *language, Vector *analyzers) {
     PolyAnalyzer *self = (PolyAnalyzer*)Class_Make_Obj(POLYANALYZER);
     return PolyAnalyzer_init(self, language, analyzers);
 }
 
 PolyAnalyzer*
 PolyAnalyzer_init(PolyAnalyzer *self, String *language,
-                  VArray *analyzers) {
+                  Vector *analyzers) {
     Analyzer_init((Analyzer*)self);
     PolyAnalyzerIVARS *const ivars = PolyAnalyzer_IVARS(self);
 
     if (analyzers) {
-        for (uint32_t i = 0, max = VA_Get_Size(analyzers); i < max; i++) {
-            CERTIFY(VA_Fetch(analyzers, i), ANALYZER);
+        for (uint32_t i = 0, max = Vec_Get_Size(analyzers); i < max; i++) {
+            CERTIFY(Vec_Fetch(analyzers, i), ANALYZER);
         }
-        ivars->analyzers = (VArray*)INCREF(analyzers);
+        ivars->analyzers = (Vector*)INCREF(analyzers);
     }
     else if (language) {
-        ivars->analyzers = VA_new(3);
-        VA_Push(ivars->analyzers, (Obj*)CaseFolder_new());
-        VA_Push(ivars->analyzers, (Obj*)RegexTokenizer_new(NULL));
-        VA_Push(ivars->analyzers, (Obj*)SnowStemmer_new(language));
+        ivars->analyzers = Vec_new(3);
+        Vec_Push(ivars->analyzers, (Obj*)CaseFolder_new());
+        Vec_Push(ivars->analyzers, (Obj*)RegexTokenizer_new(NULL));
+        Vec_Push(ivars->analyzers, (Obj*)SnowStemmer_new(language));
     }
     else {
         THROW(ERR, "Must specify either 'language' or 'analyzers'");
@@ -63,19 +63,19 @@ PolyAnalyzer_Destroy_IMP(PolyAnalyzer *self) {
     SUPER_DESTROY(self, POLYANALYZER);
 }
 
-VArray*
+Vector*
 PolyAnalyzer_Get_Analyzers_IMP(PolyAnalyzer *self) {
     return PolyAnalyzer_IVARS(self)->analyzers;
 }
 
 Inversion*
 PolyAnalyzer_Transform_IMP(PolyAnalyzer *self, Inversion *inversion) {
-    VArray *const analyzers = PolyAnalyzer_IVARS(self)->analyzers;
+    Vector *const analyzers = PolyAnalyzer_IVARS(self)->analyzers;
     (void)INCREF(inversion);
 
     // Iterate through each of the analyzers in order.
-    for (uint32_t i = 0, max = VA_Get_Size(analyzers); i < max; i++) {
-        Analyzer *analyzer = (Analyzer*)VA_Fetch(analyzers, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(analyzers); i < max; i++) {
+        Analyzer *analyzer = (Analyzer*)Vec_Fetch(analyzers, i);
         Inversion *new_inversion = Analyzer_Transform(analyzer, inversion);
         DECREF(inversion);
         inversion = new_inversion;
@@ -86,8 +86,8 @@ PolyAnalyzer_Transform_IMP(PolyAnalyzer *self, Inversion *inversion) {
 
 Inversion*
 PolyAnalyzer_Transform_Text_IMP(PolyAnalyzer *self, String *text) {
-    VArray *const   analyzers     = PolyAnalyzer_IVARS(self)->analyzers;
-    const uint32_t  num_analyzers = VA_Get_Size(analyzers);
+    Vector *const   analyzers     = PolyAnalyzer_IVARS(self)->analyzers;
+    const uint32_t  num_analyzers = Vec_Get_Size(analyzers);
     Inversion      *retval;
 
     if (num_analyzers == 0) {
@@ -98,10 +98,10 @@ PolyAnalyzer_Transform_Text_IMP(PolyAnalyzer *self, String *text) {
         DECREF(seed);
     }
     else {
-        Analyzer *first_analyzer = (Analyzer*)VA_Fetch(analyzers, 0);
+        Analyzer *first_analyzer = (Analyzer*)Vec_Fetch(analyzers, 0);
         retval = Analyzer_Transform_Text(first_analyzer, text);
         for (uint32_t i = 1; i < num_analyzers; i++) {
-            Analyzer *analyzer = (Analyzer*)VA_Fetch(analyzers, i);
+            Analyzer *analyzer = (Analyzer*)Vec_Fetch(analyzers, i);
             Inversion *new_inversion = Analyzer_Transform(analyzer, retval);
             DECREF(retval);
             retval = new_inversion;
@@ -117,7 +117,7 @@ PolyAnalyzer_Equals_IMP(PolyAnalyzer *self, Obj *other) {
     if (!Obj_Is_A(other, POLYANALYZER))                       { return false; }
     PolyAnalyzerIVARS *const ivars = PolyAnalyzer_IVARS(self);
     PolyAnalyzerIVARS *const ovars = PolyAnalyzer_IVARS((PolyAnalyzer*)other);
-    if (!VA_Equals(ovars->analyzers, (Obj*)ivars->analyzers)) { return false; }
+    if (!Vec_Equals(ovars->analyzers, (Obj*)ivars->analyzers)) { return false; }
     return true;
 }
 
@@ -140,10 +140,10 @@ PolyAnalyzer_Load_IMP(PolyAnalyzer *self, Obj *dump) {
     PolyAnalyzer_Load_t super_load 
         = SUPER_METHOD_PTR(POLYANALYZER, LUCY_PolyAnalyzer_Load);
     PolyAnalyzer *loaded = super_load(self, dump);
-    VArray *analyzer_dumps
-        = (VArray*)CERTIFY(Hash_Fetch_Utf8(source, "analyzers", 9), VARRAY);
-    VArray *analyzers
-        = (VArray*)CERTIFY(Freezer_load((Obj*)analyzer_dumps), VARRAY);
+    Vector *analyzer_dumps
+        = (Vector*)CERTIFY(Hash_Fetch_Utf8(source, "analyzers", 9), VECTOR);
+    Vector *analyzers
+        = (Vector*)CERTIFY(Freezer_load((Obj*)analyzer_dumps), VECTOR);
     PolyAnalyzer_init(loaded, NULL, analyzers);
     DECREF(analyzers);
     return loaded;

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Analysis/PolyAnalyzer.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Analysis/PolyAnalyzer.cfh b/core/Lucy/Analysis/PolyAnalyzer.cfh
index 437f9fa..0a7badb 100644
--- a/core/Lucy/Analysis/PolyAnalyzer.cfh
+++ b/core/Lucy/Analysis/PolyAnalyzer.cfh
@@ -49,10 +49,10 @@ parcel Lucy;
  */
 public class Lucy::Analysis::PolyAnalyzer inherits Lucy::Analysis::Analyzer {
 
-    VArray  *analyzers;
+    Vector  *analyzers;
 
     inert incremented PolyAnalyzer*
-    new(String *language = NULL, VArray *analyzers = NULL);
+    new(String *language = NULL, Vector *analyzers = NULL);
 
     /**
      * @param language An ISO code from the list of supported languages.
@@ -66,11 +66,11 @@ public class Lucy::Analysis::PolyAnalyzer inherits Lucy::Analysis::Analyzer {
      */
     public inert PolyAnalyzer*
     init(PolyAnalyzer *self, String *language = NULL,
-         VArray *analyzers = NULL);
+         Vector *analyzers = NULL);
 
     /** Getter for "analyzers" member.
      */
-    public VArray*
+    public Vector*
     Get_Analyzers(PolyAnalyzer *self);
 
     public incremented Inversion*

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Highlight/HeatMap.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/HeatMap.c b/core/Lucy/Highlight/HeatMap.c
index 13bf656..62d1b87 100644
--- a/core/Lucy/Highlight/HeatMap.c
+++ b/core/Lucy/Highlight/HeatMap.c
@@ -22,24 +22,24 @@
 #include "Clownfish/Util/SortUtils.h"
 
 HeatMap*
-HeatMap_new(VArray *spans, uint32_t window) {
+HeatMap_new(Vector *spans, uint32_t window) {
     HeatMap *self = (HeatMap*)Class_Make_Obj(HEATMAP);
     return HeatMap_init(self, spans, window);
 }
 
 HeatMap*
-HeatMap_init(HeatMap *self, VArray *spans, uint32_t window) {
+HeatMap_init(HeatMap *self, Vector *spans, uint32_t window) {
     HeatMapIVARS *const ivars = HeatMap_IVARS(self);
-    VArray *spans_copy = VA_Clone(spans);
-    VArray *spans_plus_boosts;
+    Vector *spans_copy = Vec_Clone(spans);
+    Vector *spans_plus_boosts;
 
     ivars->spans  = NULL;
     ivars->window = window;
 
-    VA_Sort(spans_copy);
+    Vec_Sort(spans_copy);
     spans_plus_boosts = HeatMap_Generate_Proximity_Boosts(self, spans_copy);
-    VA_Push_All(spans_plus_boosts, spans_copy);
-    VA_Sort(spans_plus_boosts);
+    Vec_Push_All(spans_plus_boosts, spans_copy);
+    Vec_Sort(spans_plus_boosts);
     ivars->spans = HeatMap_Flatten_Spans(self, spans_plus_boosts);
 
     DECREF(spans_plus_boosts);
@@ -63,14 +63,14 @@ S_compare_i32(void *context, const void *va, const void *vb) {
 
 // Create all the spans needed by HeatMap_Flatten_Spans, based on the source
 // offsets and lengths... but leave the scores at 0.
-static VArray*
-S_flattened_but_empty_spans(VArray *spans) {
-    const uint32_t num_spans = VA_Get_Size(spans);
+static Vector*
+S_flattened_but_empty_spans(Vector *spans) {
+    const uint32_t num_spans = Vec_Get_Size(spans);
     int32_t *bounds = (int32_t*)MALLOCATE((num_spans * 2) * sizeof(int32_t));
 
     // Assemble a list of all unique start/end boundaries.
     for (uint32_t i = 0; i < num_spans; i++) {
-        Span *span            = (Span*)VA_Fetch(spans, i);
+        Span *span            = (Span*)Vec_Fetch(spans, i);
         bounds[i]             = Span_Get_Offset(span);
         bounds[i + num_spans] = Span_Get_Offset(span) + Span_Get_Length(span);
     }
@@ -86,34 +86,34 @@ S_flattened_but_empty_spans(VArray *spans) {
     }
 
     // Create one Span for each zone between two bounds.
-    VArray *flattened = VA_new(num_bounds - 1);
+    Vector *flattened = Vec_new(num_bounds - 1);
     for (uint32_t i = 0; i < num_bounds - 1; i++) {
         int32_t  start   = bounds[i];
         int32_t  length  = bounds[i + 1] - start;
-        VA_Push(flattened, (Obj*)Span_new(start, length, 0.0f));
+        Vec_Push(flattened, (Obj*)Span_new(start, length, 0.0f));
     }
 
     FREEMEM(bounds);
     return flattened;
 }
 
-VArray*
-HeatMap_Flatten_Spans_IMP(HeatMap *self, VArray *spans) {
-    const uint32_t num_spans = VA_Get_Size(spans);
+Vector*
+HeatMap_Flatten_Spans_IMP(HeatMap *self, Vector *spans) {
+    const uint32_t num_spans = Vec_Get_Size(spans);
     UNUSED_VAR(self);
 
     if (!num_spans) {
-        return VA_new(0);
+        return Vec_new(0);
     }
     else {
-        VArray *flattened = S_flattened_but_empty_spans(spans);
-        const uint32_t num_raw_flattened = VA_Get_Size(flattened);
+        Vector *flattened = S_flattened_but_empty_spans(spans);
+        const uint32_t num_raw_flattened = Vec_Get_Size(flattened);
 
         // Iterate over each of the source spans, contributing their scores to
         // any destination span that falls within range.
         uint32_t dest_tick = 0;
         for (uint32_t i = 0; i < num_spans; i++) {
-            Span *source_span = (Span*)VA_Fetch(spans, i);
+            Span *source_span = (Span*)Vec_Fetch(spans, i);
             int32_t source_span_offset = Span_Get_Offset(source_span);
             int32_t source_span_len    = Span_Get_Length(source_span);
             int32_t source_span_end    = source_span_offset + source_span_len;
@@ -121,7 +121,7 @@ HeatMap_Flatten_Spans_IMP(HeatMap *self, VArray *spans) {
             // Get the location of the flattened span that shares the source
             // span's offset.
             for (; dest_tick < num_raw_flattened; dest_tick++) {
-                Span *dest_span = (Span*)VA_Fetch(flattened, dest_tick);
+                Span *dest_span = (Span*)Vec_Fetch(flattened, dest_tick);
                 if (Span_Get_Offset(dest_span) == source_span_offset) {
                     break;
                 }
@@ -129,7 +129,7 @@ HeatMap_Flatten_Spans_IMP(HeatMap *self, VArray *spans) {
 
             // Fill in scores.
             for (uint32_t j = dest_tick; j < num_raw_flattened; j++) {
-                Span *dest_span = (Span*)VA_Fetch(flattened, j);
+                Span *dest_span = (Span*)Vec_Fetch(flattened, j);
                 if (Span_Get_Offset(dest_span) == source_span_end) {
                     break;
                 }
@@ -144,12 +144,12 @@ HeatMap_Flatten_Spans_IMP(HeatMap *self, VArray *spans) {
         // Leave holes instead of spans that don't have any score.
         dest_tick = 0;
         for (uint32_t i = 0; i < num_raw_flattened; i++) {
-            Span *span = (Span*)VA_Fetch(flattened, i);
+            Span *span = (Span*)Vec_Fetch(flattened, i);
             if (Span_Get_Weight(span)) {
-                VA_Store(flattened, dest_tick++, INCREF(span));
+                Vec_Store(flattened, dest_tick++, INCREF(span));
             }
         }
-        VA_Excise(flattened, dest_tick, num_raw_flattened - dest_tick);
+        Vec_Excise(flattened, dest_tick, num_raw_flattened - dest_tick);
 
         return flattened;
     }
@@ -178,17 +178,17 @@ HeatMap_Calc_Proximity_Boost_IMP(HeatMap *self, Span *span1, Span *span2) {
     }
 }
 
-VArray*
-HeatMap_Generate_Proximity_Boosts_IMP(HeatMap *self, VArray *spans) {
-    VArray *boosts = VA_new(0);
-    const uint32_t num_spans = VA_Get_Size(spans);
+Vector*
+HeatMap_Generate_Proximity_Boosts_IMP(HeatMap *self, Vector *spans) {
+    Vector *boosts = Vec_new(0);
+    const uint32_t num_spans = Vec_Get_Size(spans);
 
     if (num_spans > 1) {
         for (uint32_t i = 0, max = num_spans - 1; i < max; i++) {
-            Span *span1 = (Span*)VA_Fetch(spans, i);
+            Span *span1 = (Span*)Vec_Fetch(spans, i);
 
             for (uint32_t j = i + 1; j <= max; j++) {
-                Span *span2 = (Span*)VA_Fetch(spans, j);
+                Span *span2 = (Span*)Vec_Fetch(spans, j);
                 float prox_score
                     = HeatMap_Calc_Proximity_Boost(self, span1, span2);
                 if (prox_score == 0) {
@@ -198,7 +198,7 @@ HeatMap_Generate_Proximity_Boosts_IMP(HeatMap *self, VArray *spans) {
                     int32_t length = Span_Get_Offset(span2)
                                      - Span_Get_Offset(span1)
                                      + Span_Get_Length(span2);
-                    VA_Push(boosts,
+                    Vec_Push(boosts,
                             (Obj*)Span_new(Span_Get_Offset(span1), length,
                                            prox_score));
                 }
@@ -209,7 +209,7 @@ HeatMap_Generate_Proximity_Boosts_IMP(HeatMap *self, VArray *spans) {
     return boosts;
 }
 
-VArray*
+Vector*
 HeatMap_Get_Spans_IMP(HeatMap *self) {
     return HeatMap_IVARS(self)->spans;
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Highlight/HeatMap.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/HeatMap.cfh b/core/Lucy/Highlight/HeatMap.cfh
index 5df3f45..4b66cae 100644
--- a/core/Lucy/Highlight/HeatMap.cfh
+++ b/core/Lucy/Highlight/HeatMap.cfh
@@ -24,11 +24,11 @@ parcel Lucy;
 
 class Lucy::Highlight::HeatMap inherits Clownfish::Obj {
 
-    VArray   *spans;
+    Vector   *spans;
     uint32_t  window;
 
     inert incremented HeatMap*
-    new(VArray *spans, uint32_t window = 133);
+    new(Vector *spans, uint32_t window = 133);
 
     /**
      * @param spans An array of Spans, which need not be sorted and will not
@@ -37,7 +37,7 @@ class Lucy::Highlight::HeatMap inherits Clownfish::Obj {
      * reinforce each other.
      */
     public inert HeatMap*
-    init(HeatMap *self, VArray *spans, uint32_t window = 133);
+    init(HeatMap *self, Vector *spans, uint32_t window = 133);
 
     /** Reduce/slice overlapping spans.  Say we have two spans:
      *
@@ -53,8 +53,8 @@ class Lucy::Highlight::HeatMap inherits Clownfish::Obj {
      * @param spans An array of Spans, which must be sorted by offset then
      * length.
      */
-    incremented VArray*
-    Flatten_Spans(HeatMap *self, VArray *spans);
+    incremented Vector*
+    Flatten_Spans(HeatMap *self, Vector *spans);
 
     /** If the two spans overlap or abut, return a bonus equal to their summed
      * scores; as they move further apart, tail the bonus down until it hits 0
@@ -69,10 +69,10 @@ class Lucy::Highlight::HeatMap inherits Clownfish::Obj {
      * @param spans An array of Spans, which must be sorted by offset then
      * length.
      */
-    incremented VArray*
-    Generate_Proximity_Boosts(HeatMap *self, VArray *spans);
+    incremented Vector*
+    Generate_Proximity_Boosts(HeatMap *self, Vector *spans);
 
-    VArray*
+    Vector*
     Get_Spans(HeatMap *self);
 
     public void

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Highlight/Highlighter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/Highlighter.c b/core/Lucy/Highlight/Highlighter.c
index b0397a1..f090264 100644
--- a/core/Lucy/Highlight/Highlighter.c
+++ b/core/Lucy/Highlight/Highlighter.c
@@ -166,11 +166,11 @@ Highlighter_Create_Excerpt_IMP(Highlighter *self, HitDoc *hit_doc) {
         DocVector *doc_vec
             = Searcher_Fetch_Doc_Vec(ivars->searcher,
                                      HitDoc_Get_Doc_ID(hit_doc));
-        VArray *maybe_spans
+        Vector *maybe_spans
             = Compiler_Highlight_Spans(ivars->compiler, ivars->searcher,
                                        doc_vec, ivars->field);
-        VArray *score_spans = maybe_spans ? maybe_spans : VA_new(0);
-        VA_Sort(score_spans);
+        Vector *score_spans = maybe_spans ? maybe_spans : Vec_new(0);
+        Vec_Sort(score_spans);
         HeatMap *heat_map
             = HeatMap_new(score_spans, (ivars->excerpt_length * 2) / 3);
 
@@ -197,9 +197,9 @@ static int32_t
 S_hottest(HeatMap *heat_map) {
     float max_score = 0.0f;
     int32_t retval = 0;
-    VArray *spans = HeatMap_Get_Spans(heat_map);
-    for (uint32_t i = VA_Get_Size(spans); i--;) {
-        Span *span = (Span*)VA_Fetch(spans, i);
+    Vector *spans = HeatMap_Get_Spans(heat_map);
+    for (uint32_t i = Vec_Get_Size(spans); i--;) {
+        Span *span = (Span*)Vec_Fetch(spans, i);
         if (Span_Get_Weight(span) >= max_score) {
             retval = Span_Get_Offset(span);
             max_score = Span_Get_Weight(span);
@@ -465,7 +465,7 @@ Highlighter_Raw_Excerpt_IMP(Highlighter *self, String *field_val,
 }
 
 String*
-Highlighter_Highlight_Excerpt_IMP(Highlighter *self, VArray *spans,
+Highlighter_Highlight_Excerpt_IMP(Highlighter *self, Vector *spans,
                                   String *raw_excerpt, int32_t top) {
     int32_t         hl_start        = 0;
     int32_t         hl_end          = 0;
@@ -475,8 +475,8 @@ Highlighter_Highlight_Excerpt_IMP(Highlighter *self, VArray *spans,
     CharBuf        *encode_buf      = NULL;
     int32_t         raw_excerpt_end = top + Str_Length(raw_excerpt);
 
-    for (uint32_t i = 0, max = VA_Get_Size(spans); i < max; i++) {
-        Span *span = (Span*)VA_Fetch(spans, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(spans); i < max; i++) {
+        Span *span = (Span*)Vec_Fetch(spans, i);
         int32_t offset = Span_Get_Offset(span);
         if (offset < top) {
             continue;

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Highlight/Highlighter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Highlight/Highlighter.cfh b/core/Lucy/Highlight/Highlighter.cfh
index bfeaae3..d1a80a9 100644
--- a/core/Lucy/Highlight/Highlighter.cfh
+++ b/core/Lucy/Highlight/Highlighter.cfh
@@ -136,7 +136,7 @@ public class Lucy::Highlight::Highlighter inherits Clownfish::Obj {
      * (Helper function for Create_Excerpt only exposed for testing purposes.)
      */
     String*
-    Highlight_Excerpt(Highlighter *self, VArray *spans, String *raw_excerpt,
+    Highlight_Excerpt(Highlighter *self, Vector *spans, String *raw_excerpt,
                       int32_t top);
 
     public void

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/BackgroundMerger.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/BackgroundMerger.c b/core/Lucy/Index/BackgroundMerger.c
index 93b4996..d4a0bed 100644
--- a/core/Lucy/Index/BackgroundMerger.c
+++ b/core/Lucy/Index/BackgroundMerger.c
@@ -125,10 +125,10 @@ BGMerger_init(BackgroundMerger *self, Obj *index, IndexManager *manager) {
     // Create new Segment.
     int64_t new_seg_num
         = IxManager_Highest_Seg_Num(ivars->manager, ivars->snapshot) + 1;
-    VArray *fields = Schema_All_Fields(ivars->schema);
+    Vector *fields = Schema_All_Fields(ivars->schema);
     ivars->segment = Seg_new(new_seg_num);
-    for (uint32_t i = 0, max = VA_Get_Size(fields); i < max; i++) {
-        Seg_Add_Field(ivars->segment, (String*)VA_Fetch(fields, i));
+    for (uint32_t i = 0, max = Vec_Get_Size(fields); i < max; i++) {
+        Seg_Add_Field(ivars->segment, (String*)Vec_Fetch(fields, i));
     }
     DECREF(fields);
 
@@ -206,14 +206,14 @@ BGMerger_Optimize_IMP(BackgroundMerger *self) {
 static uint32_t
 S_maybe_merge(BackgroundMerger *self) {
     BackgroundMergerIVARS *const ivars = BGMerger_IVARS(self);
-    VArray *to_merge = IxManager_Recycle(ivars->manager, ivars->polyreader,
+    Vector *to_merge = IxManager_Recycle(ivars->manager, ivars->polyreader,
                                          ivars->del_writer, 0, ivars->optimize);
-    int32_t num_to_merge = VA_Get_Size(to_merge);
+    int32_t num_to_merge = Vec_Get_Size(to_merge);
 
     // There's no point in merging one segment if it has no deletions, because
     // we'd just be rewriting it. */
     if (num_to_merge == 1) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(to_merge, 0);
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(to_merge, 0);
         if (!SegReader_Del_Count(seg_reader)) {
             DECREF(to_merge);
             return 0;
@@ -229,7 +229,7 @@ S_maybe_merge(BackgroundMerger *self) {
 
     // Consolidate segments.
     for (uint32_t i = 0, max = num_to_merge; i < max; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(to_merge, i);
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(to_merge, i);
         String    *seg_name   = SegReader_Get_Seg_Name(seg_reader);
         int64_t    doc_count  = Seg_Get_Count(ivars->segment);
         Matcher *deletions
@@ -255,20 +255,20 @@ S_merge_updated_deletions(BackgroundMerger *self) {
 
     PolyReader *new_polyreader
         = PolyReader_open((Obj*)ivars->folder, NULL, NULL);
-    VArray *new_seg_readers
+    Vector *new_seg_readers
         = PolyReader_Get_Seg_Readers(new_polyreader);
-    VArray *old_seg_readers
+    Vector *old_seg_readers
         = PolyReader_Get_Seg_Readers(ivars->polyreader);
-    Hash *new_segs = Hash_new(VA_Get_Size(new_seg_readers));
+    Hash *new_segs = Hash_new(Vec_Get_Size(new_seg_readers));
 
-    for (uint32_t i = 0, max = VA_Get_Size(new_seg_readers); i < max; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(new_seg_readers, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(new_seg_readers); i < max; i++) {
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(new_seg_readers, i);
         String    *seg_name   = SegReader_Get_Seg_Name(seg_reader);
         Hash_Store(new_segs, seg_name, INCREF(seg_reader));
     }
 
-    for (uint32_t i = 0, max = VA_Get_Size(old_seg_readers); i < max; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(old_seg_readers, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(old_seg_readers); i < max; i++) {
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(old_seg_readers, i);
         String    *seg_name   = SegReader_Get_Seg_Name(seg_reader);
 
         // If this segment was merged away...
@@ -303,7 +303,7 @@ S_merge_updated_deletions(BackgroundMerger *self) {
     else {
         PolyReader *merge_polyreader
             = PolyReader_open((Obj*)ivars->folder, ivars->snapshot, NULL);
-        VArray *merge_seg_readers
+        Vector *merge_seg_readers
             = PolyReader_Get_Seg_Readers(merge_polyreader);
         Snapshot *latest_snapshot
             = Snapshot_Read_File(Snapshot_new(), ivars->folder, NULL);
@@ -319,9 +319,9 @@ S_merge_updated_deletions(BackgroundMerger *self) {
 
         SegWriter_Prep_Seg_Dir(seg_writer);
 
-        for (uint32_t i = 0, max = VA_Get_Size(merge_seg_readers); i < max; i++) {
+        for (uint32_t i = 0, max = Vec_Get_Size(merge_seg_readers); i < max; i++) {
             SegReader *seg_reader
-                = (SegReader*)VA_Fetch(merge_seg_readers, i);
+                = (SegReader*)Vec_Fetch(merge_seg_readers, i);
             if (SegReader_Get_Seg_Num(seg_reader) == merge_seg_num) {
                 I32Array *offsets = PolyReader_Offsets(merge_polyreader);
                 seg_tick = i;
@@ -371,8 +371,8 @@ S_merge_updated_deletions(BackgroundMerger *self) {
 void
 BGMerger_Prepare_Commit_IMP(BackgroundMerger *self) {
     BackgroundMergerIVARS *const ivars = BGMerger_IVARS(self);
-    VArray   *seg_readers     = PolyReader_Get_Seg_Readers(ivars->polyreader);
-    uint32_t  num_seg_readers = VA_Get_Size(seg_readers);
+    Vector   *seg_readers     = PolyReader_Get_Seg_Readers(ivars->polyreader);
+    uint32_t  num_seg_readers = Vec_Get_Size(seg_readers);
     uint32_t  segs_merged     = 0;
 
     if (ivars->prepared) {
@@ -442,9 +442,9 @@ BGMerger_Prepare_Commit_IMP(BackgroundMerger *self) {
             // Add the fresh content to our snapshot. (It's important to
             // run this AFTER S_merge_updated_deletions, because otherwise
             // we couldn't tell whether the deletion counts changed.)
-            VArray *files = Snapshot_List(latest_snapshot);
-            for (uint32_t i = 0, max = VA_Get_Size(files); i < max; i++) {
-                String *file = (String*)VA_Fetch(files, i);
+            Vector *files = Snapshot_List(latest_snapshot);
+            for (uint32_t i = 0, max = Vec_Get_Size(files); i < max; i++) {
+                String *file = (String*)Vec_Fetch(files, i);
                 if (Str_Starts_With_Utf8(file, "seg_", 4)) {
                     int64_t gen = (int64_t)IxFileNames_extract_gen(file);
                     if (gen > ivars->cutoff) {

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DataReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataReader.c b/core/Lucy/Index/DataReader.c
index 4a2879a..f2469c9 100644
--- a/core/Lucy/Index/DataReader.c
+++ b/core/Lucy/Index/DataReader.c
@@ -25,12 +25,12 @@
 
 DataReader*
 DataReader_init(DataReader *self, Schema *schema, Folder *folder,
-                Snapshot *snapshot, VArray *segments, int32_t seg_tick) {
+                Snapshot *snapshot, Vector *segments, int32_t seg_tick) {
     DataReaderIVARS *const ivars = DataReader_IVARS(self);
     ivars->schema   = (Schema*)INCREF(schema);
     ivars->folder   = (Folder*)INCREF(folder);
     ivars->snapshot = (Snapshot*)INCREF(snapshot);
-    ivars->segments = (VArray*)INCREF(segments);
+    ivars->segments = (Vector*)INCREF(segments);
     ivars->seg_tick = seg_tick;
     if (seg_tick != -1) {
         if (!segments) {
@@ -38,7 +38,7 @@ DataReader_init(DataReader *self, Schema *schema, Folder *folder,
                   seg_tick);
         }
         else {
-            Segment *segment = (Segment*)VA_Fetch(segments, seg_tick);
+            Segment *segment = (Segment*)Vec_Fetch(segments, seg_tick);
             if (!segment) {
                 THROW(ERR, "No segment at seg_tick %i32", seg_tick);
             }
@@ -79,7 +79,7 @@ DataReader_Get_Snapshot_IMP(DataReader *self) {
     return DataReader_IVARS(self)->snapshot;
 }
 
-VArray*
+Vector*
 DataReader_Get_Segments_IMP(DataReader *self) {
     return DataReader_IVARS(self)->segments;
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DataReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DataReader.cfh b/core/Lucy/Index/DataReader.cfh
index 2000d95..38d6259 100644
--- a/core/Lucy/Index/DataReader.cfh
+++ b/core/Lucy/Index/DataReader.cfh
@@ -28,7 +28,7 @@ public class Lucy::Index::DataReader inherits Clownfish::Obj {
     Schema      *schema;
     Folder      *folder;
     Snapshot    *snapshot;
-    VArray      *segments;
+    Vector      *segments;
     Segment     *segment;
     int32_t      seg_tick;
 
@@ -44,7 +44,7 @@ public class Lucy::Index::DataReader inherits Clownfish::Obj {
      */
     public inert DataReader*
     init(DataReader *self, Schema *schema = NULL, Folder *folder = NULL,
-         Snapshot *snapshot = NULL, VArray *segments = NULL,
+         Snapshot *snapshot = NULL, Vector *segments = NULL,
          int32_t seg_tick = -1);
 
     /** Create a reader which aggregates the output of several lower level
@@ -54,7 +54,7 @@ public class Lucy::Index::DataReader inherits Clownfish::Obj {
      * @param offsets Doc id start offsets for each reader.
      */
     public abstract incremented nullable DataReader*
-    Aggregator(DataReader *self, VArray *readers, I32Array *offsets);
+    Aggregator(DataReader *self, Vector *readers, I32Array *offsets);
 
     /** Accessor for "schema" member var.
      */
@@ -73,7 +73,7 @@ public class Lucy::Index::DataReader inherits Clownfish::Obj {
 
     /** Accessor for "segments" member var.
      */
-    public nullable VArray*
+    public nullable Vector*
     Get_Segments(DataReader *self);
 
     /** Accessor for "segment" member var.

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DeletionsReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsReader.c b/core/Lucy/Index/DeletionsReader.c
index 08f466e..5c1ed67 100644
--- a/core/Lucy/Index/DeletionsReader.c
+++ b/core/Lucy/Index/DeletionsReader.c
@@ -33,7 +33,7 @@
 
 DeletionsReader*
 DelReader_init(DeletionsReader *self, Schema *schema, Folder *folder,
-               Snapshot *snapshot, VArray *segments, int32_t seg_tick) {
+               Snapshot *snapshot, Vector *segments, int32_t seg_tick) {
     DataReader_init((DataReader*)self, schema, folder, snapshot, segments,
                     seg_tick);
     ABSTRACT_CLASS_CHECK(self, DELETIONSREADER);
@@ -41,31 +41,31 @@ DelReader_init(DeletionsReader *self, Schema *schema, Folder *folder,
 }
 
 DeletionsReader*
-DelReader_Aggregator_IMP(DeletionsReader *self, VArray *readers,
+DelReader_Aggregator_IMP(DeletionsReader *self, Vector *readers,
                          I32Array *offsets) {
     UNUSED_VAR(self);
     return (DeletionsReader*)PolyDelReader_new(readers, offsets);
 }
 
 PolyDeletionsReader*
-PolyDelReader_new(VArray *readers, I32Array *offsets) {
+PolyDelReader_new(Vector *readers, I32Array *offsets) {
     PolyDeletionsReader *self
         = (PolyDeletionsReader*)Class_Make_Obj(POLYDELETIONSREADER);
     return PolyDelReader_init(self, readers, offsets);
 }
 
 PolyDeletionsReader*
-PolyDelReader_init(PolyDeletionsReader *self, VArray *readers,
+PolyDelReader_init(PolyDeletionsReader *self, Vector *readers,
                    I32Array *offsets) {
     DelReader_init((DeletionsReader*)self, NULL, NULL, NULL, NULL, -1);
     PolyDeletionsReaderIVARS *const ivars = PolyDelReader_IVARS(self);
     ivars->del_count = 0;
-    for (uint32_t i = 0, max = VA_Get_Size(readers); i < max; i++) {
+    for (uint32_t i = 0, max = Vec_Get_Size(readers); i < max; i++) {
         DeletionsReader *reader = (DeletionsReader*)CERTIFY(
-                                      VA_Fetch(readers, i), DELETIONSREADER);
+                                      Vec_Fetch(readers, i), DELETIONSREADER);
         ivars->del_count += DelReader_Del_Count(reader);
     }
-    ivars->readers = (VArray*)INCREF(readers);
+    ivars->readers = (Vector*)INCREF(readers);
     ivars->offsets = (I32Array*)INCREF(offsets);
     return self;
 }
@@ -74,12 +74,12 @@ void
 PolyDelReader_Close_IMP(PolyDeletionsReader *self) {
     PolyDeletionsReaderIVARS *const ivars = PolyDelReader_IVARS(self);
     if (ivars->readers) {
-        for (uint32_t i = 0, max = VA_Get_Size(ivars->readers); i < max; i++) {
+        for (uint32_t i = 0, max = Vec_Get_Size(ivars->readers); i < max; i++) {
             DeletionsReader *reader
-                = (DeletionsReader*)VA_Fetch(ivars->readers, i);
+                = (DeletionsReader*)Vec_Fetch(ivars->readers, i);
             if (reader) { DelReader_Close(reader); }
         }
-        VA_Clear(ivars->readers);
+        Vec_Clear(ivars->readers);
     }
 }
 
@@ -101,13 +101,13 @@ PolyDelReader_Iterator_IMP(PolyDeletionsReader *self) {
     PolyDeletionsReaderIVARS *const ivars = PolyDelReader_IVARS(self);
     SeriesMatcher *deletions = NULL;
     if (ivars->del_count) {
-        uint32_t num_readers = VA_Get_Size(ivars->readers);
-        VArray *matchers = VA_new(num_readers);
+        uint32_t num_readers = Vec_Get_Size(ivars->readers);
+        Vector *matchers = Vec_new(num_readers);
         for (uint32_t i = 0; i < num_readers; i++) {
             DeletionsReader *reader
-                = (DeletionsReader*)VA_Fetch(ivars->readers, i);
+                = (DeletionsReader*)Vec_Fetch(ivars->readers, i);
             Matcher *matcher = DelReader_Iterator(reader);
-            if (matcher) { VA_Store(matchers, i, (Obj*)matcher); }
+            if (matcher) { Vec_Store(matchers, i, (Obj*)matcher); }
         }
         deletions = SeriesMatcher_new(matchers, ivars->offsets);
         DECREF(matchers);
@@ -117,7 +117,7 @@ PolyDelReader_Iterator_IMP(PolyDeletionsReader *self) {
 
 DefaultDeletionsReader*
 DefDelReader_new(Schema *schema, Folder *folder, Snapshot *snapshot,
-                 VArray *segments, int32_t seg_tick) {
+                 Vector *segments, int32_t seg_tick) {
     DefaultDeletionsReader *self
         = (DefaultDeletionsReader*)Class_Make_Obj(DEFAULTDELETIONSREADER);
     return DefDelReader_init(self, schema, folder, snapshot, segments,
@@ -126,7 +126,7 @@ DefDelReader_new(Schema *schema, Folder *folder, Snapshot *snapshot,
 
 DefaultDeletionsReader*
 DefDelReader_init(DefaultDeletionsReader *self, Schema *schema,
-                  Folder *folder, Snapshot *snapshot, VArray *segments,
+                  Folder *folder, Snapshot *snapshot, Vector *segments,
                   int32_t seg_tick) {
     DelReader_init((DeletionsReader*)self, schema, folder, snapshot, segments,
                    seg_tick);
@@ -156,7 +156,7 @@ DefDelReader_Destroy_IMP(DefaultDeletionsReader *self) {
 BitVector*
 DefDelReader_Read_Deletions_IMP(DefaultDeletionsReader *self) {
     DefaultDeletionsReaderIVARS *const ivars = DefDelReader_IVARS(self);
-    VArray  *segments    = DefDelReader_Get_Segments(self);
+    Vector  *segments    = DefDelReader_Get_Segments(self);
     Segment *segment     = DefDelReader_Get_Segment(self);
     String  *my_seg_name = Seg_Get_Name(segment);
     String  *del_file    = NULL;
@@ -165,8 +165,8 @@ DefDelReader_Read_Deletions_IMP(DefaultDeletionsReader *self) {
     // Start with deletions files in the most recently added segments and work
     // backwards.  The first one we find which addresses our segment is the
     // one we need.
-    for (int32_t i = VA_Get_Size(segments) - 1; i >= 0; i--) {
-        Segment *other_seg = (Segment*)VA_Fetch(segments, i);
+    for (int32_t i = Vec_Get_Size(segments) - 1; i >= 0; i--) {
+        Segment *other_seg = (Segment*)Vec_Fetch(segments, i);
         Hash *metadata
             = (Hash*)Seg_Fetch_Metadata_Utf8(other_seg, "deletions", 9);
         if (metadata) {

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DeletionsReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsReader.cfh b/core/Lucy/Index/DeletionsReader.cfh
index 5e82331..c1db617 100644
--- a/core/Lucy/Index/DeletionsReader.cfh
+++ b/core/Lucy/Index/DeletionsReader.cfh
@@ -21,7 +21,7 @@ class Lucy::Index::DeletionsReader nickname DelReader
 
     inert DeletionsReader*
     init(DeletionsReader *self, Schema *schema = NULL, Folder *folder = NULL,
-         Snapshot *snapshot = NULL, VArray *segments = NULL,
+         Snapshot *snapshot = NULL, Vector *segments = NULL,
          int32_t seg_tick = -1);
 
     /** Return the number of docs which have been marked as deleted in this
@@ -37,21 +37,21 @@ class Lucy::Index::DeletionsReader nickname DelReader
     Iterator(DeletionsReader *self);
 
     public incremented nullable DeletionsReader*
-    Aggregator(DeletionsReader *self, VArray *readers, I32Array *offsets);
+    Aggregator(DeletionsReader *self, Vector *readers, I32Array *offsets);
 }
 
 class Lucy::Index::PolyDeletionsReader nickname PolyDelReader
     inherits Lucy::Index::DeletionsReader {
 
-    VArray   *readers;
+    Vector   *readers;
     I32Array *offsets;
     int32_t   del_count;
 
     inert incremented PolyDeletionsReader*
-    new(VArray *readers, I32Array *offsets);
+    new(Vector *readers, I32Array *offsets);
 
     inert PolyDeletionsReader*
-    init(PolyDeletionsReader *self, VArray *readers, I32Array *offsets);
+    init(PolyDeletionsReader *self, Vector *readers, I32Array *offsets);
 
     int32_t
     Del_Count(PolyDeletionsReader *self);
@@ -73,12 +73,12 @@ class Lucy::Index::DefaultDeletionsReader nickname DefDelReader
     int32_t    del_count;
 
     inert incremented DefaultDeletionsReader*
-    new(Schema *schema, Folder *folder, Snapshot *snapshot, VArray *segments,
+    new(Schema *schema, Folder *folder, Snapshot *snapshot, Vector *segments,
         int32_t seg_tick);
 
     inert DefaultDeletionsReader*
     init(DefaultDeletionsReader *self, Schema *schema, Folder *folder,
-         Snapshot *snapshot, VArray *segments, int32_t seg_tick);
+         Snapshot *snapshot, Vector *segments, int32_t seg_tick);
 
     int32_t
     Del_Count(DefaultDeletionsReader *self);

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DeletionsWriter.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsWriter.c b/core/Lucy/Index/DeletionsWriter.c
index 9e088c7..2d93bab 100644
--- a/core/Lucy/Index/DeletionsWriter.c
+++ b/core/Lucy/Index/DeletionsWriter.c
@@ -85,16 +85,16 @@ DefDelWriter_init(DefaultDeletionsWriter *self, Schema *schema,
     DataWriter_init((DataWriter*)self, schema, snapshot, segment, polyreader);
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     ivars->seg_readers          = PolyReader_Seg_Readers(polyreader);
-    uint32_t num_seg_readers    = VA_Get_Size(ivars->seg_readers);
+    uint32_t num_seg_readers    = Vec_Get_Size(ivars->seg_readers);
     ivars->seg_starts           = PolyReader_Offsets(polyreader);
-    ivars->bit_vecs             = VA_new(num_seg_readers);
+    ivars->bit_vecs             = Vec_new(num_seg_readers);
     ivars->updated              = (bool*)CALLOCATE(num_seg_readers, sizeof(bool));
     ivars->searcher             = IxSearcher_new((Obj*)polyreader);
     ivars->name_to_tick         = Hash_new(num_seg_readers);
 
     // Materialize a BitVector of deletions for each segment.
     for (uint32_t i = 0; i < num_seg_readers; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->seg_readers, i);
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(ivars->seg_readers, i);
         BitVector *bit_vec    = BitVec_new(SegReader_Doc_Max(seg_reader));
         DeletionsReader *del_reader
             = (DeletionsReader*)SegReader_Fetch(
@@ -110,7 +110,7 @@ DefDelWriter_init(DefaultDeletionsWriter *self, Schema *schema,
             }
             DECREF(seg_dels);
         }
-        VA_Store(ivars->bit_vecs, i, (Obj*)bit_vec);
+        Vec_Store(ivars->bit_vecs, i, (Obj*)bit_vec);
         Hash_Store(ivars->name_to_tick,
                    SegReader_Get_Seg_Name(seg_reader),
                    (Obj*)Int32_new(i));
@@ -144,10 +144,10 @@ DefDelWriter_Finish_IMP(DefaultDeletionsWriter *self) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     Folder *const folder = ivars->folder;
 
-    for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->seg_readers, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(ivars->seg_readers); i < max; i++) {
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(ivars->seg_readers, i);
         if (ivars->updated[i]) {
-            BitVector *deldocs   = (BitVector*)VA_Fetch(ivars->bit_vecs, i);
+            BitVector *deldocs   = (BitVector*)Vec_Fetch(ivars->bit_vecs, i);
             int32_t    doc_max   = SegReader_Doc_Max(seg_reader);
             double     used      = (doc_max + 1) / 8.0;
             uint32_t   byte_size = (uint32_t)ceil(used);
@@ -182,10 +182,10 @@ DefDelWriter_Metadata_IMP(DefaultDeletionsWriter *self) {
     Hash    *const metadata = super_meta(self);
     Hash    *const files    = Hash_new(0);
 
-    for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->seg_readers, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(ivars->seg_readers); i < max; i++) {
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(ivars->seg_readers, i);
         if (ivars->updated[i]) {
-            BitVector *deldocs   = (BitVector*)VA_Fetch(ivars->bit_vecs, i);
+            BitVector *deldocs   = (BitVector*)Vec_Fetch(ivars->bit_vecs, i);
             Segment   *segment   = SegReader_Get_Segment(seg_reader);
             Hash      *mini_meta = Hash_new(2);
             Hash_Store_Utf8(mini_meta, "count", 5,
@@ -217,7 +217,7 @@ DefDelWriter_Seg_Deletions_IMP(DefaultDeletionsWriter *self,
                                                    seg_name);
     int32_t tick          = tick_obj ? Int32_Get_Value(tick_obj) : 0;
     SegReader *candidate  = tick_obj
-                            ? (SegReader*)VA_Fetch(ivars->seg_readers, tick)
+                            ? (SegReader*)Vec_Fetch(ivars->seg_readers, tick)
                             : NULL;
 
     if (tick_obj) {
@@ -225,7 +225,7 @@ DefDelWriter_Seg_Deletions_IMP(DefaultDeletionsWriter *self,
             = (DeletionsReader*)SegReader_Obtain(
                   candidate, Class_Get_Name(DELETIONSREADER));
         if (ivars->updated[tick] || DelReader_Del_Count(del_reader)) {
-            BitVector *deldocs = (BitVector*)VA_Fetch(ivars->bit_vecs, tick);
+            BitVector *deldocs = (BitVector*)Vec_Fetch(ivars->bit_vecs, tick);
             deletions = (Matcher*)BitVecMatcher_new(deldocs);
         }
     }
@@ -243,7 +243,7 @@ DefDelWriter_Seg_Del_Count_IMP(DefaultDeletionsWriter *self,
     Integer32 *tick
         = (Integer32*)Hash_Fetch(ivars->name_to_tick, seg_name);
     BitVector *deldocs = tick
-                         ? (BitVector*)VA_Fetch(ivars->bit_vecs, Int32_Get_Value(tick))
+                         ? (BitVector*)Vec_Fetch(ivars->bit_vecs, Int32_Get_Value(tick))
                          : NULL;
     return deldocs ? BitVec_Count(deldocs) : 0;
 }
@@ -252,12 +252,12 @@ void
 DefDelWriter_Delete_By_Term_IMP(DefaultDeletionsWriter *self,
                                 String *field, Obj *term) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
-    for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->seg_readers, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(ivars->seg_readers); i < max; i++) {
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(ivars->seg_readers, i);
         PostingListReader *plist_reader
             = (PostingListReader*)SegReader_Fetch(
                   seg_reader, Class_Get_Name(POSTINGLISTREADER));
-        BitVector *bit_vec = (BitVector*)VA_Fetch(ivars->bit_vecs, i);
+        BitVector *bit_vec = (BitVector*)Vec_Fetch(ivars->bit_vecs, i);
         PostingList *plist = plist_reader
                              ? PListReader_Posting_List(plist_reader, field, term)
                              : NULL;
@@ -282,9 +282,9 @@ DefDelWriter_Delete_By_Query_IMP(DefaultDeletionsWriter *self, Query *query) {
     Compiler *compiler = Query_Make_Compiler(query, (Searcher*)ivars->searcher,
                                              Query_Get_Boost(query), false);
 
-    for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(ivars->seg_readers, i);
-        BitVector *bit_vec = (BitVector*)VA_Fetch(ivars->bit_vecs, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(ivars->seg_readers); i < max; i++) {
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(ivars->seg_readers, i);
+        BitVector *bit_vec = (BitVector*)Vec_Fetch(ivars->bit_vecs, i);
         Matcher *matcher = Compiler_Make_Matcher(compiler, seg_reader, false);
 
         if (matcher) {
@@ -309,7 +309,7 @@ void
 DefDelWriter_Delete_By_Doc_ID_IMP(DefaultDeletionsWriter *self, int32_t doc_id) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
     uint32_t   sub_tick   = PolyReader_sub_tick(ivars->seg_starts, doc_id);
-    BitVector *bit_vec    = (BitVector*)VA_Fetch(ivars->bit_vecs, sub_tick);
+    BitVector *bit_vec    = (BitVector*)Vec_Fetch(ivars->bit_vecs, sub_tick);
     uint32_t   offset     = I32Arr_Get(ivars->seg_starts, sub_tick);
     int32_t    seg_doc_id = doc_id - offset;
 
@@ -322,7 +322,7 @@ DefDelWriter_Delete_By_Doc_ID_IMP(DefaultDeletionsWriter *self, int32_t doc_id)
 bool
 DefDelWriter_Updated_IMP(DefaultDeletionsWriter *self) {
     DefaultDeletionsWriterIVARS *const ivars = DefDelWriter_IVARS(self);
-    for (uint32_t i = 0, max = VA_Get_Size(ivars->seg_readers); i < max; i++) {
+    for (uint32_t i = 0, max = Vec_Get_Size(ivars->seg_readers); i < max; i++) {
         if (ivars->updated[i]) { return true; }
     }
     return false;
@@ -348,7 +348,7 @@ DefDelWriter_Merge_Segment_IMP(DefaultDeletionsWriter *self,
     Hash *del_meta = (Hash*)Seg_Fetch_Metadata_Utf8(segment, "deletions", 9);
 
     if (del_meta) {
-        VArray *seg_readers = ivars->seg_readers;
+        Vector *seg_readers = ivars->seg_readers;
         Hash   *files = (Hash*)Hash_Fetch_Utf8(del_meta, "files", 5);
         if (files) {
             HashIterator *iter = HashIter_new(files);
@@ -360,9 +360,9 @@ DefDelWriter_Merge_Segment_IMP(DefaultDeletionsWriter *self,
                  * we're adding correspond to.  If it's gone, we don't
                  * need to worry about losing deletions files that point
                  * at it. */
-                for (uint32_t i = 0, max = VA_Get_Size(seg_readers); i < max; i++) {
+                for (uint32_t i = 0, max = Vec_Get_Size(seg_readers); i < max; i++) {
                     SegReader *candidate
-                        = (SegReader*)VA_Fetch(seg_readers, i);
+                        = (SegReader*)Vec_Fetch(seg_readers, i);
                     String *candidate_name
                         = Seg_Get_Name(SegReader_Get_Segment(candidate));
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DeletionsWriter.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DeletionsWriter.cfh b/core/Lucy/Index/DeletionsWriter.cfh
index cfd2200..e1e4795 100644
--- a/core/Lucy/Index/DeletionsWriter.cfh
+++ b/core/Lucy/Index/DeletionsWriter.cfh
@@ -100,10 +100,10 @@ public abstract class Lucy::Index::DeletionsWriter nickname DelWriter
 class Lucy::Index::DefaultDeletionsWriter nickname DefDelWriter
     inherits Lucy::Index::DeletionsWriter {
 
-    VArray        *seg_readers;
+    Vector        *seg_readers;
     Hash          *name_to_tick;
     I32Array      *seg_starts;
-    VArray        *bit_vecs;
+    Vector        *bit_vecs;
     bool          *updated;
     IndexSearcher *searcher;
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DocReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocReader.c b/core/Lucy/Index/DocReader.c
index 76b9c64..0df3798 100644
--- a/core/Lucy/Index/DocReader.c
+++ b/core/Lucy/Index/DocReader.c
@@ -31,32 +31,32 @@
 
 DocReader*
 DocReader_init(DocReader *self, Schema *schema, Folder *folder,
-               Snapshot *snapshot, VArray *segments, int32_t seg_tick) {
+               Snapshot *snapshot, Vector *segments, int32_t seg_tick) {
     return (DocReader*)DataReader_init((DataReader*)self, schema, folder,
                                        snapshot, segments, seg_tick);
 }
 
 DocReader*
-DocReader_Aggregator_IMP(DocReader *self, VArray *readers,
+DocReader_Aggregator_IMP(DocReader *self, Vector *readers,
                          I32Array *offsets) {
     UNUSED_VAR(self);
     return (DocReader*)PolyDocReader_new(readers, offsets);
 }
 
 PolyDocReader*
-PolyDocReader_new(VArray *readers, I32Array *offsets) {
+PolyDocReader_new(Vector *readers, I32Array *offsets) {
     PolyDocReader *self = (PolyDocReader*)Class_Make_Obj(POLYDOCREADER);
     return PolyDocReader_init(self, readers, offsets);
 }
 
 PolyDocReader*
-PolyDocReader_init(PolyDocReader *self, VArray *readers, I32Array *offsets) {
+PolyDocReader_init(PolyDocReader *self, Vector *readers, I32Array *offsets) {
     DocReader_init((DocReader*)self, NULL, NULL, NULL, NULL, -1);
     PolyDocReaderIVARS *const ivars = PolyDocReader_IVARS(self);
-    for (uint32_t i = 0, max = VA_Get_Size(readers); i < max; i++) {
-        CERTIFY(VA_Fetch(readers, i), DOCREADER);
+    for (uint32_t i = 0, max = Vec_Get_Size(readers); i < max; i++) {
+        CERTIFY(Vec_Fetch(readers, i), DOCREADER);
     }
-    ivars->readers = (VArray*)INCREF(readers);
+    ivars->readers = (Vector*)INCREF(readers);
     ivars->offsets = (I32Array*)INCREF(offsets);
     return self;
 }
@@ -65,11 +65,11 @@ void
 PolyDocReader_Close_IMP(PolyDocReader *self) {
     PolyDocReaderIVARS *const ivars = PolyDocReader_IVARS(self);
     if (ivars->readers) {
-        for (uint32_t i = 0, max = VA_Get_Size(ivars->readers); i < max; i++) {
-            DocReader *reader = (DocReader*)VA_Fetch(ivars->readers, i);
+        for (uint32_t i = 0, max = Vec_Get_Size(ivars->readers); i < max; i++) {
+            DocReader *reader = (DocReader*)Vec_Fetch(ivars->readers, i);
             if (reader) { DocReader_Close(reader); }
         }
-        VA_Clear(ivars->readers);
+        Vec_Clear(ivars->readers);
     }
 }
 
@@ -86,7 +86,7 @@ PolyDocReader_Fetch_Doc_IMP(PolyDocReader *self, int32_t doc_id) {
     PolyDocReaderIVARS *const ivars = PolyDocReader_IVARS(self);
     uint32_t seg_tick = PolyReader_sub_tick(ivars->offsets, doc_id);
     int32_t  offset   = I32Arr_Get(ivars->offsets, seg_tick);
-    DocReader *doc_reader = (DocReader*)VA_Fetch(ivars->readers, seg_tick);
+    DocReader *doc_reader = (DocReader*)Vec_Fetch(ivars->readers, seg_tick);
     HitDoc *hit_doc = NULL;
     if (!doc_reader) {
         THROW(ERR, "Invalid doc_id: %i32", doc_id);
@@ -100,7 +100,7 @@ PolyDocReader_Fetch_Doc_IMP(PolyDocReader *self, int32_t doc_id) {
 
 DefaultDocReader*
 DefDocReader_new(Schema *schema, Folder *folder, Snapshot *snapshot,
-                 VArray *segments, int32_t seg_tick) {
+                 Vector *segments, int32_t seg_tick) {
     DefaultDocReader *self
         = (DefaultDocReader*)Class_Make_Obj(DEFAULTDOCREADER);
     return DefDocReader_init(self, schema, folder, snapshot, segments,
@@ -132,7 +132,7 @@ DefDocReader_Destroy_IMP(DefaultDocReader *self) {
 
 DefaultDocReader*
 DefDocReader_init(DefaultDocReader *self, Schema *schema, Folder *folder,
-                  Snapshot *snapshot, VArray *segments, int32_t seg_tick) {
+                  Snapshot *snapshot, Vector *segments, int32_t seg_tick) {
     Hash *metadata;
     Segment *segment;
     DocReader_init((DocReader*)self, schema, folder, snapshot, segments,

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DocReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocReader.cfh b/core/Lucy/Index/DocReader.cfh
index 57c5f63..8de9c6e 100644
--- a/core/Lucy/Index/DocReader.cfh
+++ b/core/Lucy/Index/DocReader.cfh
@@ -26,7 +26,7 @@ public class Lucy::Index::DocReader inherits Lucy::Index::DataReader {
 
     inert DocReader*
     init(DocReader *self, Schema *schema = NULL, Folder *folder = NULL,
-         Snapshot *snapshot = NULL, VArray *segments = NULL,
+         Snapshot *snapshot = NULL, Vector *segments = NULL,
          int32_t seg_tick = -1);
 
     /** Retrieve the document identified by `doc_id`.
@@ -43,21 +43,21 @@ public class Lucy::Index::DocReader inherits Lucy::Index::DataReader {
      * @param offsets Doc id start offsets for each reader.
      */
     public incremented nullable DocReader*
-    Aggregator(DocReader *self, VArray *readers, I32Array *offsets);
+    Aggregator(DocReader *self, Vector *readers, I32Array *offsets);
 }
 
 /** Aggregate multiple DocReaders.
  */
 class Lucy::Index::PolyDocReader inherits Lucy::Index::DocReader {
 
-    VArray   *readers;
+    Vector   *readers;
     I32Array *offsets;
 
     inert incremented PolyDocReader*
-    new(VArray *readers, I32Array *offsets);
+    new(Vector *readers, I32Array *offsets);
 
     inert PolyDocReader*
-    init(PolyDocReader *self, VArray *readers, I32Array *offsets);
+    init(PolyDocReader *self, Vector *readers, I32Array *offsets);
 
     public incremented HitDoc*
     Fetch_Doc(PolyDocReader *self, int32_t doc_id);
@@ -76,12 +76,12 @@ class Lucy::Index::DefaultDocReader nickname DefDocReader
     InStream    *ix_in;
 
     inert incremented DefaultDocReader*
-    new(Schema *schema, Folder *folder, Snapshot *snapshot, VArray *segments,
+    new(Schema *schema, Folder *folder, Snapshot *snapshot, Vector *segments,
         int32_t seg_tick);
 
     inert DefaultDocReader*
     init(DefaultDocReader *self, Schema *schema, Folder *folder,
-         Snapshot *snapshot, VArray *segments, int32_t seg_tick);
+         Snapshot *snapshot, Vector *segments, int32_t seg_tick);
 
     public incremented HitDoc*
     Fetch_Doc(DefaultDocReader *self, int32_t doc_id);

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/DocVector.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/DocVector.c b/core/Lucy/Index/DocVector.c
index 9e7fa72..de393c8 100644
--- a/core/Lucy/Index/DocVector.c
+++ b/core/Lucy/Index/DocVector.c
@@ -85,7 +85,7 @@ DocVec_Field_Buf_IMP(DocVector *self, String *field) {
     return (ByteBuf*)Hash_Fetch(ivars->field_bufs, field);
 }
 
-VArray*
+Vector*
 DocVec_Field_Names_IMP(DocVector *self) {
     DocVectorIVARS *const ivars = DocVec_IVARS(self);
     return Hash_Keys(ivars->field_bufs);

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/FilePurger.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/FilePurger.c b/core/Lucy/Index/FilePurger.c
index 9b5971a..da9a673 100644
--- a/core/Lucy/Index/FilePurger.c
+++ b/core/Lucy/Index/FilePurger.c
@@ -30,7 +30,7 @@
 // Place unused files into purgables array and obsolete Snapshots into
 // snapshots array.
 static void
-S_discover_unused(FilePurger *self, VArray **purgables, VArray **snapshots);
+S_discover_unused(FilePurger *self, Vector **purgables, Vector **snapshots);
 
 // Clean up after a failed background merge session, adding all dead files to
 // the list of candidates to be zapped.
@@ -38,8 +38,8 @@ static void
 S_zap_dead_merge(FilePurger *self, Hash *candidates);
 
 // Return an array of recursively expanded filepath entries.
-static VArray*
-S_find_all_referenced(Folder *folder, VArray *entries);
+static Vector*
+S_find_all_referenced(Folder *folder, Vector *entries);
 
 FilePurger*
 FilePurger_new(Folder *folder, Snapshot *snapshot, IndexManager *manager) {
@@ -85,17 +85,17 @@ FilePurger_Purge_IMP(FilePurger *self) {
     if (Lock_Obtain(deletion_lock)) {
         Folder *folder   = ivars->folder;
         Hash   *failures = Hash_new(0);
-        VArray *purgables;
-        VArray *snapshots;
+        Vector *purgables;
+        Vector *snapshots;
 
         S_discover_unused(self, &purgables, &snapshots);
 
         // Attempt to delete entries -- if failure, no big deal, just try
         // again later.  Proceed in reverse lexical order so that directories
         // get deleted after they've been emptied.
-        VA_Sort(purgables);
-        for (uint32_t i = VA_Get_Size(purgables); i--;) {
-            String *entry = (String*)VA_Fetch(purgables, i);
+        Vec_Sort(purgables);
+        for (uint32_t i = Vec_Get_Size(purgables); i--;) {
+            String *entry = (String*)Vec_Fetch(purgables, i);
             if (Hash_Fetch(ivars->disallowed, entry)) { continue; }
             if (!Folder_Delete(folder, entry)) {
                 if (Folder_Exists(folder, entry)) {
@@ -104,15 +104,15 @@ FilePurger_Purge_IMP(FilePurger *self) {
             }
         }
 
-        for (uint32_t i = 0, max = VA_Get_Size(snapshots); i < max; i++) {
-            Snapshot *snapshot = (Snapshot*)VA_Fetch(snapshots, i);
+        for (uint32_t i = 0, max = Vec_Get_Size(snapshots); i < max; i++) {
+            Snapshot *snapshot = (Snapshot*)Vec_Fetch(snapshots, i);
             bool snapshot_has_failures = false;
             if (Hash_Get_Size(failures)) {
                 // Only delete snapshot files if all of their entries were
                 // successfully deleted.
-                VArray *entries = Snapshot_List(snapshot);
-                for (uint32_t j = VA_Get_Size(entries); j--;) {
-                    String *entry = (String*)VA_Fetch(entries, j);
+                Vector *entries = Snapshot_List(snapshot);
+                for (uint32_t j = Vec_Get_Size(entries); j--;) {
+                    String *entry = (String*)Vec_Fetch(entries, j);
                     if (Hash_Fetch(failures, entry)) {
                         snapshot_has_failures = true;
                         break;
@@ -185,25 +185,25 @@ S_zap_dead_merge(FilePurger *self, Hash *candidates) {
 }
 
 static void
-S_discover_unused(FilePurger *self, VArray **purgables_ptr,
-                  VArray **snapshots_ptr) {
+S_discover_unused(FilePurger *self, Vector **purgables_ptr,
+                  Vector **snapshots_ptr) {
     FilePurgerIVARS *const ivars = FilePurger_IVARS(self);
     Folder      *folder       = ivars->folder;
     DirHandle   *dh           = Folder_Open_Dir(folder, NULL);
     if (!dh) { RETHROW(INCREF(Err_get_error())); }
-    VArray      *spared       = VA_new(1);
-    VArray      *snapshots    = VA_new(1);
+    Vector      *spared       = Vec_new(1);
+    Vector      *snapshots    = Vec_new(1);
     String      *snapfile     = NULL;
 
     // Start off with the list of files in the current snapshot.
     if (ivars->snapshot) {
-        VArray *entries    = Snapshot_List(ivars->snapshot);
-        VArray *referenced = S_find_all_referenced(folder, entries);
-        VA_Push_All(spared, referenced);
+        Vector *entries    = Snapshot_List(ivars->snapshot);
+        Vector *referenced = S_find_all_referenced(folder, entries);
+        Vec_Push_All(spared, referenced);
         DECREF(entries);
         DECREF(referenced);
         snapfile = Snapshot_Get_Path(ivars->snapshot);
-        if (snapfile) { VA_Push(spared, INCREF(snapfile)); }
+        if (snapfile) { Vec_Push(spared, INCREF(snapfile)); }
     }
 
     Hash *candidates = Hash_new(64);
@@ -217,8 +217,8 @@ S_discover_unused(FilePurger *self, VArray **purgables_ptr,
                 = Snapshot_Read_File(Snapshot_new(), folder, entry);
             Lock *lock
                 = IxManager_Make_Snapshot_Read_Lock(ivars->manager, entry);
-            VArray *snap_list  = Snapshot_List(snapshot);
-            VArray *referenced = S_find_all_referenced(folder, snap_list);
+            Vector *snap_list  = Snapshot_List(snapshot);
+            Vector *referenced = S_find_all_referenced(folder, snap_list);
 
             // DON'T obtain the lock -- only see whether another
             // entity holds a lock on the snapshot file.
@@ -228,21 +228,21 @@ S_discover_unused(FilePurger *self, VArray **purgables_ptr,
             if (lock && Lock_Is_Locked(lock)) {
                 // The snapshot file is locked, which means someone's using
                 // that version of the index -- protect all of its entries.
-                uint32_t new_size = VA_Get_Size(spared)
-                                    + VA_Get_Size(referenced)
+                uint32_t new_size = Vec_Get_Size(spared)
+                                    + Vec_Get_Size(referenced)
                                     + 1;
-                VA_Grow(spared, new_size);
-                VA_Push(spared, (Obj*)Str_Clone(entry));
-                VA_Push_All(spared, referenced);
+                Vec_Grow(spared, new_size);
+                Vec_Push(spared, (Obj*)Str_Clone(entry));
+                Vec_Push_All(spared, referenced);
             }
             else {
                 // No one's using this snapshot, so all of its entries are
                 // candidates for deletion.
-                for (uint32_t i = 0, max = VA_Get_Size(referenced); i < max; i++) {
-                    String *file = (String*)VA_Fetch(referenced, i);
+                for (uint32_t i = 0, max = Vec_Get_Size(referenced); i < max; i++) {
+                    String *file = (String*)Vec_Fetch(referenced, i);
                     Hash_Store(candidates, file, (Obj*)CFISH_TRUE);
                 }
-                VA_Push(snapshots, INCREF(snapshot));
+                Vec_Push(snapshots, INCREF(snapshot));
             }
 
             DECREF(referenced);
@@ -258,8 +258,8 @@ S_discover_unused(FilePurger *self, VArray **purgables_ptr,
     S_zap_dead_merge(self, candidates);
 
     // Eliminate any current files from the list of files to be purged.
-    for (uint32_t i = 0, max = VA_Get_Size(spared); i < max; i++) {
-        String *filename = (String*)VA_Fetch(spared, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(spared); i < max; i++) {
+        String *filename = (String*)Vec_Fetch(spared, i);
         DECREF(Hash_Delete(candidates, filename));
     }
 
@@ -271,22 +271,22 @@ S_discover_unused(FilePurger *self, VArray **purgables_ptr,
     DECREF(spared);
 }
 
-static VArray*
-S_find_all_referenced(Folder *folder, VArray *entries) {
-    Hash *uniqued = Hash_new(VA_Get_Size(entries));
-    for (uint32_t i = 0, max = VA_Get_Size(entries); i < max; i++) {
-        String *entry = (String*)VA_Fetch(entries, i);
+static Vector*
+S_find_all_referenced(Folder *folder, Vector *entries) {
+    Hash *uniqued = Hash_new(Vec_Get_Size(entries));
+    for (uint32_t i = 0, max = Vec_Get_Size(entries); i < max; i++) {
+        String *entry = (String*)Vec_Fetch(entries, i);
         Hash_Store(uniqued, entry, (Obj*)CFISH_TRUE);
         if (Folder_Is_Directory(folder, entry)) {
-            VArray *contents = Folder_List_R(folder, entry);
-            for (uint32_t j = VA_Get_Size(contents); j--;) {
-                String *sub_entry = (String*)VA_Fetch(contents, j);
+            Vector *contents = Folder_List_R(folder, entry);
+            for (uint32_t j = Vec_Get_Size(contents); j--;) {
+                String *sub_entry = (String*)Vec_Fetch(contents, j);
                 Hash_Store(uniqued, sub_entry, (Obj*)CFISH_TRUE);
             }
             DECREF(contents);
         }
     }
-    VArray *referenced = Hash_Keys(uniqued);
+    Vector *referenced = Hash_Keys(uniqued);
     DECREF(uniqued);
     return referenced;
 }

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/HighlightReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/HighlightReader.c b/core/Lucy/Index/HighlightReader.c
index 8d6316c..345431e 100644
--- a/core/Lucy/Index/HighlightReader.c
+++ b/core/Lucy/Index/HighlightReader.c
@@ -33,7 +33,7 @@
 
 HighlightReader*
 HLReader_init(HighlightReader *self, Schema *schema, Folder *folder,
-              Snapshot *snapshot, VArray *segments, int32_t seg_tick) {
+              Snapshot *snapshot, Vector *segments, int32_t seg_tick) {
     DataReader_init((DataReader*)self, schema, folder, snapshot, segments,
                     seg_tick);
     ABSTRACT_CLASS_CHECK(self, HIGHLIGHTREADER);
@@ -41,28 +41,28 @@ HLReader_init(HighlightReader *self, Schema *schema, Folder *folder,
 }
 
 HighlightReader*
-HLReader_Aggregator_IMP(HighlightReader *self, VArray *readers,
+HLReader_Aggregator_IMP(HighlightReader *self, Vector *readers,
                         I32Array *offsets) {
     UNUSED_VAR(self);
     return (HighlightReader*)PolyHLReader_new(readers, offsets);
 }
 
 PolyHighlightReader*
-PolyHLReader_new(VArray *readers, I32Array *offsets) {
+PolyHLReader_new(Vector *readers, I32Array *offsets) {
     PolyHighlightReader *self
         = (PolyHighlightReader*)Class_Make_Obj(POLYHIGHLIGHTREADER);
     return PolyHLReader_init(self, readers, offsets);
 }
 
 PolyHighlightReader*
-PolyHLReader_init(PolyHighlightReader *self, VArray *readers,
+PolyHLReader_init(PolyHighlightReader *self, Vector *readers,
                   I32Array *offsets) {
     HLReader_init((HighlightReader*)self, NULL, NULL, NULL, NULL, -1);
     PolyHighlightReaderIVARS *const ivars = PolyHLReader_IVARS(self);
-    for (uint32_t i = 0, max = VA_Get_Size(readers); i < max; i++) {
-        CERTIFY(VA_Fetch(readers, i), HIGHLIGHTREADER);
+    for (uint32_t i = 0, max = Vec_Get_Size(readers); i < max; i++) {
+        CERTIFY(Vec_Fetch(readers, i), HIGHLIGHTREADER);
     }
-    ivars->readers = (VArray*)INCREF(readers);
+    ivars->readers = (Vector*)INCREF(readers);
     ivars->offsets = (I32Array*)INCREF(offsets);
     return self;
 }
@@ -71,9 +71,9 @@ void
 PolyHLReader_Close_IMP(PolyHighlightReader *self) {
     PolyHighlightReaderIVARS *const ivars = PolyHLReader_IVARS(self);
     if (ivars->readers) {
-        for (uint32_t i = 0, max = VA_Get_Size(ivars->readers); i < max; i++) {
+        for (uint32_t i = 0, max = Vec_Get_Size(ivars->readers); i < max; i++) {
             HighlightReader *sub_reader
-                = (HighlightReader*)VA_Fetch(ivars->readers, i);
+                = (HighlightReader*)Vec_Fetch(ivars->readers, i);
             if (sub_reader) { HLReader_Close(sub_reader); }
         }
         DECREF(ivars->readers);
@@ -97,14 +97,14 @@ PolyHLReader_Fetch_Doc_Vec_IMP(PolyHighlightReader *self, int32_t doc_id) {
     uint32_t seg_tick = PolyReader_sub_tick(ivars->offsets, doc_id);
     int32_t  offset   = I32Arr_Get(ivars->offsets, seg_tick);
     HighlightReader *sub_reader
-        = (HighlightReader*)VA_Fetch(ivars->readers, seg_tick);
+        = (HighlightReader*)Vec_Fetch(ivars->readers, seg_tick);
     if (!sub_reader) { THROW(ERR, "Invalid doc_id: %i32", doc_id); }
     return HLReader_Fetch_Doc_Vec(sub_reader, doc_id - offset);
 }
 
 DefaultHighlightReader*
 DefHLReader_new(Schema *schema, Folder *folder, Snapshot *snapshot,
-                VArray *segments, int32_t seg_tick) {
+                Vector *segments, int32_t seg_tick) {
     DefaultHighlightReader *self = (DefaultHighlightReader*)Class_Make_Obj(
                                        DEFAULTHIGHLIGHTREADER);
     return DefHLReader_init(self, schema, folder, snapshot, segments,
@@ -113,7 +113,7 @@ DefHLReader_new(Schema *schema, Folder *folder, Snapshot *snapshot,
 
 DefaultHighlightReader*
 DefHLReader_init(DefaultHighlightReader *self, Schema *schema,
-                 Folder *folder, Snapshot *snapshot, VArray *segments,
+                 Folder *folder, Snapshot *snapshot, Vector *segments,
                  int32_t seg_tick) {
     HLReader_init((HighlightReader*)self, schema, folder, snapshot,
                   segments, seg_tick);

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/HighlightReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/HighlightReader.cfh b/core/Lucy/Index/HighlightReader.cfh
index 8568330..d6cef6d 100644
--- a/core/Lucy/Index/HighlightReader.cfh
+++ b/core/Lucy/Index/HighlightReader.cfh
@@ -25,7 +25,7 @@ class Lucy::Index::HighlightReader nickname HLReader
 
     inert HighlightReader*
     init(HighlightReader *self, Schema *schema = NULL, Folder *folder = NULL,
-         Snapshot *snapshot = NULL, VArray *segments = NULL,
+         Snapshot *snapshot = NULL, Vector *segments = NULL,
          int32_t seg_tick = -1);
 
     /** Return the DocVector object for the given doc id.
@@ -34,20 +34,20 @@ class Lucy::Index::HighlightReader nickname HLReader
     Fetch_Doc_Vec(HighlightReader *self, int32_t doc_id);
 
     public incremented nullable HighlightReader*
-    Aggregator(HighlightReader *self, VArray *readers, I32Array *offsets);
+    Aggregator(HighlightReader *self, Vector *readers, I32Array *offsets);
 }
 
 class Lucy::Index::PolyHighlightReader nickname PolyHLReader
     inherits Lucy::Index::HighlightReader {
 
-    VArray   *readers;
+    Vector   *readers;
     I32Array *offsets;
 
     inert incremented PolyHighlightReader*
-    new(VArray *readers, I32Array *offsets);
+    new(Vector *readers, I32Array *offsets);
 
     inert PolyHighlightReader*
-    init(PolyHighlightReader *self, VArray *readers, I32Array *offsets);
+    init(PolyHighlightReader *self, Vector *readers, I32Array *offsets);
 
     public incremented DocVector*
     Fetch_Doc_Vec(PolyHighlightReader *self, int32_t doc_id);
@@ -68,12 +68,12 @@ class Lucy::Index::DefaultHighlightReader nickname DefHLReader
     /** Constructors.
      */
     inert incremented DefaultHighlightReader*
-    new(Schema *schema, Folder *folder, Snapshot *snapshot, VArray *segments,
+    new(Schema *schema, Folder *folder, Snapshot *snapshot, Vector *segments,
         int32_t seg_tick);
 
     inert DefaultHighlightReader*
     init(DefaultHighlightReader *self, Schema *schema, Folder *folder,
-         Snapshot *snapshot, VArray *segments, int32_t seg_tick);
+         Snapshot *snapshot, Vector *segments, int32_t seg_tick);
 
     /** Return the DocVector object for the given doc id.
      */

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/IndexManager.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexManager.c b/core/Lucy/Index/IndexManager.c
index 17de0cb..b780716 100644
--- a/core/Lucy/Index/IndexManager.c
+++ b/core/Lucy/Index/IndexManager.c
@@ -68,11 +68,11 @@ IxManager_Destroy_IMP(IndexManager *self) {
 
 int64_t
 IxManager_Highest_Seg_Num_IMP(IndexManager *self, Snapshot *snapshot) {
-    VArray *files = Snapshot_List(snapshot);
+    Vector *files = Snapshot_List(snapshot);
     uint64_t highest_seg_num = 0;
     UNUSED_VAR(self);
-    for (uint32_t i = 0, max = VA_Get_Size(files); i < max; i++) {
-        String *file = (String*)VA_Fetch(files, i);
+    for (uint32_t i = 0, max = Vec_Get_Size(files); i < max; i++) {
+        String *file = (String*)Vec_Fetch(files, i);
         if (Seg_valid_seg_name(file)) {
             uint64_t seg_num = IxFileNames_extract_gen(file);
             if (seg_num > highest_seg_num) { highest_seg_num = seg_num; }
@@ -131,27 +131,27 @@ S_fibonacci(uint32_t n) {
     return result;
 }
 
-VArray*
+Vector*
 IxManager_Recycle_IMP(IndexManager *self, PolyReader *reader,
                       DeletionsWriter *del_writer, int64_t cutoff,
                       bool optimize) {
-    VArray *seg_readers = PolyReader_Get_Seg_Readers(reader);
-    size_t num_seg_readers = VA_Get_Size(seg_readers);
+    Vector *seg_readers = PolyReader_Get_Seg_Readers(reader);
+    size_t num_seg_readers = Vec_Get_Size(seg_readers);
     SegReader **candidates
         = (SegReader**)MALLOCATE(num_seg_readers * sizeof(SegReader*));
     size_t num_candidates = 0;
     for (size_t i = 0; i < num_seg_readers; i++) {
-        SegReader *seg_reader = (SegReader*)VA_Fetch(seg_readers, i);
+        SegReader *seg_reader = (SegReader*)Vec_Fetch(seg_readers, i);
         if (SegReader_Get_Seg_Num(seg_reader) > cutoff) {
             candidates[num_candidates++] = seg_reader;
         }
     }
 
-    VArray *recyclables = VA_new(num_candidates);
+    Vector *recyclables = Vec_new(num_candidates);
 
     if (optimize) {
         for (size_t i = 0; i < num_candidates; i++) {
-            VA_Push(recyclables, INCREF(candidates[i]));
+            Vec_Push(recyclables, INCREF(candidates[i]));
         }
         FREEMEM(candidates);
         return recyclables;
@@ -170,7 +170,7 @@ IxManager_Recycle_IMP(IndexManager *self, PolyReader *reader,
 
     // Move SegReaders to be recycled.
     for (uint32_t i = 0; i < threshold; i++) {
-        VA_Store(recyclables, i, INCREF(candidates[i]));
+        Vec_Store(recyclables, i, INCREF(candidates[i]));
     }
 
     // Find segments where at least 10% of all docs have been deleted.
@@ -181,7 +181,7 @@ IxManager_Recycle_IMP(IndexManager *self, PolyReader *reader,
         double num_deletions = DelWriter_Seg_Del_Count(del_writer, seg_name);
         double del_proportion = num_deletions / doc_max;
         if (del_proportion >= 0.1) {
-            VA_Push(recyclables, INCREF(seg_reader));
+            Vec_Push(recyclables, INCREF(seg_reader));
         }
     }
 

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/IndexManager.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexManager.cfh b/core/Lucy/Index/IndexManager.cfh
index a4ae10c..7a16231 100644
--- a/core/Lucy/Index/IndexManager.cfh
+++ b/core/Lucy/Index/IndexManager.cfh
@@ -83,7 +83,7 @@ public class Lucy::Index::IndexManager nickname IxManager
      * @param optimize A boolean indicating whether to spend extra time
      * optimizing the index for search-time performance.
      */
-    public incremented VArray*
+    public incremented Vector*
     Recycle(IndexManager *self, PolyReader *reader,
             DeletionsWriter *del_writer, int64_t cutoff,
             bool optimize = false);

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/IndexReader.c
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexReader.c b/core/Lucy/Index/IndexReader.c
index b236fee..b8f2725 100644
--- a/core/Lucy/Index/IndexReader.c
+++ b/core/Lucy/Index/IndexReader.c
@@ -38,7 +38,7 @@ IndexReader*
 IxReader_do_open(IndexReader *temp_self, Obj *index, Snapshot *snapshot,
                  IndexManager *manager) {
     PolyReader *polyreader = PolyReader_open(index, snapshot, manager);
-    if (!VA_Get_Size(PolyReader_Get_Seg_Readers(polyreader))) {
+    if (!Vec_Get_Size(PolyReader_Get_Seg_Readers(polyreader))) {
         THROW(ERR, "Index doesn't seem to contain any data");
     }
     DECREF(temp_self);
@@ -47,7 +47,7 @@ IxReader_do_open(IndexReader *temp_self, Obj *index, Snapshot *snapshot,
 
 IndexReader*
 IxReader_init(IndexReader *self, Schema *schema, Folder *folder,
-              Snapshot *snapshot, VArray *segments, int32_t seg_tick,
+              Snapshot *snapshot, Vector *segments, int32_t seg_tick,
               IndexManager *manager) {
     snapshot = snapshot ? (Snapshot*)INCREF(snapshot) : Snapshot_new();
     DataReader_init((DataReader*)self, schema, folder, snapshot, segments,

http://git-wip-us.apache.org/repos/asf/lucy/blob/0c238b13/core/Lucy/Index/IndexReader.cfh
----------------------------------------------------------------------
diff --git a/core/Lucy/Index/IndexReader.cfh b/core/Lucy/Index/IndexReader.cfh
index ed58e9e..77c8875 100644
--- a/core/Lucy/Index/IndexReader.cfh
+++ b/core/Lucy/Index/IndexReader.cfh
@@ -44,7 +44,7 @@ public class Lucy::Index::IndexReader nickname IxReader
 
     public inert nullable IndexReader*
     init(IndexReader *self, Schema *schema = NULL, Folder *folder,
-         Snapshot *snapshot = NULL, VArray *segments = NULL,
+         Snapshot *snapshot = NULL, Vector *segments = NULL,
          int32_t seg_tick = -1, IndexManager *manager = NULL);
 
     public inert incremented nullable IndexReader*
@@ -93,7 +93,7 @@ public class Lucy::Index::IndexReader nickname IxReader
     /** Return an array of all the SegReaders represented within the
      * IndexReader.
      */
-    public abstract incremented VArray*
+    public abstract incremented Vector*
     Seg_Readers(IndexReader *self);
 
     /** Fetch a component, or throw an error if the component can't be found.


Mime
View raw message