You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@causeway.apache.org by "danhaywood (via GitHub)" <gi...@apache.org> on 2023/09/21 22:53:48 UTC

[GitHub] [causeway] danhaywood commented on a diff in pull request #1887: CAUSEWAY-3597: adds mixin to download .columnOrder.txt file

danhaywood commented on code in PR #1887:
URL: https://github.com/apache/causeway/pull/1887#discussion_r1333673675


##########
core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/feature/ObjectAssociation.java:
##########
@@ -157,6 +165,43 @@ public static final Predicate<ObjectAssociation> staticallyVisible(final Where w
             };
         }
 
+        static Where whereContextFor(final Identifier memberIdentifier) {
+            return memberIdentifier.getType().isAction()
+                    ? STANDALONE_TABLES
+                    : PARENTED_TABLES;
+        }
+
+        /**
+         * Returns true if no {@link HiddenFacet} is found that vetoes visibility.
+         * <p>
+         * However, if its a 1-to-Many, whereHidden={@link Where.ALL_TABLES} is used as default
+         * when no {@link HiddenFacet} is found.
+         * @apiNote an alternative would be to prime the meta-model with fallback facets,
+         *      however the current approach is more heap friendly
+         */
+        public static Predicate<ObjectAssociation> visibleAccordingToHiddenFacet(
+                final Identifier memberIdentifier) {
+            val whereContext = whereContextFor(memberIdentifier);
+            return (final ObjectAssociation assoc) -> assoc.lookupFacet(HiddenFacet.class)
+                    .map(WhereValueFacet.class::cast)
+                    .map(WhereValueFacet::where)
+                    // in case its a 1-to-Many, whereHidden=ALL_TABLES is the default when not specified otherwise
+                    .or(()->assoc.getSpecialization().right().map(__->Where.ALL_TABLES))
+                    .stream()
+                    .noneMatch(whereHidden -> whereHidden.includes(whereContext));
+        }
+
+        public static Predicate<ObjectAssociation> referencesParent(
+                final @Nullable ObjectSpecification parentSpec) {
+            if(parentSpec == null) {
+                return _Predicates.alwaysFalse();
+            }
+            return (final ObjectAssociation assoc) -> {
+                    if(assoc.isCollection()) return false; // never true for collections
+                    return Facets.hiddenWhereMatches(Where.REFERENCES_PARENT::equals).test(assoc)
+                            && parentSpec.isOfType(assoc.getElementType());

Review Comment:
   As you noticed, I did just refactor the code, but yes, there's a ticket I raised recently regarding the fact that REFERENCES_PARENT doesn't seem to be honoured.
   
   Actually I think the correct formulation may be assoc.getReturnType().isOfType(parentSpec), because the assoc in question is of the elements of the collection, and we want to exclude those that point back to (have a return type of) the parent owning the collection.
   
   



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: dev-unsubscribe@causeway.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org