[SalesForce] How to add list of list and list

To note:

• I_ws is a single instance of WarrantyServices__c
• DSlst is a list<Driver__c>
• PSlst is a single instance of Part_Services__c

Since they are all different types, you can't just create a list of all of them together. I suggest creating a subclass that includes all the types you'd like to return.

Note: You can always create constructors and instance methods for any subclass you create.

Example:

public class WarrentyResponse{
    public WarrantyServices__c warrentyServices {get;set;}
    public list<Driver__c> driverList {get;set;}
    public Part_Services__c partServices {get;set;}

    public WarrentyResponse(){
        this.warrentyServices = new WarrantyServices__c();
        this.driverList = new list<Driver__c>();
        this.partServices = new Part_Services__c();
    }//END init()

    // another constructor
    public WarrentyResponse(list<Driver__c> driverList){
        this.warrentyServices = new WarrentyServices();
        this.driverList = driverList;        //<--------- what's different
        this.partServices = new Part_Services__c();
    }//END init(list<Driver__c> driverList)


    // Example of an instance method
    public integer getNumberOfDrivers(){
        return driverList.size();
    }//END getNumberOfDrivers()
}//END WarrentyResponse

public WarrentyResponse GetResponse( WarrantyServices__c I_ws, tnsPartservicesresponsev13.PartServicesResponse tnPSResponse, tnsDriverdetailsresponsev13.DriverDetailsResponse tnDRes){ 
    WarrentyResponse returnResponse=new WarrentyResponse();

    if(tnPSResponse != NULL) {        
          for(tnsPartservicesv13.PartServices ps : tnPSResponse.PartServices.PartServices) {            
               Part_Services__c p = new Part_Services__c();           
               returnResponse.partServices=p;               
          }
    } else if(tnDRes !=NULL) {
          for(tnsDriverdetailsv13.DriverDetails Dd : tnDRes.DriverDetails.DriverDetails){
               List<Driver__c> DSlst = new List<Driver__c>();               
               returnResponse.driverList=DSlst ;
          }
    }
    returnResponse.warrentyServices=I_ws;

    return returnResponse;
}

Update:

Try using this wrapper class instead:

public class TransformOfferSet{

    public List<WrapperService> I_WarrantyService {get;set;}
    public List<WrapperService> II_WarrantyService {get;set;}
    List<WarrantyServices__c> WSLst {get;set;}
    List<Driver__c> DSlst {get;set;}
    List<Part_Services__c> PSlst {get;set;}

    public TransformOfferSet(){
        this.I_WarrantyService = new list<WrapperService>();
        this.II_WarrantyService = new list<WrapperService>();
        this.WSLst = new list<WarrantyServices__c>();
        this.DSlst = new list<Driver__c>();
        this.PSlst = new list<Part_Services__c>();
    }//END init()
}//END TransformOfferSet

Then in your method(s), have the return type be TransformOfferSet, create a new TransformOfferSet instance in your method, do whatever calculations you need, and then set the TransformOfferSet variables appropriately.

What's great about creating a subclass to hold data is you can use TransformOfferSet as both a return type AND an input parameter. Therefore, you can collect/set all the TransformOfferSet variable over multiple methods:

Brief Example:

public TransformOfferSet applyEverything(){
    return applyParts(applyDrivers(applyWarrentyServices()));
}//END applyEverything     

public TransformOfferSet applyWarrentyServices(/* whatever you need */){
    TransformOfferSet returnClass = new TransformOfferSet();

    // do all your data-gathering and calculations
    list<WrapperService> myI_WarrantyService = new list<WrapperService>();
    list<WrapperService> myII_WarrantyService = new list<WrapperService>();
    list<WrapperServices__c> myWSLst = new list<WrapperServices__c>();
    //  ... more calculations...

    returnClass.I_WarrantyService = myI_WarrantyService;
    returnClass.II_WarrantyService = myII_WarrantyService;
    returnClass.WSLst = myWSLst;

    return returnClass;
}//END applyWarrentyServices

public TransformOfferSet applyDrivers(TransformOfferSet offer /*, other params */){
    // gather data
    list<Driver__c> myDrivers = new list<Driver__c>();
    // do desired calculations

    offer.DSlst = myDrivers;

    return offer;
}//END applyDrivers

public TransformOfferSet applyParts(TransformOfferSet offer /*, other params */){
    // gather data
    list<Part_Services__c> myParts = new list<Part_Services__c>();
    // do desired calculations

    offer.PSlst = myParts;

    return offer;
}//END applyParts

I believe your only option is to re-query. Unless you want to do some crazy serialization hijinks like I laid out in this other post. Basically, you would probably have to do something like the following:

class Proxy
{
    final List<Child__c> records;
    Proxy(List<Child__c> children) { records = children; }
    Integer totalSize { get { return records.size(); } }
    Boolean done = true;
}

// elsewhere...
Map<String, Object> data = parent.getPopulatedFieldsAsMap();
data.put('ChildRelationshipName__r', new Proxy(allChildren));
parent = (Parent__c)JSON.deserialize(JSON.serialize(data), Parent__c.class);