[SalesForce] Error: Invalid conversion from runtime type List to List>

This seems similar to other "Can not cast List to List" questions, except in the other cases the culprit tended to be custom sObjects, whereas nothing like that is relevant here.

Why is this cast illegal? What additional checks do I have to add?

I do this after I make an API call to a 3rd party service, and I get back some JSON, which is a string, and then I pass the string into this function, to transform it into what I want:

public List<Map<String, Object>> deserializeJson(String privcoDataString) {
boolean badApiCall = false;
List<Map<String, Object>> deserializedResults = new List<Map<String, Object>>(); 
    Object objResponse = JSON.deserializeUntyped(privcoDataString);

    if (objResponse instanceof Map<String, Object>) {
        Map<String, Object> mapResponse = (Map<String, Object>)objResponse;

    System.debug('mapResponse.get(data)'); 
    System.debug(mapResponse.get('data')); 

        List<Map<String, Object>> possibledeserializedResults = (List<Map<String, Object>>)mapResponse.get('data');

    if(possibledeserializedResults == null) {
    badApiCall = true; 
        } else if (possibledeserializedResults.isEmpty()) {
    badApiCall = true; 
        } else {
    deserializedResults = possibledeserializedResults;
    }

    } else {
    badApiCall = true; 
}

if (badApiCall) {
    System.debug(objResponse);
    ApexPages.Message msgErr = new ApexPages.Message(ApexPages.Severity.ERROR, 'Search Failed! Sorry!');
    ApexPages.addmessage(msgErr);
    Map<String, Object> errorMap = new Map<String, Object>();
    errorMap.put('bad_api_call', true); 
    deserializedResults.add(errorMap); 
}

    return deserializedResults;
}

This line gives me an error:

List<Map<String, Object>> possibledeserializedResults = (List<Map<String, Object>>)mapResponse.get('data');

The error is:

Invalid conversion from runtime type List to List>

And yet, as you can see, I have not declared data to be a List yet. It should be an Object and then in this line I narrow cast it. But it doesn't work.

Where would the code get the idea that "data" is List, and even if that is true, why can't I then narrow cast that to List<Map<String, Object>>?

In this case, data is a List full of Map instances. So the conversion should be valid.

Best Answer

I agree with Rahul's comment that the following is probably the best you can do:

String payload = '{"data": [{"s": "a", "i": 1}]}';
Map<String, Object> deserialized = (Map<String, Object>)JSON.deserializeUntyped(payload);
List<Map<String, Object>> data = new List<Map<String, Object>>();
for (Object instance : (List<Object>)deserialized.get('data'))
    data.add((Map<String, Object>)instance);

Related Solutions

[SalesForce] apex String instanceof Object

TL;DR Pretty much the entire "Type" system that governs Maps, Sets, and Lists is broken. Do not trust instanceOf, use your own logical assessment to determine if something is safe or not.

The type system that governs the system usually works pretty well, but it has a flaw when it comes to collections and how they are determined to be the right "size" or not. In fact, it's pretty much broken.

Let's start with your example. Since m instanceOf Map<String, Object> is true, that means that the following code compiles:

// Map<String, String> is an instanceOf Map<String, Object>
Map<String, Object> m = new Map<String, String>();

However, if you try to use it the wrong way...

m.put('Hello', 5);

This code throws a TypeException, because 5 is not a String. In other words, the compiler's type checks are inverted; it allowed an assignment that was factually incorrect, because not all Object values are String values. Note that this is a runtime exception: the compiler failed to notice that you were doing something that was wrong.

It's broken in other ways, too. We already know that a String is an type of Object:

String s = 'Hello World';
// Compile error:
// Operation instanceof is always true since an instance of 
// String is always an instance of Object
System.debug(s instanceOf Object);

That means that Object can store every type of String. Right? Not according to the compiler:

// Does not compile
Map<String, String> m = new Map<String, Object>();

Wait, what? We can't store a String in an Object value? That can't be right?!

System.debug(new Map<String, Object>() instanceOf Map<String, String>);
// USER_DEBUG|[1]|DEBUG|false

So, we can try to store an Object in a String, but not a String in an Object. It's completely backwards. You can try this with other types, too:

System.debug(new Map<String, Date>() instanceOf Map<String, DateTime>);
System.debug(new Map<String, Integer>() instanceOf Map<String, Decimal>);
System.debug(new Map<String, Integer>() instanceOf Map<String, Long>);

All of these statements fail to compile with "X always instanceOf y" messages. Yet clearly that's not true. If you try to store any of the types on the left into a variable with the data type on the right, it will let you, but crash the moment you try and store a value outside the legal range of the object actually referenced in the code.

There's a whole class of really cool things we can't do because of this inverted type check, and there's plenty of opportunities for errors. I strongly suggest you avoid trusting instanceOf, and instead rely on your own logic to work through if a type is safe or not.

Also, you'll notice that we can't even cast Sets around. For example, neither of the following lines compile:

Set<String> s1 = new Set<Object>();
Set<Object> s2 = new Set<String>();

Finally, this bug also extends to custom classes/inheritance:

class c1 {

}
class c2 extends c1 {

}
// All C2s are C1s, but this won't compile
Map<String, c2> m1 = new Map<String, c1>();
// Not all C2s are C1s, but this compiles and can crash.
Map<String, c1> m2 = new Map<String, c2>();

[SalesForce] Invalid conversion from runtime type String to Double

If you are going to cast a variable, you’re most likely doing what’s known as a downcast. This means that you’re taking the Object and casting it into a more “specific” type of Object. Here’s an example:

Object aSentenceObject = 'This is just a regular sentence';
String aSentenceString = (String)aSentenceObject;

also you can use "upcast"

String aSentenceString = 'This is just another regular sentence';
Object aSentenceObject = (Object)aSentenceString;

as you can see from example, for doing casting you have to have inheritance between classes. Double and String don't have such inheritance.

use Double.valueOf method

line.put(targetField, Double.valueOf(fieldValue));

Best Answer

Related Solutions

[SalesForce] apex String instanceof Object

[SalesForce] Invalid conversion from runtime type String to Double

Related Topic