[SalesForce] Is it possible to convert Map> to Map> without a loop

As a Salesforce developer, I am frequently working with Maps and am looking to abstract the process of generating maps from SObject lists.

I've created the following helper class:

private class MapBySharedKeyExtractor {
    SObjectField keyField;
    XAP_PRED_SObjectPredicateIntf predicate;

    MapBySharedKeyExtractor(SObjectField keyField, XAP_PRED_SObjectPredicateIntf predicate) {
        this.keyField = keyField;
        this.predicate = predicate;
    }

    public Map<Object, List<SObject>> extractFrom(List<SObject> homogeneousSObjectList) {
        if (homogeneousSObjectList == null || homogeneousSObjectList.isEmpty()) {
            return null;
        }

        Map<Object, List<SObject>> sObjectListByKeyMap = new Map<Object, List<SObject>>();
        for (SObject sObj : homogeneousSObjectList) {
            if (this.predicate.isTrueFor(sObj)) {
                Object key = sObj.get(this.keyField);
                if (!sObjectListByKeyMap.containsKey(key)) {
                    sObjectListByKeyMap.put(key, new List<SObject>());
                }
                sObjectListByKeyMap.get(key).add(sObj);
            }
        }
        return sObjectListByKeyMap;
    }
}

This is the prediate interface:

public interface XAP_PRED_SObjectPredicateIntf {
    Boolean isTrueFor(SObject sObj);
}

However, as the final step of this journey, I would like to be able to change the generated Map into concrete types, so I would like (for example) to have a helper method:

  public static Map<Id, List<SObject>> mapBySpecifiedIdField(List<SObject> homogeneousSObjectList, SObjectField idField) {
        Map<Object, List<SObject>> sObjectListBySpecifiedObjectMap
                = new MapBySharedKeyExtractor(idField, new XAP_PRED_SObjectFieldHasNonNullValue(idField))
                .extractFrom(homogeneousSObjectList);

        String mapType = 'Map<Id, List<' + homogeneousSObjectList[0].getSObjectType() + '>>';
        Map<Id, List<SObject>> concreteSObjectListByIdMap = (Map<Id, List<SObject>>) Type.forName(mapType).newInstance();
        concreteSObjectListByIdMap.putAll(sObjectListBySpecifiedObjectMap);
        return concreteSObjectListByIdMap;
    }

However this fails because this is invalid:

 concreteSObjectListByIdMap.putAll(sObjectListBySpecifiedObjectMap);

Is there any way I can make this work without iterating through sObjectListBySpecifiedObjectMap and casting each key individually?

Best Answer

No. You can't convert key types without a loop. The Map structure is not flexible in this way. The List type is a bit more flexible, however, and so you can make this minor simplification, as concretely typing the List<SObject> offers few tangible benefits unless you plan to upsert it.

Map<Id, List<SObject>> concreteSObjectListByIdMap = new Map<Id, List<SObject>>();

No need for dynamic Type.forName instantiation.

Related Solutions

[SalesForce] Map Where Key is a different SObject

A generic pattern for the sort of logic I think you are aiming to create is this:

for (CampaignMember cm : [
        SELECT Id, CampaignId, AccountID_Formula__c
        FROM CampaignMember
        WHERE AccountID_Formula__c = :accIds
        ORDER BY Name
        ]){
    List<CampaignMember> l = accountCampaignMap.get(cm.AccountID_Formula__c);
    if (l == null) {
        l = new List<CampaignMember>();
        accountCampaignMap.put(cm.AccountID_Formula__c, l);
    }
    l.add(cm);
}

This will result in each list being in the order of the CampaignMember.Name.

[SalesForce] How to deserialize into interface type when concrete type is unknown

I think you should revisit the idea of using an abstract class rather than an interface. You can use the former to enforce a contract.

public class Demo
{
    final String typeName;
    public String getSomeProperty() { return typeName; }
    public abstract List<User> doStuff();
}

Granted, this definition cannot be constructed either, but deserialization into this type is allowed.

Demo instance = (Demo)JSON.deserialize('{}', Demo.class);
system.debug(instance.getSomeProperty());

And the contract gets enforced, for if you try to save a class which doesn't implement the method:

class Foo extends Demo { }

You get a compile-time error:

Class Foo must implement the abstract method: List<User> Demo.doStuff()

As a benefit, properties like typeName can be preserved throughout the serialization round-trip.

Here's a simple demonstration of that process. First define this extension:

public class Foo extends Demo
{
    final String profileName;
    public override List<User> doStuff()
    {
        return [
            SELECT Username FROM User
            WHERE Profile.Name = :profileName
        ];
    }
}

Now run this script:

String payload = '{"typeName": "Foo", "profileName": "System Administrator"}';
Map<String, Object> controllerData = (Map<String, Object>)JSON.deserializeUntyped(payload);
String controllerType = (String)controllerData.get('typeName');

Demo controller;
if (controllerType != null)
{
    controller = (Demo)JSON.deserialize(payload, Type.forName(controllerType));
    system.debug(controller.doStuff());
}

As far as why your repo works in aura but not in a pure Apex context, it looks like the system acts similarly to Visualforce, treating methods prefixed with get as properties and adding them to the serialization (since the end result is indecipherable from { get; set; } notation). If you had named your method retrieveName instead of getName, I suspect it would not have worked in aura either. You can hack around it with mimicry along the lines of:

public class MyClass
{
    final String name = getName();
    public String getName() { return 'MyClass'; }
}

But I suspect that's not a tenable long-term solution.

Best Answer

Related Solutions

[SalesForce] Map Where Key is a different SObject

[SalesForce] How to deserialize into interface type when concrete type is unknown

Related Topic