import models/SimpleClassDiagrams as SimpleClassDiagrams
include "primitives.alh"

SimpleClassDiagrams CoreFormalism {
    SimpleAttribute String {
        constraint = $
            String function constraint(model : Element, name : String):
                if (bool_not(is_physical_string(model["model"][name]))):
                    return "String has no string value"!
                else:
                    return "OK"!
            $
    }

    SimpleAttribute Permissions {
        constraint = $
            String function constraint(model : Element, name : String):
                Element self
                self = model["model"][name]
                if (bool_not(is_physical_string(self))):
                    return "Permissions has no string value"!
                if (bool_not(string_len(self) == 3)):
                    return "Permissions string is not of correct length"!
                if (bool_or(cast_s2i(string_get(self, 0)) < 0, cast_s2i(string_get(self, 0)) > 2)):
                    return "Owner permission is not in range [0, 2]"!
                if (bool_or(cast_s2i(string_get(self, 1)) < 0, cast_s2i(string_get(self, 1)) > 2)):
                    return "Group permission is not in range [0, 2]"!
                if (bool_or(cast_s2i(string_get(self, 2)) < 0, cast_s2i(string_get(self, 2)) > 2)):
                    return "Other permission is not in range [0, 2]"!
                return "OK"!
            $
    }

    SimpleAttribute Boolean {
        constraint = $
            String function constraint(model : Element, name : String):
                if (bool_not(is_physical_boolean(model["model"][name]))):
                    return "Boolean has no bool value"!
                else:
                    return "OK"!
            $
    }

    SimpleAttribute Natural {
        constraint = $
            String function constraint(model : Element, name : String):
                if (bool_not(is_physical_int(model["model"][name]))):
                    return "Natural has no integer value"!
                elif (integer_lt(model["model"][name], 0)):
                    return "Natural has negative value"!
                else:
                    return "OK"!
            $
    }

    Class User {
        name : String
        password : String
        admin : Boolean
    }

    Class Group {
        name : String
    }

    Association ownedBy (Group, User) {}
    Association belongsTo (User, Group) {}

    Class Entry {
        name : String
        permissions : Permissions
    }

    Class Folder : Entry {
    }

    Association contains (Folder, Entry) {}

    Class Model : Entry {
        location : String
    }

    Class TypeMapping : Model {}

    Association instanceOf (Model, Model) {
    }

    Association owner (Model, User) {
        target_lower_cardinality = 1
        target_upper_cardinality = 1
    }

    Association group (Model, Group) {
        target_lower_cardinality = 1
        target_upper_cardinality = 1
    }

    Class Transformation : Model {}

    Class ModelTransformation : Transformation {}

    Class ActionLanguage : Transformation {}

    Class ManualOperation : Transformation {}

    Association transformInput (Model, Transformation) {
        name : String
    }
    Association transformOutput (Transformation, Model) {
        name : String
    }

    Association tracability (Model, Model) {
        type : String
    }

    Association semantics (instanceOf, ActionLanguage) {
        target_lower_cardinality = 1
        target_upper_cardinality = 1
    }
    Association typing (instanceOf, TypeMapping) {
        target_lower_cardinality = 1
        target_upper_cardinality = 1
    }

    Class Service {
        name : String
        port : String
    }
}

export CoreFormalism to models/CoreFormalism