iterator recognizes vdata, tests

include/hdf4cpp/HdfFile.h

@@ -41,8 +41,7 @@ class HdfFile {
     int32 sId;
     int32 vId;
 
-    int32 loneSize;
-    std::vector<int32> loneRefs;
+    std::vector<std::pair<int32, Type> > loneRefs;
 };
 
 class HdfFile::Iterator : public std::iterator<std::bidirectional_iterator_tag, HdfItem> {
@@ -72,12 +71,23 @@ public:
     }
 
     HdfItem operator*() {
-        if(index < 0 || index >= file->loneSize) {
+        if(index < 0 || index >= file->loneRefs.size()) {
             throw std::runtime_error("HDF4CPP: cannot access invalid item");
         }
-        int32 ref = file->loneRefs[index];
-        int32 id = Vattach(file->vId, file->loneRefs[index], "r");
-        return HdfItem(new HdfGroupItem(id), file->sId, file->vId);
+        int32 ref = file->loneRefs[index].first;
+        switch(file->loneRefs[index].second) {
+            case VGROUP: {
+                int32 id = Vattach(file->vId, ref, "r");
+                return HdfItem(new HdfGroupItem(id), file->sId, file->vId);
+            }
+            case VDATA: {
+                int32 id = VSattach(file->vId, ref, "r");
+                return HdfItem(new HdfDataItem(id), file->sId, file->vId);
+            }
+            default: {
+                return HdfItem(nullptr, file->sId, file->vId);
+            }
+        }
     }
 private:
     const HdfFile *file;

include/hdf4cpp/HdfItem.h

@@ -404,7 +404,8 @@ public:
             throw std::runtime_error("HDF4CPP: cannot access invalid item");
         }
         if(Visvs(key, ref)) {
-            throw std::runtime_error("HDF4CPP: vdata not supported yet");
+            int32 id = VSattach(vId, ref, "r");
+            return HdfItem(new HdfDataItem(id), sId, vId);
         } else if(Visvg(key, ref)) {
             int32 id = Vattach(vId, ref, "r");
             return HdfItem(new HdfGroupItem(id), sId, vId);

lib/HdfFile.cpp

@@ -15,9 +15,19 @@ hdf4cpp::HdfFile::HdfFile(const std::string& path) {
     vId = Hopen(path.c_str(), DFACC_READ, 0);
     Vstart(vId);
 
-    loneSize = Vlone(vId, nullptr, 0);
-    loneRefs.resize((size_t) loneSize);
-    Vlone(vId, loneRefs.data(), loneSize);
+    int32 loneSize = Vlone(vId, nullptr, 0);
+    std::vector<int32> refs((size_t) loneSize);
+    Vlone(vId, refs.data(), loneSize);
+    for(const auto& ref : refs) {
+        loneRefs.push_back(std::pair<int32, Type>(ref, VGROUP));
+    }
+
+    int32 loneVdata = VSlone(vId, nullptr, 0);
+    refs.resize((size_t) loneVdata);
+    VSlone(vId, refs.data(), loneVdata);
+    for(const auto& ref : refs) {
+        loneRefs.push_back(std::pair<int32, Type>(ref, VDATA));
+    }
 }
 hdf4cpp::HdfFile::~HdfFile() {
     SDend(sId);
@@ -107,10 +117,5 @@ hdf4cpp::HdfFile::Iterator hdf4cpp::HdfFile::begin() const {
     return Iterator(this, 0);
 }
 hdf4cpp::HdfFile::Iterator hdf4cpp::HdfFile::end() const {
-    int32 size;
-    size = Vlone(vId, nullptr, 0);
-    if(size == FAIL) {
-        size = 0;
-    }
-    return Iterator(this, size);
+    return Iterator(this, (int32) loneRefs.size());
 }

tests/HdfFileTest.cpp

@@ -47,14 +47,14 @@ TEST_F(HdfFileTest, InvalidItem) {
 TEST_F(HdfFileTest, ReadData1) {
     HdfItem item = file.get("Data");
     std::vector<int32> vec;
-    item.read(vec);
+    ASSERT_TRUE(item.read(vec));
     ASSERT_EQ(vec, std::vector<int32>({1, 2, 3, 4, 5, 6, 7, 8, 9}));
 }
 
 TEST_F(HdfFileTest, ReadData2) {
     HdfItem item = file.get("DataWithAttributes");
     std::vector<float32> vec;
-    item.read(vec);
+    ASSERT_TRUE(item.read(vec));
     ASSERT_EQ(vec, std::vector<float32>({0.0, 0.1, 0.2, 1.0, 1.1, 1.2, 2.0, 2.1, 2.2}));
 }
 
@@ -63,12 +63,12 @@ TEST_F(HdfFileTest, ReadDatasetAttributes) {
 
     HdfAttribute attribute1 = item.getAttribute("Integer");
     std::vector<int32> integer;
-    attribute1.get(integer);
+    ASSERT_TRUE(attribute1.get(integer));
     ASSERT_EQ(integer, std::vector<int32>({12345}));
 
     HdfAttribute attribute2 = item.getAttribute("Integers");
     std::vector<int32> integers;
-    attribute2.get(integers);
+    ASSERT_TRUE(attribute2.get(integers));
     ASSERT_EQ(integers, std::vector<int32>({1, 12, 123, 1234, 12345}));
 }
 
@@ -78,21 +78,21 @@ TEST_F(HdfFileTest, ReadGroupAttributes) {
     {
         HdfAttribute attribute = item.getAttribute("Egy");
         std::vector<int8> egy;
-        attribute.get(egy);
+        ASSERT_TRUE(attribute.get(egy));
         ASSERT_EQ(egy, std::vector<int8>({1}));
     }
 
     {
         HdfAttribute attribute = item.getAttribute("One");
         std::vector<int16> one;
-        attribute.get(one);
+        ASSERT_TRUE(attribute.get(one));
         ASSERT_EQ(one, std::vector<int16>({1}));
     }
 
     {
         HdfAttribute attribute = item.getAttribute("Ein");
         std::vector<int32> ein;
-        attribute.get(ein);
+        ASSERT_TRUE(attribute.get(ein));
         ASSERT_EQ(ein, std::vector<int32>({1}));
     }
 }
@@ -108,14 +108,14 @@ TEST_F(HdfFileTest, ReadDataInRange) {
         HdfItem item = file.get("Data");
         ASSERT_TRUE(item.isValid());
         std::vector<int32> vec;
-        item.read(vec, std::vector<Range>({Range(0, 2), Range(1, 2)}));
+        ASSERT_TRUE(item.read(vec, std::vector<Range>({Range(0, 2), Range(1, 2)})));
         ASSERT_EQ(vec, std::vector<int32>({2, 3, 5, 6}));
     }
     {
         HdfItem item = file.get("DataWithAttributes");
         ASSERT_TRUE(item.isValid());
         std::vector<float32> vec;
-        item.read(vec, std::vector<Range>({Range(2, 1), Range(0, 2)}));
+        ASSERT_TRUE(item.read(vec, std::vector<Range>({Range(2, 1), Range(0, 2)})));
         ASSERT_EQ(vec, std::vector<float32>({2.0, 2.1}));
     }
 }
@@ -143,7 +143,7 @@ TEST_F(HdfFileTest, MovingItems) {
     HdfItem item2 = std::move(item1);
     ASSERT_FALSE(item1.isValid());
     std::vector<int32> vec;
-    item2.read(vec);
+    ASSERT_TRUE(item2.read(vec));
     ASSERT_EQ(vec, std::vector<int32>({1, 2, 3, 4, 5, 6, 7, 8, 9}));
 }
 
@@ -151,9 +151,9 @@ TEST_F(HdfFileTest, GetAllDatsetsWithTheSameName) {
     std::vector<HdfItem> items = file.getAll("DoubleDataset");
     ASSERT_EQ(items.size(), 2);
     std::vector<int32> vec;
-    items[0].read(vec);
+    ASSERT_TRUE(items[0].read(vec));
     ASSERT_EQ(vec, std::vector<int32>({0}));
-    items[1].read(vec);
+    ASSERT_TRUE(items[1].read(vec));
     ASSERT_EQ(vec, std::vector<int32>({0, 1}));
 }
 
@@ -181,19 +181,19 @@ TEST_F(HdfFileTest, GlobalAttribute) {
     std::vector<int8> vec;
     HdfAttribute attribute = file.getAttribute("GlobalAttribute");
     ASSERT_TRUE(attribute.isValid());
-    attribute.get(vec);
+    ASSERT_TRUE(attribute.get(vec));
     ASSERT_EQ(vec, std::vector<int8>({11, 22}));
 }
 
-TEST_F(HdfFileTest, ItemIterator1) {
+TEST_F(HdfFileTest, FileIterator) {
     std::ostringstream out;
     for(auto it : file) {
         out << it.getName() << '*';
     }
-    ASSERT_EQ(out.str(), std::string("Group*GroupWithOnlyAttribute*RIG0.0*/home/patrik/HDF4CPP/tests/test_data/small_test.hdf*"));
+    ASSERT_EQ(out.str(), std::string("Group*GroupWithOnlyAttribute*RIG0.0*/home/patrik/HDF4CPP/tests/test_data/small_test.hdf*Egy*One*Ein*Vdata*attribute*"));
 }
 
-TEST_F(HdfFileTest, ItemIterator2) {
+TEST_F(HdfFileTest, GroupIterator) {
     HdfItem item = file.get("Group");
     ASSERT_TRUE(item.isValid());
     std::ostringstream out;
@@ -203,6 +203,19 @@ TEST_F(HdfFileTest, ItemIterator2) {
     ASSERT_EQ(out.str(), "Data*DataWithAttributes*");
 }
 
+TEST_F(HdfFileTest, IteratingOverNonGroupItems) {
+    std::ostringstream out;
+    HdfItem sdata = file.get("DoubleDataset");
+    for(const auto& item : sdata) {
+        out << item.getName();
+    }
+    HdfItem vdata = file.get("Vdata");
+    for(const auto& item : vdata) {
+        out << item.getName();
+    }
+    ASSERT_TRUE(out.str().empty());
+}
+
 TEST_F(HdfFileTest, ItemIterator3) {
     auto it = file.begin();
     HdfItem item = *it;
@@ -217,6 +230,7 @@ TEST_F(HdfFileTest, HiddenGroup) {
 TEST_F(HdfFileTest, VDataRead1) {
     HdfItem item = file.get("Vdata");
     ASSERT_TRUE(item.isValid());
+    ASSERT_EQ(item.getName(), "Vdata");
     std::vector<int32> vec;
     ASSERT_TRUE(item.read(vec, "age"));
     ASSERT_EQ(vec, std::vector<int32>({39, 19, 55}));
@@ -225,6 +239,7 @@ TEST_F(HdfFileTest, VDataRead1) {
 TEST_F(HdfFileTest, VDataRead2) {
     HdfItem item = file.get("Vdata");
     ASSERT_TRUE(item.isValid());
+    ASSERT_EQ(item.getName(), "Vdata");
     std::vector<std::vector<char> > vec;
     ASSERT_TRUE(item.read(vec, "name"));
     std::vector<std::string> exp = {"Patrick Jane", "Barry Allen", "Angus MacGyver"};
@@ -237,6 +252,7 @@ TEST_F(HdfFileTest, VDataRead2) {
 TEST_F(HdfFileTest, VDataAttributes) {
     HdfItem item = file.get("Vdata");
     ASSERT_TRUE(item.isValid());
+    ASSERT_EQ(item.getName(), "Vdata");
     HdfAttribute attribute = item.getAttribute("attribute");
     ASSERT_TRUE(attribute.isValid());
     std::vector<int32> vec;