private void InitializeModalityFrequency(Random r)
{
using (DataTable dt = new DataTable())
{
dt.Columns.Add("Frequency", typeof(int));
dt.Columns.Add("AverageSeriesPerStudy", typeof(double));
dt.Columns.Add("StandardDeviationSeriesPerStudy", typeof(double));
dt.Columns.Add("AverageImagesPerSeries", typeof(double));
dt.Columns.Add("StandardDeviationImagesPerSeries", typeof(double));
DataGenerator.EmbeddedCsvToDataTable(typeof(DicomDataGenerator), "DicomDataGeneratorModalities.csv", dt);
ModalityFrequency = new BucketList <ModalityStats>();
int idx = 0;
foreach (DataRow dr in dt.Rows)
{
string modality = (string)dr["Modality"];
ModalityFrequency.Add((int)dr["Frequency"],
new ModalityStats(
modality,
(double)dr["AverageSeriesPerStudy"],
(double)dr["StandardDeviationSeriesPerStudy"],
(double)dr["AverageImagesPerSeries"],
(double)dr["StandardDeviationImagesPerSeries"],
r
));
ModalityIndexes.Add(modality, idx++);
}
}
}
public void InsertBucketList(BucketList bucketList) //return ActionResult
{
//if (bucketList == null)
// return NotFound();
_bucketList.InsertOne(bucketList);
//return CreatedAtRoute("GetById", new { id = bucketList.Id }, bucketList);
}
private void InitializeHourOfDay(Random r)
{
//Provenance:
//select DATEPART(HOUR,StudyTime),work.dbo.get_aggregate_value(count(*)) from CT_Godarts_StudyTable group by DATEPART(HOUR,StudyTime)
HourOfDay = new BucketList <int>();
HourOfDay.Add(1, 1);
HourOfDay.Add(4, 1);
HourOfDay.Add(5, 1);
HourOfDay.Add(6, 1);
HourOfDay.Add(8, 15);
HourOfDay.Add(9, 57);
HourOfDay.Add(10, 36);
HourOfDay.Add(11, 41);
HourOfDay.Add(12, 51);
HourOfDay.Add(13, 55);
HourOfDay.Add(14, 54);
HourOfDay.Add(15, 42);
HourOfDay.Add(16, 44);
HourOfDay.Add(17, 42);
HourOfDay.Add(18, 33);
HourOfDay.Add(19, 1);
HourOfDay.Add(20, 7);
HourOfDay.Add(21, 5);
HourOfDay.Add(22, 8);
}
public void RandomPrefixDistributionTest()
{
Contact dummyContact = new Contact(new VirtualProtocol(), ID.Zero);
((VirtualProtocol)dummyContact.Protocol).Node = new Node(dummyContact, new VirtualStorage());
List <int> contactsAdded = new List <int>();
100.ForEach(() =>
{
ID ourID = ID.RandomIDInKeySpace;
BucketList bucketList = new BucketList(ourID, dummyContact);
3200.ForEach(() =>
{
ID id = ID.RandomIDInKeySpace;
if (id != ourID)
{
Contact contact = new Contact(new VirtualProtocol(), id);
((VirtualProtocol)contact.Protocol).Node = new Node(contact, new VirtualStorage());
bucketList.AddContact(contact);
}
});
int contacts = bucketList.Buckets.Sum(b => b.Contacts.Count);
contactsAdded.Add(contacts);
});
double avg = contactsAdded.Average();
double stdev = contactsAdded.Select(n => (double)n).StdDev();
Assert.IsTrue(contactsAdded.Average().ApproximatelyEquals(1900, 200), "Unexpected distribution: avg = " + avg);
Assert.IsTrue(stdev.ApproximatelyEquals(800, 100), "Bad distribution: stdev = " + stdev);
}
/// <param name="table">the table to be anonymized, the first attribute
/// in the DataTable has to be a unique id</param>
/// <param name="qid">QI indecies</param>
/// <param name="hierarchies">domain generalization hierarchies</param>
public Mondrian(DataTable table, List <int> qid, List <IHierarchy> hierarchies)
{
this.table = table;
this.qid = qid;
this.hierarchies = hierarchies;
result = new BucketList();
}
public void DistributionTestForEachPrefix()
{
Contact dummyContact = new Contact(new VirtualProtocol(), ID.Zero);
((VirtualProtocol)dummyContact.Protocol).Node = new Node(dummyContact, new VirtualStorage());
Random rnd = new Random();
StringBuilder sb = new StringBuilder();
byte[] buffer = new byte[20];
160.ForEach((i) =>
{
BucketList bucketList = new BucketList(new ID(BigInteger.Pow(new BigInteger(2), i)), dummyContact);
3200.ForEach(() =>
{
rnd.NextBytes(buffer);
Contact contact = new Contact(new VirtualProtocol(), new ID(buffer));
((VirtualProtocol)contact.Protocol).Node = new Node(contact, new VirtualStorage());
bucketList.AddContact(contact);
});
int contacts = bucketList.Buckets.Sum(b => b.Contacts.Count);
sb.Append(i + "," + contacts + CRLF);
});
File.WriteAllText("prefixTest.txt", sb.ToString());
}
public static void Main()
{
var normalList = new NormalList <int>();
var bucketList = new BucketList <int>();
for (int i = 0; i < 1000000; i++)
{
normalList.Add(i);
bucketList.Add(i);
}
MeasureTime(() =>
{
for (int i = 0; i < 400000; i++)
{
normalList.Remove(0);
}
}, "normal list removing");
MeasureTime(() =>
{
for (int i = 0; i < 400000; i++)
{
bucketList.Remove(0);
}
}, "bucket list removing");
}
public void RandomIDDistributionTest()
{
Contact dummyContact = new Contact(new VirtualProtocol(), ID.Zero);
((VirtualProtocol)dummyContact.Protocol).Node = new Node(dummyContact, new VirtualStorage());
Random rnd = new Random();
byte[] buffer = new byte[20];
List <int> contactsAdded = new List <int>();
100.ForEach(() =>
{
rnd.NextBytes(buffer);
BucketList bucketList = new BucketList(new ID(buffer), dummyContact);
3200.ForEach(() =>
{
rnd.NextBytes(buffer);
Contact contact = new Contact(new VirtualProtocol(), new ID(buffer));
((VirtualProtocol)contact.Protocol).Node = new Node(contact, new VirtualStorage());
bucketList.AddContact(contact);
});
int contacts = bucketList.Buckets.Sum(b => b.Contacts.Count);
contactsAdded.Add(contacts);
});
Assert.IsTrue(contactsAdded.Average().ApproximatelyEquals(720, 20), "Unexpected distribution.");
Assert.IsTrue(contactsAdded.Select(n => (double)n).StdDev().ApproximatelyEquals(10, 2), "Bad distribution");
}
/// <param name="table">the table to be anonymized, the first attribute
/// in the DataTable has to be a unique id</param>
/// <param name="qid">QI indecies</param>
/// <param name="hierarchies">domain generalization hierarchies</param>
public Mondrian(DataTable table, List<int> qid, List<IHierarchy> hierarchies)
{
this.table = table;
this.qid = qid;
this.hierarchies = hierarchies;
result = new BucketList();
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BucketList bucketList = db.BucketLists.Find(id);
var cust = db.Customers.Single(c => c.Id == bucketList.CustomerID);
var serv = db.ServiceProviders.Single(s => s.Id == bucketList.ServiceProviderID);
if (cust.EmailId != User.Identity.Name || serv.EmailId != User.Identity.Name)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (bucketList == null)
{
return(HttpNotFound());
}
if (bucketList.Completed)
{
flag = 1;
}
var cust1 = db.Customers.Where(cu => cu.Id == bucketList.CustomerID);
var serv1 = db.BucketLists.Where(ser => ser.ServiceProviderID == bucketList.ServiceProviderID);
foreach (BucketList bc in serv1)
{
bc.ServiceProviderID = servicepid;
}
ViewBag.CustomerID = new SelectList(cust1, "Id", "FirstName");
ViewBag.ServiceProviderID = new SelectList(serv1, "Id", "FirstName");
return(View(bucketList));
}
public override BucketList Run()
{
var result = new BucketList();
var generalizedBucketList = base.Run();
foreach (var bucket in generalizedBucketList)
{
var privateBucket = new Bucket();
foreach (var tuple in bucket)
{
if (Int32.Parse(tuple.GetValue(tuple.GetNumberOfAttributes() - 1)) == 1)
{
tuple.RemoveAttribute(tuple.GetNumberOfAttributes() - 1);
privateBucket.Add(tuple);
}
if (privateBucket.Count > 0)
{
privateBucket.node = bucket.node;
}
}
if (privateBucket.Count > 0)
{
result.Add(privateBucket);
}
}
return(result);
}
public ActionResult Create([Bind(Include = "ID,DateAdded,Description,EmailId,Address_1,Address_2,City,State,Zip,Completed,CustomerID,ServiceProviderID,slotbooked")] BucketList bucketList)
{
//bucketList.DateAdded = DateTime.Now;
bucketList.EmailId = User.Identity.Name;
//bucketList.ServiceProviderID = servicepid;
if (ModelState.IsValid)
{
db.BucketLists.Add(bucketList);
UpdateSlotInfo(bucketList.DateAdded, bucketList.slotbooked, bucketList.ServiceProviderID);
maketransaction(bucketList.CustomerID);
db.SaveChanges();
var service = db.ServiceProviders.Single(s => s.Id == bucketList.ServiceProviderID);
var provide = db.Services.Single(p => p.id == service.ServiceID);
sendEmail(service.EmailId, provide.ServiceName, bucketList.ID, bucketList.DateAdded, bucketList.slotbooked).Wait();
return(RedirectToAction("Details", "Customers", new { id = bucketList.CustomerID }));
}
if (Spam.spamflag == 1)
{
bucredirect = 1;
return(RedirectToAction("Index"));
}
var cust = db.Customers.Where(cu => cu.EmailId == User.Identity.Name);
var serv = db.ServiceProviders.Where(ser => ser.Id == servicepid);
ViewBag.DateAdded = slotDate.Date;
ViewBag.slotbooked = sTime;
ViewBag.CustomerID = new SelectList(cust, "Id", "FirstName");
ViewBag.ServiceProviderID = new SelectList(serv, "Id", "FirstName");
return(View(bucketList));
}
public async Task AddActivityInBucketList()
{
//Arrange
var activityType = ActivityTypeFactory.Default();
var city = CityFactory.Default();
var activity = ActivityFactory.Default(city.Id, activityType.Id);
BucketList bucket = null;
await ExecuteDatabaseAction(async (doFestContext) =>
{
await doFestContext.ActivityTypes.AddAsync(activityType);
await doFestContext.Cities.AddAsync(city);
await doFestContext.Activities.AddAsync(activity);
await doFestContext.SaveChangesAsync();
bucket = await doFestContext
.BucketLists
.FirstOrDefaultAsync(x => x.UserId == AuthenticatedUserId);
});
//Act
var response = await HttpClient.PostAsync($"/api/v1/bucketlists/{bucket.Id}/activities/{activity.Id}", null);
//Assert
response.IsSuccessStatusCode.Should().BeTrue();
}
private void InitNode(IPEndPoint ipEndpoint)
{
BucketList = new BucketList(Id, 20);
Storage = new MemoryNodeStorage(20);
_server = new KadNodeServer(ipEndpoint);
_server.Start(this);
}
public async Task <IActionResult> OnGetAsync(int?bucketListId)
{
if (_userService.UserIsNotAuthenticated(User))
{
return(RedirectToPage("../AuthError"));
}
BucketListSL = await _bucketListService.PopulateBucketListDropDownListOrderedByNameAsync(_context, _userService.GetUserId(User), false, true);
if (bucketListId != null)
{
SelectedBucketList = await _bucketListService.GetBLByIDAsync(_context, bucketListId);
if (SelectedBucketList == null)
{
return(NotFound());
}
if (_userService.BucketListIsNotBelongingToUser(User, SelectedBucketList))
{
return(Forbid());
}
SelectedBLElements = await _bucketListService.PopulateSelectedBLElementsListWithProgressionOrderedByNameAsync(_context, (int)bucketListId, false);
}
return(Page());
}
public async Task FindAllNotificationsUserTest()
{
// Arrange
var activityType = ActivityTypeFactory.Default();
var activity = ActivityFactory.Default(CityId, activityType.Id);
var notification = NotificationFactory.Default(activity.Id);
activity.AddNotification(notification);
BucketList bucketList = null;
BucketListActivity bucketListActivity = null;
await ExecuteDatabaseAction(async (doFestContext) =>
{
await doFestContext.ActivityTypes.AddAsync(activityType);
await doFestContext.SaveChangesAsync();
bucketList = await doFestContext.BucketLists.FirstOrDefaultAsync(entity => entity.UserId == AuthenticatedUserId);
if (bucketList != null)
{
bucketListActivity = new BucketListActivity(bucketList.Id, activity.Id);
await doFestContext.BucketListActivities.AddAsync(bucketListActivity);
await doFestContext.Activities.AddAsync(activity);
await doFestContext.SaveChangesAsync();
}
});
// Act
var response = await HttpClient.GetAsync("api/v1/notifications");
// Assert
response.IsSuccessStatusCode.Should().BeTrue();
var notifications = await response.Content.ReadAsAsync <IList <Notification> >();
notifications.Should().HaveCount(1);
}
public async Task <IActionResult> OnGetAsync(int?bucketListId)
{
if (_userService.UserIsNotAuthenticated(User))
{
return(RedirectToPage("../AuthError"));
}
if (bucketListId == null)
{
return(NotFound());
}
BucketList = await _bucketListService.GetBLByIDAsync(_context, bucketListId);
if (BucketList == null)
{
return(NotFound());
}
if (_userService.BucketListIsNotBelongingToUser(User, BucketList))
{
return(Forbid());
}
return(Page());
}
public async Task <BucketList> ListBucketsAsync(ListBucketsOptions listBucketsOptions)
{
var listBucketsOptionsSWIG = listBucketsOptions.ToSWIG();
_listOptions.Add(listBucketsOptionsSWIG);
using (SWIG.UplinkBucketIterator bucketIterator = await Task.Run(() => SWIG.storj_uplink.uplink_list_buckets(_access._project, listBucketsOptionsSWIG)).ConfigureAwait(false))
{
using (SWIG.UplinkError error = SWIG.storj_uplink.uplink_bucket_iterator_err(bucketIterator))
{
if (error != null && !string.IsNullOrEmpty(error.message))
{
throw new BucketListException(error.message);
}
}
BucketList bucketList = new BucketList();
while (SWIG.storj_uplink.uplink_bucket_iterator_next(bucketIterator))
{
var bucket = SWIG.storj_uplink.uplink_bucket_iterator_item(bucketIterator);
bucketList.Items.Add(Bucket.FromSWIG(bucket, _access._project));
}
return(bucketList);
}
}
public int GetMeasurement(BucketList bucketList)
{
int result = 0;
foreach (var bucket in bucketList)
result += (bucket.Count * bucket.Count());
return result;
}
public int GetMeasurementOfPublicTable(BucketList bucketList)
{
int result = 0;
foreach (var bucket in bucketList)
result += (bucket.SensitiveValueCount() * bucket.SensitiveValueCount());
return result;
}
/// <summary>
/// Nikhil Gupta
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult BookService(int?id)
{
BucketList bk = new BucketList();
bk.DateAdded = slotDate;
bk.slotbooked = sTime;
return(RedirectToAction("BkBook", "BucketLists", new { id = id, DateAdded = bk.DateAdded, slotbooked = bk.slotbooked }));
}
private void InitializeImageType()
{
ImageType = new BucketList <string>();
ImageType.Add(96, "ORIGINAL\\PRIMARY\\AXIAL");
ImageType.Add(1, "ORIGINAL\\PRIMARY\\LOCALIZER");
ImageType.Add(3, "DERIVED\\SECONDARY");
}
public ActionResult DeleteConfirmed(int id)
{
BucketList bucketList = db.BucketLists.Find(id);
db.BucketLists.Remove(bucketList);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task ReplaceBucketList(BucketList updatedBucketList)
{
var collection = GetCollection <BucketList>(Const.MongoDbConst.CollectionBucketList);
var filter = Builders <BucketList> .Filter.Eq(s => s.ListId, updatedBucketList.ListId);
await collection.ReplaceOneAsync(filter, updatedBucketList);
}
private void UpdateLastSeen(ContactNode node)
{
var bucket = BucketList.GetBucket(node.Id);
if (bucket.Contains(node.Id))
{
bucket.SeenNow(node);
}
}
public static void Seed(this ModelBuilder modelBuilder)
{
#region UserType
var userTypes = new List <UserType>()
{
new UserType("Admin", "Full access"),
new UserType("Normal user", "Normal access"),
};
modelBuilder.Entity <UserType>().HasData(userTypes);
#endregion
#region Admin
var admin = new User("DoFestAdmin",
"*****@*****.**",
CreateHash("passwordAdmin"),
userTypes[0].Id,
null
);
modelBuilder.Entity <User>().HasData(admin);
var bucketListAdmin = new BucketList(admin.Id, "Admin bucketList");
modelBuilder.Entity <BucketList>().HasData(bucketListAdmin);
#endregion
var assembly = Assembly.GetExecutingAssembly();
var resourceName = assembly.GetManifestResourceNames().Single(str => str.EndsWith("Activities.json"));
string result = string.Empty;
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
result = reader.ReadToEnd();
}
var activityData = JObject.Parse(result)["Activities"];
#region City
var citiesData = (from activity in activityData select(string) activity["Location"]).Distinct();
var cities = citiesData.Select(cityName => new City(cityName)).ToList();
modelBuilder.Entity <City>().HasData(cities);
#endregion
#region ActivityType
var activityTypeData = (from activity in activityData select(string) activity["Category"]).Distinct();
var activityTypes =
activityTypeData.Select(activityTypeName => new ActivityType(activityTypeName)).ToList();
modelBuilder.Entity <ActivityType>().HasData(activityTypes);
#endregion
var cityMap = cities.ToDictionary(city => city.Name, city => city.Id);
var activityTypeMap = activityTypes.ToDictionary(aType => aType.Name, aType => aType.Id);
#region Activity
var activities = activityData !
.Select(activity => new Activity(activityTypeMap[((string)activity["Category"]) !],
public int GetMeasurement(BucketList bucketList)
{
int result = 0;
foreach (var bucket in bucketList)
{
result += (bucket.Count() * (bucket.node.SumOfLevels()));
}
return result;
}
private void UpdateLastSeen(NodeMessage msg)
{
var bucket = BucketList.GetBucket(msg.OriginatorId);
if (bucket.Contains(msg.OriginatorId))
{
bucket.SeenNow(bucket.GetNode(msg.OriginatorId));
}
}
private void InitNode(IPEndPoint ipEndpoint)
{
_server = new NodeServer(ipEndpoint);
_server.OnMaliciousMessage += CheckPossibleMaliciousMessage;
_tokenStorage = new TokenStorage();
BucketList = new BucketList(Id, 20);
Storage = new MemoryInfoHashStorage(20);
_server.Start(this);
}
public int GetMeasurementOfPublicTable(BucketList bucketList)
{
int result = 0;
foreach (var bucket in bucketList)
{
int count = bucket.SensitiveValueCount();
result += (count * (bucket.node.SumOfLevels()));
}
return result;
}
public int GetMeasurement(BucketList bucketList)
{
int result = 0;
foreach (var bucket in bucketList)
{
result += (bucket.Count() * (bucket.node.SumOfLevels()));
}
return(result);
}
public void AddToList(string activity)
{
var bucketlist = new BucketList
{
Activity = activity
};
bucketListContext.Add(bucketlist);
bucketListContext.SaveChanges();
}
public async Task <Result <string, Error> > Register(RegisterModel registerModel)
{
var user = await _userRepository.GetByEmail(registerModel.Email);
if (user != null)
{
return(Result.Failure <string, Error>(ErrorsList.EmailExists));
}
user = await _userRepository.GetByUsername(registerModel.Username);
if (user != null)
{
return(Result.Failure <string, Error>(ErrorsList.UsernameExists));
}
var city = await _cityRepository.GetById(registerModel.City);
if (city == null)
{
return(Result.Failure <string, Error>(ErrorsList.InvalidCity));
}
var userType = await _userTypeRepository.GetByName("Normal user");
var newStudent = new Student(registerModel.Name,
registerModel.Age,
registerModel.Year,
city.Id
);
var newUser = new User(registerModel.Username,
registerModel.Email,
_passwordHasher.CreateHash(registerModel.Password),
userType.Id,
newStudent.Id
);
newUser.AddStudent(newStudent);
await _userRepository.Add(newUser);
await _userRepository.SaveChanges();
var newBucketList = new BucketList(newUser.Id,
registerModel.BucketListName
);
await _bucketListRepository.Add(newBucketList);
await _bucketListRepository.SaveChanges();
return(Result.Success <string, Error>("User registered"));
}
public void BucketSplitTest()
{
Contact dummyContact = new Contact(new VirtualProtocol(), ID.Zero);
((VirtualProtocol)dummyContact.Protocol).Node = new Node(dummyContact, new VirtualStorage());
BucketList bucketList = new BucketList(ID.RandomIDInKeySpace, dummyContact);
Constants.K.ForEach(() => bucketList.AddContact(new Contact(null, ID.RandomIDInKeySpace)));
bucketList.AddContact(new Contact(null, ID.RandomIDInKeySpace));
Assert.IsTrue(bucketList.Buckets.Count > 1, "Bucket should have split into two or more buckets.");
}
public void UniqueIDAddTest()
{
Contact dummyContact = new Contact(new VirtualProtocol(), ID.Zero);
((VirtualProtocol)dummyContact.Protocol).Node = new Node(dummyContact, new VirtualStorage());
BucketList bucketList = new BucketList(ID.RandomIDInKeySpace, dummyContact);
Constants.K.ForEach(() => bucketList.AddContact(new Contact(null, ID.RandomIDInKeySpace)));
Assert.IsTrue(bucketList.Buckets.Count == 1, "No split should have taken place.");
Assert.IsTrue(bucketList.Buckets[0].Contacts.Count == Constants.K, "K contacts should have been added.");
}
/*
* It returns a delta present BucketList with as less generalization as possible.
*/
public BucketList GetBestPermutedTable(BucketList bucketList)
{
BucketList bestTable = new BucketList();
for (int i = 0; i < bucketList.Count(); i++)
{
List<Node> nodeList = MakeNodeList(bucketList[i].node);
var anonymizedBucket = GeneralizeAndPermute(min, max, bucketList[i], qid, nodeList, hierarchies);
bestTable.Add(anonymizedBucket);
}
return bestTable;
}
/// <summary>
/// Convert a BucketList to a DataTable and adds group id's for each tuple.
/// </summary>
/// <returns>the converted DataTable</returns>
public DataTable ConvertBucketListToDataTable(BucketList bt)
{
DataTable dt = table.Clone();
dt.Columns.Add("GroupId", typeof(int));
int groupId = 0;
foreach (var bucket in bt)
{
foreach (var tuple in bucket)
{
string[] values = tuple.GetValues();
List<object> r = new List<object>();
r.AddRange(values);
r.Add(groupId);
dt.Rows.Add(r.ToArray());
}
groupId++;
}
return dt;
}
/// <summary>
/// Tuple partitioning is dane by K-Mondrian.
/// This method doesn't generalize the tuples, but permutes the sensitive values
/// within each QI column inside every bucket.
/// </summary>
/// <returns>a one-attribute-per-column-sliced BucketList</returns>
public override BucketList Run()
{
var result = new BucketList();
var generalizedBucketList = base.Run();
foreach (var bucket in generalizedBucketList)
{
//undo all of the generalizations
for (int i = 0; i < bucket.node.generalizations.Count; i++)
{
bucket.node.generalizations[i] = 0;
}
var permutedBucket = GeneralizeBucket(bucket, hierarchies);
foreach (int i in qid)
permutedBucket.PermuteValues(i);
result.Add(permutedBucket);
}
return result;
}
public override BucketList Run()
{
var result = new BucketList();
var generalizedBucketList = base.Run();
foreach (var bucket in generalizedBucketList)
{
var privateBucket = new Bucket();
foreach (var tuple in bucket)
{
if (Int32.Parse(tuple.GetValue(tuple.GetNumberOfAttributes() - 1)) == 1)
{
tuple.RemoveAttribute(tuple.GetNumberOfAttributes() - 1);
privateBucket.Add(tuple);
}
if (privateBucket.Count > 0)
privateBucket.node = bucket.node;
}
if (privateBucket.Count > 0)
result.Add(privateBucket);
}
return result;
}
public override BucketList Run()
{
var result = new BucketList();
var generalizedBucketList = base.Run();
var genPerm = GetBestPermutedTable(generalizedBucketList);
foreach (var bucket in genPerm)
{
//if any of the bucket is null, it means that it is not delta-present, k has to be increased
if (bucket == null) return null;
var privateBucket = new Bucket();
foreach (var tuple in bucket)
{
if (Int32.Parse(tuple.GetValue(tuple.GetNumberOfAttributes() - 1)) == 1)
{
tuple.RemoveAttribute(tuple.GetNumberOfAttributes() - 1);
privateBucket.Add(tuple);
}
if (privateBucket.Count > 0)
privateBucket.node = bucket.node;
}
if (privateBucket.Count > 0)
{
foreach (int i in qid)
privateBucket.PermuteValues(i);
result.Add(privateBucket);
}
}
return result;
}
