Changeset 8 for src/main/java/geniusweb/profilesserver/websocket/GetProfileSocket.java

Timestamp:

01/28/20 10:19:55 (5 years ago)

Author:

bart

Message:

Update 28 jan 2020

File:

• src/main/java/geniusweb/profilesserver/websocket/GetProfileSocket.java (modified) (6 diffs)

src/main/java/geniusweb/profilesserver/websocket/GetProfileSocket.java

@@ -2 +2 @@
 
 import java.io.IOException;
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import javax.websocket.OnClose;
@@ -10 +20 @@
 import javax.websocket.server.ServerEndpoint;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-
+import geniusweb.bidspace.AllBidsList;
+import geniusweb.bidspace.BidsWithUtility;
+import geniusweb.issuevalue.Bid;
+import geniusweb.profile.DefaultPartialOrdering;
+import geniusweb.profile.PartialOrdering;
 import geniusweb.profile.Profile;
+import geniusweb.profile.utilityspace.LinearAdditive;
+import geniusweb.profilesserver.Jackson;
 import geniusweb.profilesserver.ProfilesFactory;
 import geniusweb.profilesserver.events.ChangeEvent;
+import tudelft.utilities.immutablelist.FixedList;
+import tudelft.utilities.immutablelist.ImmutableList;
 import tudelft.utilities.listener.Listener;
 
@@ -22 +39 @@
  * profiles is sent. For each new websocket the server will create one of this
  * but they all share one {@link ProfilesFactory}.
+ * 
+ * <p>
+ * Query string: the websocket allows query strings.
+ * <ul>
+ * <li>partial</li> a query key that is assigned a natural number N (0 or
+ * larger). If set, the profile is converted into a Partial Profile with the
+ * given number of points. If N>0, the maximum utility bid is included .If N>1,
+ * the minimum utility bid is included. The other bids are picked at random.
+ * This filtering mechanism only works if the profile is {@link LinearAdditive}
+ * space.
  */
 @ServerEndpoint("/websocket/get/{domain}/{profile}")
 public class GetProfileSocket {
-        private final static ObjectMapper jackson = new ObjectMapper();
         private Profile prof = null; // the latest that we sent to client.
 
@@ -33 +59 @@
         private Listener<ChangeEvent> changeListener;
         private Session session;
+        private Map<String, String> params = Collections.emptyMap();
 
         @OnOpen
@@ -40 +67 @@
                 this.profilename = domain + "/" + profile;
 
+                if (session.getQueryString() != null) {
+                        List<String> paramstrings = Arrays
+                                        .asList(session.getQueryString().split("&"));
+                        params = paramstrings.stream().map(str -> str.split("=")).collect(
+                                        Collectors.toMap(vals -> vals[0], vals -> vals[1]));
+                }
                 changeListener = new Listener<ChangeEvent>() {
                         @Override
@@ -56 +89 @@
                         prof = newprof;
                         try {
-                                session.getBasicRemote()
-                                                .sendText(jackson.writeValueAsString(prof));
+                                session.getBasicRemote().sendText(
+                                                Jackson.instance().writeValueAsString(filter(prof)));
                         } catch (Exception e) {
                                 e.printStackTrace();
                         }
                 }
+        }
+
+        private Profile filter(Profile prof1) {
+                String partial = params.get("partial");
+                if (partial == null) {
+                        return prof1;
+                }
+                if (!(prof1 instanceof PartialOrdering))
+                        throw new IllegalArgumentException(
+                                        "profile must be partialordering but got " + prof);
+                PartialOrdering profile = (PartialOrdering) prof1;
+                final int numbids = Integer.parseInt(partial);
+                if (numbids < 0)
+                        throw new IllegalArgumentException("parameter partial must be >=0");
+
+                ImmutableList<Bid> allbids;
+                if (profile instanceof DefaultPartialOrdering)
+                        allbids = new FixedList<Bid>(
+                                        ((DefaultPartialOrdering) profile).getBids());
+                else
+                        allbids = new AllBidsList(prof.getDomain());
+
+                if (BigInteger.valueOf(numbids).compareTo(allbids.size()) > 0)
+                        throw new IllegalArgumentException("Request for " + numbids
+                                        + " exceeds number of bids in the space " + allbids.size());
+
+                BidsWithUtility info = new BidsWithUtility((LinearAdditive) prof);
+                Set<Bid> selected = new HashSet<>();
+                if (numbids > 0) {
+                        selected.add(info.getExtremeBid(true));
+                }
+                if (numbids > 1) {
+                        selected.add(info.getExtremeBid(false));
+                }
+                Random random = new Random();
+                for (int nr = 2; nr < numbids; nr++) {
+                        int attempt = 0;
+                        Bid bid;
+                        do {
+                                long i = random.nextInt(allbids.size().intValue());
+                                bid = allbids.get(BigInteger.valueOf(i));
+                        } while (attempt++ < 10 && selected.contains(bid));
+                        selected.add(bid);
+                }
+
+                // put comparison info for these bids in the map
+                Map<Bid, Set<Bid>> isBetterMap = new HashMap<>();
+                for (Bid bid : selected) {
+                        Set<Bid> worse = selected.stream().filter(
+                                        otherbid -> profile.isPreferredOrEqual(bid, otherbid)
+                                                        && !profile.isPreferredOrEqual(otherbid, bid))
+                                        .collect(Collectors.toSet());
+                        isBetterMap.put(bid, worse);
+                }
+                return new DefaultPartialOrdering(
+                                prof.getName() + "-partial-" + numbids, prof.getDomain(),
+                                prof.getReservationBid(), isBetterMap);
         }