Merge pull request #20 from entityc/bobgarner/added-map-template-variable-type

Adding Map template variable type

Author: bobgarner

docs/emc/EMC_foundation.md

@@ -9,6 +9,7 @@ The model classes of this type are intended to provide support for foundation ty
 | Class | Description |
 |-----|-----|
 |[`MFArray`](#class_MFArray)|This class represents a ordered array of objects. To create an empty array you can use: `$[let myList = @[]@]` then can use these methods on that variable (`myList` in this example) to access the array functionality that is exposed here.|
+|[`MFMap`](#class_MFMap)|This class represents a map of objects. To create an empty map you can use: `$[let myMap = @{}@]` then can use these methods on that variable (`myMap` in this example) to access the map functionality that is exposed here.|
 |[`MFSet`](#class_MFSet)|This class represents a unique set of objects. You cannot create an object of this class in template code, however, some classes have methods that will return such an object. Since this class does not offer methods to manipulate the object, it should be considered immutable. You can iterate through the items in a set using the `foreach` instruction. For example: `$[foreach item in mySet] ... $[/foreach]` would allow you to process each item(object) in the set.|
 
 <a name="class_MFArray"></a>
@@ -122,6 +123,123 @@ Returns all the values of the array. When iterating this array with a `foreach`
 
 
 
+<a name="class_MFMap"></a>
+## MFMap Class
+
+This class represents a map of objects. To create an empty map you can use: `$[let myMap = @{}@]` then can use these methods on that variable (`myMap` in this example) to access the map functionality that is exposed here.
+
+The following properties and methods are available for this class:
+
+<hr/>
+
+#### `MFMap` **`clear`**
+
+This method removes all items in the map.
+
+<hr/>
+
+#### `boolean containsKey(Object key)`
+
+Indicates if the map contains the specified key.
+
+| Parameter | Description |
+|-----|-----|
+|`Object key` | The key of which to determine its presence in the map. |
+
+<hr/>
+
+#### `boolean containsValue(Object value)`
+
+Indicates if the map contains the specified value.
+
+| Parameter | Description |
+|-----|-----|
+|`Object value` | The object of which to determine its presence in the map. |
+
+<hr/>
+
+#### `MFMap` **`copy`**
+
+Allows you to make a copy of this map. Since it returns the new map you can chain other map methods after this one.
+
+<hr/>
+
+#### `int` **`count`**
+
+Returns the number of items in the map.
+
+<hr/>
+
+#### `Object get(Object key)`
+
+Returns the value in the map by its specified key.
+
+| Parameter | Description |
+|-----|-----|
+|`Object key` | The key. |
+
+<hr/>
+
+#### `boolean` **`isEmpty`**
+
+Indicates if the map is empty (no items).
+
+<hr/>
+
+#### `Collection` **`keys`**
+
+Returns all the keys of the map
+
+<hr/>
+
+#### `MFMap put(Object key, Object o)`
+
+Allows you to add an object to this array. The `do` template instruction can be used to do this (e.g., `$[do array.add(obj)]`. This method returns the array itself so you can chain other array methods after this one.
+
+| Parameter | Description |
+|-----|-----|
+|`Object key` | The key to put to the map. |
+|`Object o` | The object to set to the map. |
+
+<hr/>
+
+#### `MFMap putAll(MFMap otherMap)`
+
+Allows you to add all elements of another map to this map. The `do` template instruction can be used to do  this (e.g., `$[do map.putAll(otherMap)]`. This method returns the map itself so you can chain other map methods after this one.
+
+| Parameter | Description |
+|-----|-----|
+|`MFMap otherMap` | The other map to add to this map. |
+
+<hr/>
+
+#### `MFMap remove(Object key)`
+
+Allows you to remove a specified entry from the map based on its key. This method returns the map itself so you can chain other map methods after this one.
+
+| Parameter | Description |
+|-----|-----|
+|`Object key` | The key to remove from this map. |
+
+<hr/>
+
+#### `MFMap remove(Object key, Object o)`
+
+Allows you to remove a specified object from the map based on its key. This method returns the map itself so you can chain other map methods after this one.
+
+| Parameter | Description |
+|-----|-----|
+|`Object key` | The key to remove from this map. |
+|`Object o` | The object to remove from this map. |
+
+<hr/>
+
+#### `Collection` **`values`**
+
+Returns all the values of the map. When iterating this array of values with a `foreach` you do **not** need to use this method.
+
+
+
 <a name="class_MFSet"></a>
 ## MFSet Class
 

src/main/antlr4/org/entityc/compiler/transform/template/TemplateGrammer.g4

@@ -289,6 +289,7 @@ expression
     | expression bop='||' expression
     | <assoc=right> expression bop='?' expression Colon expression
     | arraySpecifier
+    | mapSpecifier
     ;
 
 expressionList
@@ -299,6 +300,18 @@ arraySpecifier
     : '@[' expressionList? ']@'
     ;
 
+mapItem
+    : expression ':' expression
+    ;
+
+mapItemList
+    : mapItem (',' mapItem)*
+    ;
+
+mapSpecifier
+    : MapOpen mapItemList? MapClose
+    ;
+
 filterParamExpression
     : OpenParen expression CloseParen
     | identifier

src/main/antlr4/org/entityc/compiler/transform/template/TemplateLexer.g4

@@ -60,6 +60,8 @@ Pipe             : '|' ;
 Outputs          : '->' ;
 ArrayOpen        : '@[' ;
 ArrayClose       : ']@' ;
+MapOpen          : '@{' ;
+MapClose         : '}@' ;
 Dollar           : '$' ;
 File             : 'file' ;
 IfDoesNotExist   : 'ifdoesnotexist' ;
@@ -139,6 +141,7 @@ DIGIT            : [0-9];
 VERSION_NUM      : (INTEGER '.' INTEGER '.' INTEGER) ;
 FLOAT            : (INTEGER '.' DIGIT*) ;
 IDENT            : (LETTER|'_') (LETTER|DIGIT|'_'|'#')* ;
+//FILTER_IDENT     : (LETTER) (LETTER|'_')* ; we should use this for filters but have to wait until I sort out issue with intellij plugin
 STRING           : '"' (ESC | ~["\\])* '"' ;
 fragment ESC     : '\\' ["\bfnrt] ;
 DOT              : '.' ;
@@ -201,6 +204,8 @@ VarIsEqual          : IsEqual -> type(IsEqual) ;
 VarNotEqual         : NotEqual -> type(NotEqual) ;
 VarArrayOpen        : ArrayOpen -> type(ArrayOpen) ;
 VarArrayClose       : ArrayClose -> type(ArrayClose) ;
+VarMapOpen          : MapOpen -> type(MapOpen) ;
+VarMapClose         : MapClose -> type(MapClose) ;
 
 VarDomainType       : DomainType -> type(DomainType) ;
 VarEntityType       : EntityType -> type(EntityType) ;

src/main/java/org/entityc/compiler/ASTVisitor.java

@@ -700,6 +700,9 @@ public Object visitRepository(EntityLanguageParser.RepositoryContext ctx) {
             }
             repository.setType(type);
         }
+        if (currentSpace() == null) {
+            ECLog.logFatal("Space must be defined before configuration.");
+        }
         currentSpace().addRepository(repository);
 
         return repository;

src/main/java/org/entityc/compiler/EntityCompiler.java

@@ -226,7 +226,12 @@ public static void RunProtoc(MTRoot root, MTConfiguration configuration) {
             processBuilder.redirectError(errorOutputFile);
             try {
                 if (EntityCompiler.isVerbose()) {
-                    ECLog.logInfo("Running PROTOC...");
+                    StringBuilder sb = new StringBuilder();
+                    for (String cmd : processBuilder.command())
+                    {
+                        sb.append(cmd + " ");
+                    }
+                    ECLog.logInfo("Running PROTOC: " + sb);
                 }
 //                ECLog.logInfo("Running PROTOC: " + processBuilder.command());
                 Process process = processBuilder.start();

src/main/java/org/entityc/compiler/model/domain/MTNamingMethod.java

@@ -11,6 +11,7 @@
 public enum MTNamingMethod {
 
     STANDARD("standard", ""),
+    UNDERSCORE("underscore", "_"),
     UNDERSCORE_LOWERCASE("underscoreLowercase", "_"),
     UNDERSCORE_UPPERCASE("underscoreUppercase", "_"),
     LOWERCASE("lowercase", ""),
@@ -46,6 +47,8 @@ public String rename(String name) {
         switch (this) {
             case STANDARD:
                 return name;
+            case UNDERSCORE:
+                return ECStringUtil.CamelToSeparator(name,delimiter);
             case UNDERSCORE_LOWERCASE:
             case DASHES_LOWERCASE:
                 return ECStringUtil.CamelToSeparator(name, delimiter).toLowerCase();

src/main/java/org/entityc/compiler/model/entity/MTEntity.java

@@ -502,7 +502,7 @@ public boolean hasBitFields() {
         category = ModelMethodCategory.RELATIONSHIP,
         description = "Indicates whether this entity defines any relationships.")
     public boolean hasRelationships() {
-        return relationships.size() > 0 || secondaryRelationshipMap.size() > 0;
+        return relationships.size() > 0 || (secondaryRelationshipMap != null && secondaryRelationshipMap.size() > 0);
     }
 
     @ModelMethod(

src/main/java/org/entityc/compiler/model/foundation/MFMap.java

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2019-2022 The EntityC Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.md file in the project root.
+ */
+
+package org.entityc.compiler.model.foundation;
+
+import org.entityc.compiler.doc.annotation.ModelClass;
+import org.entityc.compiler.doc.annotation.ModelClassType;
+import org.entityc.compiler.doc.annotation.ModelMethod;
+import org.entityc.compiler.doc.annotation.ModelMethodParameter;
+import org.entityc.compiler.util.ECLog;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+@ModelClass(type = ModelClassType.FOUNDATION,
+        description = "This class represents a map of objects. "
+                      + "To create an empty map you can use: `$[let myMap = @{}@]` then can use these methods on that "
+                      + "variable (`myMap` in this example) to access the map functionality that is exposed here.")
+public class MFMap extends MFObject {
+
+    private final HashMap map = new HashMap();
+
+    public MFMap() {
+        super();
+    }
+
+    public MFMap(Map map) {
+        super();
+        map.putAll(map);
+    }
+
+    @ModelMethod(description =
+            "Returns all the keys of the map")
+    public Collection getKeys() {
+        return map.keySet();
+    }
+
+    @ModelMethod(description =
+            "Returns all the values of the map. When iterating this array of values with a `foreach` you do "
+            + "**not** need to use this method.")
+    public Collection getValues() {
+        return map.values();
+    }
+
+    @ModelMethod(description =
+            "Allows you to add an object to this array. The `do` template instruction can be used to do "
+            + "this (e.g., `$[do array.add(obj)]`. This method returns the array itself so you "
+            + "can chain other array methods after this one.")
+    public MFMap put(
+            @ModelMethodParameter(description = "The key to put to the map.")
+            Object key,
+            @ModelMethodParameter(description = "The object to set to the map.")
+            Object o) {
+        map.put(key, o);
+        return this;
+    }
+
+    @ModelMethod(description = "Allows you to make a copy of this map. Since it returns the new map "
+                               + "you can chain other map methods after this one.")
+    public MFMap copy() {
+        MFMap newMap = new MFMap();
+        newMap.map.putAll(this.map);
+        return newMap;
+    }
+
+    @ModelMethod(description =
+            "Allows you to add all elements of another map to this map. The `do` template instruction "
+            + "can be used to do  this (e.g., `$[do map.putAll(otherMap)]`. This method returns the "
+            + "map itself so you can chain other map methods after this one.")
+    public MFMap putAll(
+            @ModelMethodParameter(description = "The other map to add to this map.")
+            MFMap otherMap) {
+        map.putAll(otherMap.map);
+        return this;
+    }
+
+    @ModelMethod(description = "Allows you to remove a specified object from the map based on its key. This method returns the "
+                               + "map itself so you can chain other map methods after this one.")
+    public MFMap remove(
+            @ModelMethodParameter(description = "The key to remove from this map.")
+            Object key,
+            @ModelMethodParameter(description = "The object to remove from this map.")
+            Object o) {
+        map.remove(key, o);
+        return this;
+    }
+
+    @ModelMethod(description = "Allows you to remove a specified entry from the map based on its key. This method returns the "
+                               + "map itself so you can chain other map methods after this one.")
+    public MFMap remove(
+            @ModelMethodParameter(description = "The key to remove from this map.")
+            Object key) {
+        map.remove(key);
+        return this;
+    }
+
+    @ModelMethod(description = "This method removes all items in the map.")
+    public MFMap clear() {
+        map.clear();
+        return this;
+    }
+
+    @ModelMethod(description = "Returns the value in the map by its specified key.")
+    public Object get(
+            @ModelMethodParameter(description = "The key.")
+            Object key) {
+        return map.get(key);
+    }
+
+    @ModelMethod(description = "Indicates if the map is empty (no items).")
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @ModelMethod(description = "Indicates if the map contains the specified key.")
+    public boolean containsKey(
+            @ModelMethodParameter(description = "The key of which to determine its presence in the map.")
+            Object key) {
+        return map.containsKey(key);
+    }
+
+    @ModelMethod(description = "Indicates if the map contains the specified value.")
+    public boolean containsValue(
+            @ModelMethodParameter(description = "The object of which to determine its presence in the map.")
+            Object value) {
+        return map.containsValue(value);
+    }
+
+    @ModelMethod(description = "Returns the number of items in the map.")
+    public int getCount() {
+        return map.size();
+    }
+}