public static HashSet <Action> CanAchive(Landmark l, Agent agent)
{
HashSet <Action> CanAchiveList = new HashSet <Action>();
foreach (GroundedPredicate gp in l.facts.Keys)
{
foreach (Action act in agent.m_actions)
{
if (act.HashEffects.Contains(gp))
{
CanAchiveList.Add(act);
}
}
}
return(CanAchiveList);
}
public bool publishsingelOrder()
{
if (isPublic)
{
return(true);
}
Landmark firstLandmark = EncryptedLandmark.ElementAt(0).Value;
foreach (var item in EncryptedLandmark.Values)
{
if (firstLandmark.Identical(item))
{
return(false);
}
}
return(true);
}
public void AddPrivatePredicate(GroundedPredicate gp, string name)
{
isPublic = false;
if (EncryptedLandmark[name] == null)
{
EncryptedLandmark[name] = new Landmark("Disjunctive", false);
EncryptedLandmark[name].AddFact(gp, "first_round");
EncryptedLandmark[name].index = index;
}
else
{
if (!EncryptedLandmark[name].facts.ContainsKey(gp))
{
EncryptedLandmark[name].AddFact(gp, "first_round");
}
}
}
public void AddPublicLandmark(Landmark l)
{
foreach (string ag in m_agents)
{
if (EncryptedLandmark[ag] == null)
{
l.index = index;
EncryptedLandmark[ag] = new Landmark(l.type, l.GoalLandmark);
}
foreach (var fact in l.facts)
{
if (!EncryptedLandmark[ag].facts.ContainsKey(fact.Key))
{
EncryptedLandmark[ag].AddFact(fact.Key, fact.Value);
}
}
}
}
public void AddPrivateLandmark(Landmark l, string name)
{
isPublic = false;
if (EncryptedLandmark[name] == null)
{
l.index = index;
EncryptedLandmark[name] = l;
}
else
{
foreach (var fact in l.facts)
{
if (!EncryptedLandmark[name].facts.ContainsKey(fact.Key))
{
EncryptedLandmark[name].AddFact(fact.Key, fact.Value);
}
}
}
}
public void AddPublicPredicate(GroundedPredicate gp)
{
foreach (string ag in m_agents)
{
if (EncryptedLandmark[ag] == null)
{
EncryptedLandmark[ag] = new Landmark("Disjunctive", false);
EncryptedLandmark[ag].AddFact(gp, "first_round");
EncryptedLandmark[ag].index = index;
}
else
{
if (!EncryptedLandmark[ag].facts.ContainsKey(gp))
{
EncryptedLandmark[ag].AddFact(gp, "first_round");
}
}
}
}
public static List <Landmark> FindPublicAndArtificialGoals(List <Agent> agents)
{
List <Landmark> PublicAndArtificialGoals = new List <Landmark>();
foreach (Agent agent in agents)
{
List <Landmark> agentsGoal = agent.GetPublicAndArtificialGoal();
for (int i = 0; i < agentsGoal.Count; i++)
{
Landmark newGoal = agentsGoal.ElementAt(i);
if (!PublicAndArtificialGoals.Contains(newGoal, new LandmarkEqualityComparer()))
{
PublicAndArtificialGoals.Add(newGoal);
}
}
}
return(PublicAndArtificialGoals);
}
public void SetIndex(int count)
{
index = count;
foreach (string ag in m_agents)
{
if (EncryptedLandmark[ag] == null)
{
EncryptedLandmark[ag] = new Landmark("FalseLandmark", false);
EncryptedLandmark[ag].GoalLandmark = isGoal;
EncryptedLandmark[ag].index = count;
EncryptedLandmark[ag].isPublic = isPublic;
EncryptedLandmark[ag].AddFact(new GroundedPredicate(Domain.FALSE_PREDICATE), "FalseLandmark");
}
else
{
EncryptedLandmark[ag].index = count;
EncryptedLandmark[ag].GoalLandmark = isGoal;
EncryptedLandmark[ag].isPublic = isPublic;
}
}
}
public void Merge(PrivacyPreservingLandmark ppLandmark)
{
if (!ppLandmark.isPublic)
{
isPublic = false;
}
foreach (var item in ppLandmark.EncryptedLandmark)
{
if (item.Value != null)
{
if (EncryptedLandmark[item.Key] == null)
{
EncryptedLandmark[item.Key] = item.Value;
}
else
{
// if (!isPublic)
// isPublic = false;
string name = item.Key;
Landmark l = item.Value;
if (EncryptedLandmark[name] == null)
{
l.index = index;
EncryptedLandmark[name] = l;
}
else
{
foreach (var fact in l.facts)
{
if (!EncryptedLandmark[name].facts.ContainsKey(fact.Key))
{
EncryptedLandmark[name].AddFact(fact.Key, fact.Value);
}
}
}
}
}
}
}
public Order(string typ, Landmark l1, Landmark l2)
{
type = typ;
lendmark1 = l1;
lendmark2 = l2;
}
public static List <Landmark> GetPublicLandmarks(GroundedPredicate goalFact, Agent courentAgent)
{
List <List <Action> > publicActionslandmarks = new List <List <Action> >();
List <Landmark> publicLandmark = new List <Landmark>();
Queue <Landmark> PrivacyPreservingQueue = new Queue <Landmark>();
Landmark l = new Landmark("pre", false);
l.AddPrivateFact(goalFact, "pre");
l.isPublic = false;
PrivacyPreservingQueue.Enqueue(l);
// publicLandmark.Add(l);
if (courentAgent.PublicPredicates.Contains(goalFact))
{
throw new Exception("it is not should to be public predicate");
}
foreach (Agent agent in agents)
{
if (agent.name.Equals(courentAgent.name))
{
agent.initPublicLandmarksDetect(l);
}
else
{
agent.initPublicLandmarksDetect(null);
}
}
while (PrivacyPreservingQueue.Count > 0)
{
Landmark ppLandmark = PrivacyPreservingQueue.Dequeue();
foreach (Agent agent in agents)
{
agent.Reset();
}
foreach (Agent agent in agents)
{
if (courentAgent.name.Equals(agent.name))
{
agent.SetLandmarkToExplorer(ppLandmark);
}
else
{
agent.SetLandmarkToExplorer((Landmark)null);
}
}
HashSet <GroundedPredicate> publicSet = new HashSet <GroundedPredicate>();
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.Detection();
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
}
}
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.WhatYoCanGet(publicSet);
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
flag2 = true;
}
}
}
}
List <Agent> relevantAgents = new List <Agent>();
foreach (Agent agent in agents)
{
List <Action> lAchievers = agent.CanGet();
if (lAchievers != null)
{
relevantAgents.Add(agent);
List <Action> publicActions = courentAgent.GetPublicActions(lAchievers);
if (publicActions.Count > 0)
{
if (ppLandmark.lAchievers != null)
{
ppLandmark.lAchievers.AddRange(publicActions);
}
else
{
ppLandmark.lAchievers = publicActions;
}
}
}
}
if (relevantAgents.Count == 1)
{
List <Landmark> newPPLandmarks = relevantAgents.ElementAt(0).DetectNewLocalLandmarks(false);
for (int i = 0; i < newPPLandmarks.Count; i++)
{
Landmark ppl = newPPLandmarks.ElementAt(i);
if (ppLandmark.mix)
{
publicLandmark.Remove(ppLandmark);
List <GroundedPredicate> publicFacts = courentAgent.GetPublicFacts(ppLandmark.facts.Keys.ToList());
foreach (GroundedPredicate publicFact in publicFacts)
{
ppl.AddPublicFact(publicFact, "pre");
}
ppl.lAchievers = new List <Action>();
ppl.lAchievers.AddRange(ppLandmark.lAchievers);
}
if (ppl.isPublic || ppl.mix)
{
publicLandmark.Add(ppl);
}
if (!ppl.isPublic || ppl.mix)
{
PrivacyPreservingQueue.Enqueue(ppl);
}
}
}
else
{
if (relevantAgents.Count > 1)
{
throw new Exception("only one agent can Achieve private landmark");
}
}
}
List <Landmark> ans = new List <Landmark>();
for (int i = 0; i < publicLandmark.Count; i++)
{
Landmark ppl = publicLandmark.ElementAt(i);
Landmark newl = new Landmark("Goal", true);
foreach (GroundedPredicate pgp in courentAgent.GetPublicFacts(ppl.facts.Keys.ToList()))
{
newl.AddPublicFact(pgp, "art-goal");
}
ans.Add(newl);
}
return(ans);
}
public static List <Landmark> DetectNewLandmarks(List <Action> PossibleBefore, HashSet <GroundedPredicate> usedFacts)
{
int indexProp = 1;
List <Landmark> newsPPLandmarks = new List <Landmark>();
bool flag2 = false;
if (PossibleBefore.Count > 0)
{
HashSet <GroundedPredicate> oldFacts = new HashSet <GroundedPredicate>();
Action firstAction = PossibleBefore[0];
foreach (GroundedPredicate prop in firstAction.HashPrecondition)
{
if (usedFacts.Contains(prop))
{
continue;
}
bool flag = true;
foreach (Action act in PossibleBefore)
{
if (!act.HashPrecondition.Contains(prop))
{
flag = false;
break;
}
}
if (flag)
{
Landmark newLandmark = new Landmark("fact", false);
newLandmark.AddFact(prop, "first_round");
indexProp++;
newsPPLandmarks.Add(newLandmark);
oldFacts.Add(prop);
usedFacts.Add(prop);
}
}
if (PossibleBefore.Count > 1)
{
firstAction = PossibleBefore[0];
}
PossibleBefore.RemoveAt(0);
foreach (GroundedPredicate prop in firstAction.HashPrecondition)
{
string type = prop.Name;
// if (!oldFacts.Contains(prop) && !usedFacts.Contains(prop))
{
int counter = 0;;
Landmark newLandmark = new Landmark("Disjunctive", false);
//newLandmark.worth = exploreLandmarks.worth - 10;
if (oldFacts.Contains(prop))
{
continue;
}
if (!usedFacts.Contains(prop))
{
newLandmark.AddFact(prop, "first_round");
}
foreach (Action act in PossibleBefore)
{
bool f = false;
foreach (GroundedPredicate prop2 in act.HashPrecondition)
{
if (prop2.Name == prop.Name)
{
if (!newLandmark.facts.ContainsKey(prop2) && !usedFacts.Contains(prop2))
{
newLandmark.AddFact(prop2, "first_round");
}
counter++;
f = true;
break;
}
}
}
if (counter == PossibleBefore.Count && newLandmark.facts.Count > 0)
{
newsPPLandmarks.Add(newLandmark);
foreach (GroundedPredicate gp in newLandmark.facts.Keys)
{
usedFacts.Add(gp);
}
}
}
}
}
return(newsPPLandmarks);
}
public static HashSet <Action> GetPublicActionsLandmarks2(GroundedPredicate goalFact, Agent courentAgent, out int dept, bool pos)
{
dept = 0;
string gpName = goalFact.Name + " " + goalFact.Constants[0];
List <Landmark> lowLayerLandmarks = new List <Landmark>();
if (courentAgent.PublicPredicates.Contains(goalFact))
{
throw new Exception();
}
Landmark firstLandmark = new Landmark("firstFact", false);
firstLandmark.lAchievers = new List <Action>();
firstLandmark.facts.Add(goalFact, "fact");
Queue <Landmark> queue = new Queue <Landmark>();
queue.Enqueue(firstLandmark);
HashSet <GroundedPredicate> usedFacts = new HashSet <GroundedPredicate>();
usedFacts.Add(goalFact);
while (queue.Count > 0)
{
Landmark courrentLandmark = queue.Dequeue();
HashSet <Action> CanAchiveList = CanAchive(courrentLandmark, courentAgent);
List <Action> privateSet = new List <Action>();
List <Action> PublicSet = new List <Action>();
foreach (Action act in CanAchiveList)
{
if (act.isPublic)
{
PublicSet.Add(act);
}
else
{
privateSet.Add(act);
}
}
courrentLandmark.lAchievers.AddRange(PublicSet);
//privateSet = courentAgent.GetUnPosibalePrivateAction(privateSet);
List <Landmark> newsPPLandmarks = DetectNewLandmarks(privateSet, usedFacts);
List <Landmark> tmp = new List <Landmark>();
foreach (Landmark l in newsPPLandmarks)
{
Landmark newLand = new Landmark(l.type, l.GoalLandmark);
foreach (var itemFact in l.facts)
{
string factName = itemFact.Key.Name + " " + itemFact.Key.Constants[0];
if (factName.Equals(gpName))
{
newLand.AddFact(itemFact.Key, itemFact.Value);
}
}
if (newLand.facts.Count > 0)
{
tmp.Add(newLand);
}
}
newsPPLandmarks = tmp;
if (newsPPLandmarks.Count > 0)
{
foreach (Landmark l in newsPPLandmarks)
{
l.lAchievers = new List <Action>();
l.lAchievers.AddRange(courrentLandmark.lAchievers);
queue.Enqueue(l);
}
}
else
{
lowLayerLandmarks.Add(courrentLandmark);
}
}
// List<List<Action>> achievers = new List<List<Action>>();
//achievers.Add(new List<Action>());
HashSet <Action> achievers = new HashSet <Action>();
foreach (Landmark l in lowLayerLandmarks)
{
foreach (Action act in l.lAchievers)
{
achievers.Add(act);
}
/* if(l.lAchievers.Count>0)
* {
* if(achievers.Count==0)
* {
* foreach (Action act in l.lAchievers)
* {
* achievers.Add(act);
* }
* }
* else
* {
* HashSet<Action> tmp = new HashSet<Action>();
* foreach(Action act in l.lAchievers)
* {
* if (achievers.Contains(act))
* tmp.Add(act);
* }
* achievers = tmp;
* }
* }*/
}
return(achievers);
}
public static KeyValuePair <List <List <Action> >, List <Landmark> > GetPublicActionsLandmarks(GroundedPredicate goalFact, Agent courentAgent, out int localDepth, bool pos)
{
List <List <Action> > publicActionslandmarks = new List <List <Action> >();
List <Landmark> publicLandmark = new List <Landmark>();
Queue <Landmark> PrivacyPreservingQueue = new Queue <Landmark>();
List <Landmark> tmpForTest = new List <Landmark>();
List <Landmark> tmpForDepthTest = new List <Landmark>();
Landmark l = new Landmark("pre", false);
l.AddPrivateFact(goalFact, "pre");
l.isPublic = false;
PrivacyPreservingQueue.Enqueue(l);
//publicLandmark.Add(l);
if (courentAgent.PublicPredicates.Contains(goalFact))
{
throw new Exception("it is not should to be public predicate");
}
foreach (Agent agent in agents)
{
if (agent.name.Equals(courentAgent.name))
{
agent.initPublicLandmarksDetect(l);
}
else
{
agent.initPublicLandmarksDetect(null);
}
}
List <Action> allAchievers;
int index = 0;
while (PrivacyPreservingQueue.Count > 0)
{
bool closeLandmark = false;
allAchievers = null;
Landmark ppLandmark = PrivacyPreservingQueue.Dequeue();
if (ppLandmark.facts.Count == 0)
{
Console.WriteLine("ddd");
}
bool f = true;
foreach (Landmark land in tmpForTest)
{
if (land.Equals(ppLandmark))
{
f = false;
break;
}
}
if (f)
{
Landmark nl = new Landmark("dd", false);
nl.facts = new Dictionary <GroundedPredicate, string>(ppLandmark.facts);
nl.index = ppLandmark.index;
tmpForTest.Add(nl);
}
foreach (Landmark land in tmpForDepthTest)
{
if (land.Identical(ppLandmark))
{
f = false;
break;
}
}
if (f)
{
tmpForDepthTest.Add(ppLandmark);
}
foreach (Agent agent in agents)
{
agent.Reset();
}
foreach (Agent agent in agents)
{
if (courentAgent.name.Equals(agent.name))
{
agent.SetLandmarkToExplorer(ppLandmark);
}
else
{
agent.SetLandmarkToExplorer((Landmark)null);
}
}
HashSet <GroundedPredicate> publicSet = new HashSet <GroundedPredicate>();
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.DetectionGlobal();
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
}
}
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.WhatYoCanGet(publicSet);
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
flag2 = true;
}
}
}
}
List <Agent> relevantAgents = new List <Agent>();
foreach (Agent agent in agents)
{
List <Action> lAchievers = agent.CanGet();
if (lAchievers != null)
{
relevantAgents.Add(agent);
allAchievers = lAchievers;
if (!ppLandmark.secondRound)
{
foreach (GroundedPredicate fact in ppLandmark.facts.Keys.ToList())
{
bool flag = false;
foreach (Action act in lAchievers)
{
if (act.HashEffects.Contains(fact))
{
flag = true;
break;
}
}
if (!flag)
{
ppLandmark.facts.Remove(fact);
}
}
List <Action> publicActions = courentAgent.GetPublicActions(lAchievers);
List <Action> privateAchievers = new List <Action>(allAchievers);
foreach (Action pubAct in publicActions)
{
privateAchievers.Remove(pubAct);
}
bool possibleInTheInitial = agent.PossibleInTheInitial(privateAchievers);
/* bool test = agent.PossibleInTheInitial(allAchievers);
* if (test && !possibleInTheInitial)
* {
* Console.WriteLine("***");
* }*/
if (ppLandmark.AchieversPossibleInTheInitial == false)
{
ppLandmark.AchieversPossibleInTheInitial = possibleInTheInitial;
}
if (publicActions.Count > 0)
{
if (ppLandmark.lAchievers != null)
{
ppLandmark.lAchievers.AddRange(publicActions);
}
else
{
ppLandmark.lAchievers = publicActions;
}
if (publicActions.Count == lAchievers.Count)
{
closeLandmark = true;
}
}
}
}
}
if (ppLandmark.lAchievers == null)
{
ppLandmark.lAchievers = new List <Action>();
}
if (allAchievers == null)
{
ppLandmark.secondRound = true;
}
if (!closeLandmark && ppLandmark.secondRound)
{
if (relevantAgents.Count == 1)
{
List <Landmark> newPPLandmarks = relevantAgents.ElementAt(0).DetectNewLocalLandmarks(true);
foreach (Landmark slave in newPPLandmarks)
{
slave.myMuster = ppLandmark;
slave.index = index;
index++;
}
for (int i = 0; i < newPPLandmarks.Count; i++)
{
Landmark ppl = newPPLandmarks.ElementAt(i);
ppl.AchieversPossibleInTheInitial = ppLandmark.AchieversPossibleInTheInitial;
ppl.lAchievers = new List <Action>(ppLandmark.lAchievers);
PrivacyPreservingQueue.Enqueue(ppl);
}
if (newPPLandmarks.Count == 0)
{
if (ppLandmark.lAchievers != null && ppLandmark.lAchievers.Count > 0)
{
if (ppLandmark.publicEffects != null)
{
ppLandmark.facts = new Dictionary <GroundedPredicate, string>();
foreach (GroundedPredicate gp in ppLandmark.publicEffects)
{
ppLandmark.facts.Add(gp, "pre");
}
publicLandmark.Add(ppLandmark);
}
}
}
}
else
{
if (relevantAgents.Count > 1)
{
throw new Exception("only one agent can Achieve private landmark");
}
if (relevantAgents.Count == 0)
{
if (ppLandmark.lAchievers != null && ppLandmark.lAchievers.Count > 0)
{
ppLandmark.facts = new Dictionary <GroundedPredicate, string>();
foreach (GroundedPredicate gp in ppLandmark.publicEffects)
{
ppLandmark.facts.Add(gp, "pre");
}
publicLandmark.Add(ppLandmark);
}
}
}
}
else
{
if (closeLandmark)
{
publicLandmark.Add(ppLandmark);
}
else
{
foreach (GroundedPredicate gp in ppLandmark.facts.Keys.ToList())
{
bool dell = true;
foreach (Action act in allAchievers)
{
if (ppLandmark.lAchievers == null || !ppLandmark.lAchievers.Contains(act))
{
if (act.HashEffects.Contains(gp))
{
dell = false;
break;
}
}
}
if (dell)
{
if (ppLandmark.publicEffects == null)
{
ppLandmark.publicEffects = new List <GroundedPredicate>();
}
ppLandmark.publicEffects.Add(gp);
ppLandmark.facts.Remove(gp);
}
else
{
bool flag = false;
if (ppLandmark.lAchievers != null)
{
foreach (Action act in ppLandmark.lAchievers)
{
if (act.HashEffects.Contains(gp))
{
flag = true;
break;
}
}
if (flag)
{
if (ppLandmark.publicEffects == null)
{
ppLandmark.publicEffects = new List <GroundedPredicate>();
}
ppLandmark.publicEffects.Add(gp);
}
}
}
}
ppLandmark.secondRound = true;
PrivacyPreservingQueue.Enqueue(ppLandmark);
}
}
}
if (pos)
{
int size = 0;
foreach (Landmark la in tmpForTest)
{
size += la.facts.Count();
}
AdvancedLandmarkProjectionPlaner.sizeOfRegressionTree += size;
}
HashSet <Landmark> dellPar = new HashSet <Landmark>();
foreach (Landmark land in tmpForDepthTest)
{
if (land.myMuster != null)
{
dellPar.Add(land.myMuster);
}
}
foreach (Landmark ldel in dellPar)
{
tmpForDepthTest.Remove(ldel);
}
int depth = 0;
foreach (Landmark land in tmpForDepthTest)
{
depth += land.depth;
}
localDepth = depth;
List <Landmark> landmarks = new List <Landmark>();
for (int i = 0; i < publicLandmark.Count; i++)
{
Landmark ppl = publicLandmark.ElementAt(i);
if (ppl.lAchievers != null)
{
landmarks.Add(ppl);
publicActionslandmarks.Add(ppl.lAchievers);
}
}
return(new KeyValuePair <List <List <Action> >, List <Landmark> >(publicActionslandmarks, landmarks));;
}
public static List <Agent> Landmarks_Detection(List <Agent> m_agents, bool full)
{
agents = m_agents;
PrivacyPreservingLandmark.m_agents = new List <string>();
foreach (Agent ag in agents)
{
PrivacyPreservingLandmark.m_agents.Add(ag.name);
}
necessaryPPOrders = new List <PPOrder>();
PrivacyPreservingLandmarks = new List <PrivacyPreservingLandmark>();
Queue <PrivacyPreservingLandmark> PrivacyPreservingQueue = new Queue <PrivacyPreservingLandmark>();
foreach (Agent agent in agents)
{
//agent.FirstIteration();
List <PrivacyPreservingLandmark> tmp = agent.FirstIteration();
if (full)
{
agent.fullDetection();
}
foreach (var item in tmp)
{
if (!PrivacyPreservingLandmarks.Contains(item))
{
if (item.toDevelop)
{
PrivacyPreservingQueue.Enqueue(item);
PrivacyPreservingLandmarks.Add(item);
}
else
{
PrivacyPreservingQueue.Enqueue(item);
PrivacyPreservingLandmarks.Add(item);
}
}
}
}
while (PrivacyPreservingQueue.Count > 0)
{
PrivacyPreservingLandmark ppLandmark = PrivacyPreservingQueue.Dequeue();
foreach (Agent agent in agents)
{
agent.Reset();
}
KeyValuePair <Landmark, string> ans = new KeyValuePair <Landmark, string>();
foreach (Agent agent in agents)
{
agent.SetLandmarkToExplorer(ppLandmark);
}
HashSet <GroundedPredicate> publicSet = new HashSet <GroundedPredicate>();
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.Detection();
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
}
}
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
foreach (Agent agent in agents)
{
HashSet <GroundedPredicate> tmp = agent.WhatYoCanGet(publicSet);
foreach (var gp in tmp)
{
if (!publicSet.Contains(gp))
{
publicSet.Add(gp);
flag2 = true;
}
}
}
}
List <Agent> relevantAgents = new List <Agent>();
foreach (Agent agent in agents)
{
List <Action> lAchievers = agent.CanGet();
if (lAchievers != null)
{
relevantAgents.Add(agent);
ppLandmark.SetAchievers(agent.name, lAchievers);
}
else
{
ppLandmark.SetAchievers(agent.name, lAchievers);
// ppLandmark.RemoveAgent(agent.name);
}
}
if (ppLandmark.ToString().Equals("Empty"))
{
PrivacyPreservingLandmarks.Remove(ppLandmark);
continue;
}
ppLandmark.TellAboutPublic(agents);
if (ppLandmark.toDevelop)
{
if (relevantAgents.Count == 1)
{
List <PrivacyPreservingLandmark> newPPLandmarks = relevantAgents.ElementAt(0).DetectNewLandmarks();
foreach (PrivacyPreservingLandmark ppl in newPPLandmarks)
{
bool insert = true;
foreach (PrivacyPreservingLandmark ppl2 in PrivacyPreservingLandmarks)
{
string str = PrivacyPreservingLandmark.Comparer(ppl, ppl2);
if (str == "First")
{
PrivacyPreservingLandmarks.Remove(ppl2);
List <PPOrder> delOrders = new List <PPOrder>();
foreach (PPOrder order in necessaryPPOrders)
{
if ((order.lendmark1.Equals(ppl2)) || (order.lendmark2.Equals(ppl2)))
{
delOrders.Add(order);
}
}
foreach (PPOrder ppo in delOrders)
{
necessaryPPOrders.Remove(ppo);
}
break;
}
if (str == "Second")
{
insert = false;
break;
}
if (str == "Identical")
{
insert = false;
break;
insert = false;
PPOrder tmpNecessaryOrder = new PPOrder("greedy-necessary", ppl2, ppLandmark);
necessaryPPOrders.Add(tmpNecessaryOrder);
break;
}
}
if (insert)
{
PrivacyPreservingLandmarks.Add(ppl);
PrivacyPreservingQueue.Enqueue(ppl);
PPOrder necessaryOrder = new PPOrder("greedy-necessary", ppl, ppLandmark);
necessaryPPOrders.Add(necessaryOrder);
}
}
}
else
{
List <PrivacyPreservingLandmark> newPPLandmarks;
Dictionary <string, List <PrivacyPreservingLandmark> > propNameToLandmarks = new Dictionary <string, List <PrivacyPreservingLandmark> >();
foreach (Agent relevantAget in relevantAgents)
{
newPPLandmarks = relevantAget.DetectNewLandmarks();
foreach (PrivacyPreservingLandmark ppl in newPPLandmarks)
{
if (!propNameToLandmarks.ContainsKey(ppl.type))
{
propNameToLandmarks.Add(ppl.type, new List <PrivacyPreservingLandmark>());
}
propNameToLandmarks[ppl.type].Add(ppl);
}
}
foreach (List <PrivacyPreservingLandmark> lppLandmarks in propNameToLandmarks.Values)
{
if (lppLandmarks.Count == relevantAgents.Count)
{
PrivacyPreservingLandmark tmpLandmark = PrivacyPreservingLandmark.MergeList(lppLandmarks);
bool insert = true;
foreach (PrivacyPreservingLandmark ppl2 in PrivacyPreservingLandmarks)
{
string str = PrivacyPreservingLandmark.Comparer(tmpLandmark, ppl2);
if (str == "First")
{
PrivacyPreservingLandmarks.Remove(ppl2);
List <PPOrder> delOrders = new List <PPOrder>();
foreach (PPOrder order in necessaryPPOrders)
{
if ((order.lendmark1.Equals(ppl2)) || (order.lendmark2.Equals(ppl2)))
{
delOrders.Add(order);
}
}
foreach (PPOrder ppo in delOrders)
{
necessaryPPOrders.Remove(ppo);
}
break;
}
if (str == "Second")
{
insert = false;
break;
}
if (str == "Identical")
{
insert = false;
break;
insert = false;
PPOrder tmpNecessaryOrder = new PPOrder("greedy-necessary", ppl2, ppLandmark);
necessaryPPOrders.Add(tmpNecessaryOrder);
break;
}
}
if (insert)
{
PrivacyPreservingLandmarks.Add(tmpLandmark);
PrivacyPreservingQueue.Enqueue(tmpLandmark);
PPOrder necessaryOrder = new PPOrder("greedy-necessary", tmpLandmark, ppLandmark);
necessaryPPOrders.Add(necessaryOrder);
}
}
}
}
}
}
int count = 0;
foreach (var ppl in PrivacyPreservingLandmarks)
{
ppl.SetIndex(count);
count++;
}
//List<Order> allReasonableorders = new List<Order>();
Dictionary <string, List <Order> > agentROrder = new Dictionary <string, List <Order> >();
foreach (Agent agent in agents)
{
List <Landmark> lLandmarks = new List <Landmark>();
List <Order> necessaryOrders = new List <Order>();
Dictionary <int, Landmark> mapTable = new Dictionary <int, Landmark>();
foreach (PrivacyPreservingLandmark ppLandmark in PrivacyPreservingLandmarks)
{
Landmark l = ppLandmark.GetAgentLandmark(agent.name);
lLandmarks.Add(l);
mapTable.Add(l.index, l);
}
foreach (PPOrder order in necessaryPPOrders)
{
if ((mapTable.ContainsKey(order.lendmark1.index)) && (mapTable.ContainsKey(order.lendmark2.index)))
{
Landmark l1 = mapTable[order.lendmark1.index];
Landmark l2 = mapTable[order.lendmark2.index];
Order newOrder = new Order("greedy-necessary", l1, l2);
necessaryOrders.Add(newOrder);
}
}
// PrivacyPreservingLandmarks.ElementAt(0).ToString();
List <Order> ans = agent.FindReasonableOrdering(lLandmarks, necessaryOrders, agents);
agentROrder.Add(agent.name, ans);
/* foreach (Order o in ans)
* {
* if (!allReasonableorders.Contains(o))
* {
* allReasonableorders.Add(o);
* }
*
* }*/
}
Dictionary <int, PrivacyPreservingLandmark> mapPPlandmark = new Dictionary <int, PrivacyPreservingLandmark>();
foreach (PrivacyPreservingLandmark ppLandmark in PrivacyPreservingLandmarks)
{
mapPPlandmark.Add(ppLandmark.index, ppLandmark);
}
Dictionary <string, List <Order> > newAgentROrder = new Dictionary <string, List <Order> >();
foreach (Agent agent in agents)
{
List <Order> localOrder = new List <Order>(agentROrder[agent.name]);
foreach (var item in agentROrder)
{
if (item.Key.Equals(agent.name))
{
continue;
}
foreach (Order rOrder in item.Value)
{
if (!localOrder.Contains(rOrder))
{
PrivacyPreservingLandmark ppl = mapPPlandmark[rOrder.lendmark2.index];
if (!ppl.achieversAgents.Contains(agent.name))
{
localOrder.Add(rOrder);
}
else
{
//localOrder.Add(rOrder);
Console.WriteLine(".............chack..............");
}
}
}
}
List <Order> del = new List <Order>();
foreach (Order o in localOrder)
{
Order newOrder = new Order("Reasonable", o.lendmark2, o.lendmark1);
if (localOrder.Contains(newOrder))
{
del.Add(newOrder);
del.Add(o);
}
}
foreach (Order dellOrder in del)
{
if (localOrder.Contains(dellOrder))
{
localOrder.Remove(dellOrder);
}
}
newAgentROrder.Add(agent.name, localOrder);
//allReasonableorders = new List<Order>();
//agent.SetReasonableOrdering(localOrder);
}
List <Order> allReasonableorders = new List <Order>();
if (newAgentROrder.Count > 0)
{
List <Order> first = newAgentROrder.ElementAt(0).Value;
foreach (Order o in first)
{
bool isShare = true;
foreach (var item in newAgentROrder)
{
if (!item.Value.Contains(o))
{
isShare = false;
continue;
}
}
if (isShare)
{
allReasonableorders.Add(o);
}
}
}
foreach (Agent agent in agents)
{
//allReasonableorders = new List<Order>();
agent.SetReasonableOrdering(allReasonableorders);
}
return(agents);
}
