¿Devolver una matriz de asignaciones que reflejen el estado global entre asociaciones de estructuras?

Estoy buscando una construcción que sea algo así como "devolver una lista de pares de valores clave", que creo que se implementaría como una matriz de asignaciones. ¿Está bien?

Es decir, me gustaría una estructura de datos que contenga una lista de (clave, valor) que usaré como un estado global que vincula algunas estructuras para asociarlas con otras.

Lo que quiero decir es algo como:

// so I have place structs
struct Place {
  uint8 placeid;
  string nameOfPlace;
  ...etc
}

// and a place can contain no more than 1 banner.    
// banners have all been to a place, but they aren't necessarily
// in a place right now. They may have been replaced with another 
// banner.
struct Banner {
  uint8 bannerid;
  uint8 placeAt; // this must match a placeid
  string thingTheBannerSays;
  uint8 timestamp;
}

Place[] places;                        // list all places
mapping(uint8 => Place)  placesById    // given an id, return the place
Banner[] banners;
mapping(uint8 => Banner)  bannersById  // given an id, return the place

// what's missing for me is a data structure
// with global state of [(place0,bannerN),(place1,bannerM)] 
// for all places.  This is what I'm looking for.

function listBannersAtPlacesRightNow() returns (???? arrayOfMappings) {
  ??? mappings[] = arrayOfMappings
  for(uint8 i =0; i < places.length; i++) {
     maxTime[i] = 0;       // declare this correctly
     idWhereMaxTime[i] = 0; // gross, would rather be null
     for(uint8 j=0; j < banners.length; j++) {
        if(banners[j].timestamp > maxTime[i]) {
          maxTime[i] = banners[j].timestamp // high water ;
          idWhereMaxTime[i] = banners[j];
        }
       }
     arrayOfMappings[i] = (places[i], idWheremaxTime[i]);
   }
 return arrayOfMappings;
 }

Lo siento, soy nuevo en esto, pero si no está claro, en palabras, me gustaría alguna variable para mantener el estado global que dice "Soy un lugar, puedo tener 0 o 1 banners. Aquí hay una lista de todos los lugares y sus pancartas actuales. Las pancartas se pueden vincular exactamente a un lugar y nunca reutilizarse".

Cuasi-pitón feo que podría aclarar la cuasi solidez fea, esto sería algo así como:

places = [{"placeid": 0, "nameofplace": "home"}, {"placeid":1, "nameofplace": "center"}]

banners = [
{"bannerid": 0, "placeAt": 0, "thingthebannersays": "hello!"},
{"bannerid": 1, "placeAt": 0, "thingthebannersays": "hello again from home!"},
{"bannerid": 2, "placeAt": 0, "thingthebannersays": "this replaces 1!"},
{"bannerid": 3, "placeAt": 1, "thingthebannersays": "this is at center!"}]

bannerAtPlaces = [(0,2), #place 0 has current banner 2
                  (1,3)  #place 1 has banner 3
]

def setBannerAtPlaces(placeid, bannerid):
  # this updates bannerAtPlaces according to some rules
  # such as the most-recent timestamp given in the solidity
  # section

# BUT If I wanted to see which places contained which banners, I'd just
# print(bannerAtPlaces).  This is the call I'm looking to repeat
# in solidity.

Todo esto surge porque prefiero que la estructura de Place contenga un campo para bannerid, pero desafortunadamente, quiero que Place pueda tener 0 banners, y parece que no puedo inicializar un valor nulo para eso --- Yo debe estar por defecto en bannerid = 0. Pero bannerid==0es un bannerid real. No puede estar en dos lugares a la vez, ya está en otro lugar y no puede ser el banner predeterminado en todos los lugares nuevos.

El motivo de una lista que especifique los estados globales sería representar esto fácilmente en el navegador, como una galería que muestra todos los pares (Lugar, Banner).

Ahora estoy viendo una pregunta similar aquí .