Merge pull request #135 from mpsonntag/file

Add missing file functions

Author: jgrewe

+nix/File.m

@@ -25,32 +25,45 @@
             % assign relations
             nix.Dynamic.add_dyn_relation(obj, 'blocks', @nix.Block);
             nix.Dynamic.add_dyn_relation(obj, 'sections', @nix.Section);
-            
+
             obj.info = nix_mx('File::describe', obj.nix_handle);
         end
-        
+
+        % braindead...
+        function check = is_open(obj)
+            check = nix_mx('File::isOpen', obj.nix_handle);
+        end
+
+        function mode = file_mode(obj)
+            mode = nix_mx('File::fileMode', obj.nix_handle);
+        end
+
+        function res = validate(obj)
+            res = nix_mx('File::validate', obj.nix_handle);
+        end
+
         % ----------------
         % Block methods
         % ----------------
 
-        function newBlock = createBlock(obj, name, type)
+        function newBlock = create_block(obj, name, type)
             newBlock = nix.Block(nix_mx('File::createBlock', obj.nix_handle, name, type));
         end;
 
-        function c = blockCount(obj)
+        function c = block_count(obj)
             c = nix_mx('File::blockCount', obj.nix_handle);
         end
 
-        function hasBlock = hasBlock(obj, id_or_name)
+        function hasBlock = has_block(obj, id_or_name)
             hasBlock = nix_mx('File::hasBlock', obj.nix_handle, id_or_name);
         end;
 
-        function retObj = openBlock(obj, id_or_name)
+        function retObj = open_block(obj, id_or_name)
             retObj = nix.Utils.open_entity(obj, ...
                 'File::openBlock', id_or_name, @nix.Block);
         end
 
-        function delCheck = deleteBlock(obj, del)
+        function delCheck = delete_block(obj, del)
             delCheck = nix.Utils.delete_entity(obj, ...
                 del, 'nix.Block', 'File::deleteBlock');
         end;
@@ -59,24 +72,24 @@
         % Section methods
         % ----------------
 
-        function newSec = createSection(obj, name, type)
+        function newSec = create_section(obj, name, type)
             newSec = nix.Section(nix_mx('File::createSection', obj.nix_handle, name, type));
         end;
 
-        function c = sectionCount(obj)
+        function c = section_count(obj)
             c = nix_mx('File::sectionCount', obj.nix_handle);
         end
 
-        function hasSec = hasSection(obj, id_or_name)
+        function hasSec = has_section(obj, id_or_name)
             hasSec = nix_mx('File::hasSection', obj.nix_handle, id_or_name);
         end;
 
-        function retObj = openSection(obj, id_or_name)
+        function retObj = open_section(obj, id_or_name)
             retObj = nix.Utils.open_entity(obj, ...
                 'File::openSection', id_or_name, @nix.Section);
         end
 
-        function delCheck = deleteSection(obj, del)
+        function delCheck = delete_section(obj, del)
             delCheck = nix.Utils.delete_entity(obj, del, 'nix.Section', 'File::deleteSection');
         end;
     end

nix_mx.cc

@@ -115,7 +115,10 @@ void mexFunction(int            nlhs,
             .reg("createBlock", &nix::File::createBlock)
             .reg("createSection", &nix::File::createSection)
             .reg("blockCount", GETTER(nix::ndsize_t, nix::File, blockCount))
-            .reg("sectionCount", GETTER(nix::ndsize_t, nix::File, sectionCount));
+            .reg("sectionCount", GETTER(nix::ndsize_t, nix::File, sectionCount))
+            .reg("isOpen", GETTER(bool, nix::File, isOpen));
+        methods->add("File::fileMode", nixfile::fileMode);
+        methods->add("File::validate", nixfile::validate);
 
         classdef<nix::Block>("Block", methods)
             .desc(&nixblock::describe)

src/nixfile.cc

@@ -11,11 +11,31 @@
 #include "mex.h"
 
 #include <nix.hpp>
+#include <nix/valid/validate.hpp>
 
 #include "handle.h"
 #include "arguments.h"
 #include "struct.h"
 
+// helper function
+mxArray *message(std::vector<nix::valid::Message> mes) {
+    const mwSize size = static_cast<mwSize>(mes.size());
+    mxArray *list = mxCreateCellArray(1, &size);
+
+    for (size_t i = 0; i < mes.size(); i++) {
+
+        nix::valid::Message curr = mes[i];
+
+        struct_builder msb({ 1 }, { "id", "msg" });
+        msb.set(curr.id);
+        msb.set(curr.msg);
+
+        mxSetCell(list, i, msb.array());
+    }
+
+    return list;
+}
+
 namespace nixfile {
 
     void open(const extractor &input, infusor &output) {
@@ -36,6 +56,41 @@ namespace nixfile {
         output.set(0, h);
     }
 
+    void fileMode(const extractor &input, infusor &output) {
+        nix::File currObj = input.entity<nix::File>(1);
+        nix::FileMode mode = currObj.fileMode();
+        uint8_t omode;
+
+        switch (mode) {
+        case nix::FileMode::ReadOnly: omode = 0; break;
+        case nix::FileMode::ReadWrite: omode = 1; break;
+        case nix::FileMode::Overwrite: omode = 2; break;
+        default: throw std::invalid_argument("unknown open mode");
+        }
+
+        output.set(0, omode);
+    }
+
+    void validate(const extractor &input, infusor &output) {
+        nix::File f = input.entity<nix::File>(1);
+        nix::valid::Result res = f.validate();
+
+        std::vector<nix::valid::Message> err = res.getErrors();
+        mxArray *err_list = message(err);
+
+        std::vector<nix::valid::Message> warn = res.getWarnings();
+        mxArray *warn_list = message(warn);
+
+        struct_builder sb({ 1 }, { "ok", "hasErrors", "hasWarnings", "errors", "warnings" });
+        sb.set(res.ok());
+        sb.set(res.hasErrors());
+        sb.set(res.hasWarnings());
+        sb.set(err_list);
+        sb.set(warn_list);
+
+        output.set(0, sb.array());
+    }
+
     mxArray *describe(const nix::File &fd) {
         struct_builder sb({ 1 }, { "format", "version", "location", "createdAt", "updatedAt" });
         sb.set(fd.format());

src/nixfile.h

@@ -15,6 +15,10 @@ namespace nixfile {
 
     void open(const extractor &input, infusor &output);
 
+    void fileMode(const extractor &input, infusor &output);
+
+    void validate(const extractor &input, infusor &output);
+
     mxArray *describe(const nix::File &f);
 
 } // namespace nixfile