usm/src/lib/File.vala

using Invercargill;
using Invercargill.Mapping;
using Invercargill.DataStructures;

namespace Usm {

    public class ManifestFile {

        public ManifestFilePathBase path_base { get; set; }
        public string path { get; set; }
        public ManifestFileType file_type { get; set; }
        public string? destination { get; set; }
        public Vector<RemoveType>? keep_on { get; set; }
        public Vector<InstallType>? skip_for { get; set; }

        public static PropertyMapper<ManifestFile> get_mapper() {
            return PropertyMapper.build_for<ManifestFile>(cfg => {
                cfg.map<string>("path", o => o.path, (o, v) => o.path = v); // TODO make nullable in some cases, add validtion (i.e. type != reg, and pathBase == as-expected)
                cfg.map<string>("pathBase", o => o.path_base.to_string(), (o, v) => o.path_base = ManifestFilePathBase.from_string(v));
                cfg.map<string>("type", o => o.file_type.to_string(), (o, v) => o.file_type = ManifestFileType.from_string(v));
                cfg.map<string>("dest", o => o.destination, (o, v) => o.destination = v)
                    .undefined_when(o => o.destination == null)
                    .when_undefined(o => o.destination = null);
                cfg.map_many<string>("keepOn", o => o.keep_on.select<string>(i => i.to_string()), (o, v) => o.keep_on = v.attempt_select<RemoveType>(i => RemoveType.from_string(i)).to_vector())
                    .undefined_when(o => o.keep_on == null)
                    .when_undefined(o => o.keep_on = null);
                cfg.map_many<string>("skipFor", o => o.skip_for.select<string>(i => i.to_string()), (o, v) => o.skip_for = v.attempt_select<InstallType>(i => InstallType.from_string(i)).to_vector())
                    .undefined_when(o => o.skip_for == null)
                    .when_undefined(o => o.skip_for = null);
                cfg.set_constructor(() => new ManifestFile());
            });
        }

        public ManifestFile.from_string(string str) throws ManifestError {
            var parts = str.split(":", 2);
            path_base = ManifestFilePathBase.from_string(parts[0]);
            file_type = ManifestFileType.REGULAR;
            if(path_base == ManifestFilePathBase.AS_EXPECTED) {
                path = "";
                return;
            }
            if(parts.length != 2) {
                throw new ManifestError.INVALID_FILE_PATH("No file path provided");
            }
            path = parts[1];
        }
        
    }

    public enum ManifestFileType {
        REGULAR,
        DIRECTORY,
        SYMBOLIC_LINK;

        public string to_string() {
            switch(this) {
                case ManifestFileType.REGULAR:
                    return "reg";
                case ManifestFileType.DIRECTORY:
                    return "dir";
                case ManifestFileType.SYMBOLIC_LINK:
                    return "lnk";
                default:
                    assert_not_reached();
            }
        }

        public static ManifestFileType from_string(string str) throws ManifestError {
            switch(str) {
                case "reg":
                    return ManifestFileType.REGULAR;
                case "dir":
                    return ManifestFileType.DIRECTORY;
                case "lnk":
                    return ManifestFileType.SYMBOLIC_LINK;
                default:
                    throw new ManifestError.INVALID_FILE_TYPE(@"Unknown file type \"$str\".");
            }
        }
    }

    public enum ManifestFilePathBase {
        SOURCE,
        BUILD,
        INSTALL,
        AS_EXPECTED;

        public string to_string() {
            switch(this) {
                case ManifestFilePathBase.SOURCE:
                    return "source";
                case ManifestFilePathBase.BUILD:
                    return "build";
                case ManifestFilePathBase.INSTALL:
                    return "install";
                case ManifestFilePathBase.AS_EXPECTED:
                    return "as-expected";
                default:
                    assert_not_reached();
            }
        }

        public static ManifestFilePathBase from_string(string str) throws ManifestError {
            switch(str) {
                case "source":
                    return ManifestFilePathBase.SOURCE;
                case "build":
                    return ManifestFilePathBase.BUILD;
                case "install":
                    return ManifestFilePathBase.INSTALL;
                case "as-expected":
                    return ManifestFilePathBase.AS_EXPECTED;
                default:
                    throw new ManifestError.INVALID_PATH_BASE(@"Unknown path base \"$str\".");
            }
        }
    }

}