MGI::Synch => {
let (mut ig, _) = cs.check_acl(&ag, ig, PCH::Instance, &[TP::Play])?;
- let mut buf = PrepareUpdatesBuffer::new(&mut ig, None, None);
+ let mut buf = PrepareUpdatesBuffer::new(&mut ig, None);
let gen = buf.gen();
drop(buf); // does updatenocc
(U{ pcs: vec![], // we handled the update ourselves,
if xupdates.len() != 0 {
Some(
Box::new(move |prepub: &mut PrepareUpdatesBuffer|
- prepub.piece_updates(xupdates))
+ prepub.piece_updates_nc(xupdates))
as SomeUnpreparedUpdates
)
} else { None },
responses.push(resp);
if let Some(unprepared) = unprepared {
st.flush(ig,how,&who)?;
- let mut prepub = PrepareUpdatesBuffer::new(ig, None, None);
+ let mut prepub = PrepareUpdatesBuffer::new(ig, None);
unprepared(&mut prepub);
prepub.finish();
}
if let Some(uu) = uu {
let mut ig = igu.by_mut(Authorisation::authorise_any());
- let mut prepub = PrepareUpdatesBuffer::new(&mut ig, None, None);
+ let mut prepub = PrepareUpdatesBuffer::new(&mut ig, None);
uu(&mut prepub);
prepub.finish();
}
}
Online => {
let estimate = updates.pcs.len() + updates.log.len();
- let mut buf = PrepareUpdatesBuffer::new(g, None, Some(estimate));
+ let mut buf = PrepareUpdatesBuffer::new(g, Some(estimate));
for (upiece, uuop) in updates.pcs {
- buf.piece_update(upiece, PUOs::Simple(uuop));
+ buf.piece_update(upiece, &None, PUOs::Simple(uuop));
}
buf.log_updates(updates.log);
buf.raw_updates(raw);
use UpdateHandler::*;
match self {
Bulk(bulk) => {
- let mut buf = PrepareUpdatesBuffer::new(g, None, None);
+ let mut buf = PrepareUpdatesBuffer::new(g, None);
for (upiece, uuop) in bulk.pieces {
- buf.piece_update(upiece, PUOs::Simple(uuop));
+ buf.piece_update(upiece, &None, PUOs::Simple(uuop));
}
if bulk.logs {
pub struct PrepareUpdatesBuffer<'r> {
g: &'r mut Instance,
us: Vec<PreparedUpdateEntry>,
- by_client: IsResponseToClientOp,
gen: Option<Generation>,
}
}
impl<'r> PrepareUpdatesBuffer<'r> {
- pub fn new(g: &'r mut Instance,
- by_client: IsResponseToClientOp,
- estimate: Option<usize>) -> Self
+ pub fn new(g: &'r mut Instance, estimate: Option<usize>) -> Self
{
let us = estimate.map_or(vec![], Vec::with_capacity);
PrepareUpdatesBuffer {
gen: None,
- by_client, us, g,
+ us, g,
}
}
piece: PieceId,
estimate: Option<usize>)
{
- let mut updates = PrepareUpdatesBuffer::new(g, None, estimate);
- updates.piece_update_image(piece)?;
+ let mut updates = PrepareUpdatesBuffer::new(g, estimate);
+ updates.piece_update_image(piece, &None)?;
updates.finish();
}
client: ClientId, cseq: ClientSequence)
-> Result<(),OE> {
let by_client = (WRC::Unpredictable, client, cseq);
- let mut buf = PrepareUpdatesBuffer::new(ig, Some(by_client), None);
+ let mut buf = PrepareUpdatesBuffer::new(ig, None);
let ops = PUOs::Simple(PieceUpdateOp::Modify(()));
let state = buf.piece_update_fallible(
- piece, ops, |pc, gen, _by_client| {
+ piece, &Some(by_client), ops, |pc, gen, _by_client| {
match partially {
POEPP::Unprocessed => { }
POEPP::Partially => { pc.gen = gen; pc.lastclient = default(); }
#[throws(InternalError)]
fn piece_update_fallible_players<U,GUF,WMZ,MUF,MPF>
- (&mut self, piece: PieceId, gen_update: GUF,
+ (&mut self, piece: PieceId, by_client: &IsResponseToClientOp,
+ gen_update: GUF,
mut with_max_z: WMZ,
mut mk_update: MUF,
mut missing: MPF,
let ipc = self.g.ipieces.get(piece);
if let Some(ref mut gpc) = gpc {
- gen_update(gpc, gen, &self.by_client);
+ gen_update(gpc, gen, by_client);
}
let gpc = gs.pieces.byid(piece).ok();
#[throws(InternalError)]
fn piece_update_fallible<GUF>(&mut self, piece: PieceId,
+ by_client: &IsResponseToClientOp,
ops: PieceUpdateOps,
gen_update: GUF)
-> PreparedUpdateEntry_Piece
let ops = self.piece_update_fallible_players
::<PreparedPieceUpdate,_,_,_,_>
(
- piece, gen_update,
+ piece,by_client, gen_update,
|max_z, gpc| max_z.update_max(&gpc.zlevel.z),
)?;
PreparedUpdateEntry_Piece {
- by_client: self.by_client,
+ by_client: by_client.clone(),
ops
}
}
- pub fn piece_update(&mut self, piece: PieceId, ops: PieceUpdateOps) {
+ pub fn piece_update(&mut self, piece: PieceId,
+ by_client: &IsResponseToClientOp,
+ ops: PieceUpdateOps) {
// Caller needs us to be infallible since it is too late by
// this point to back out a game state change.
let update = self.piece_update_fallible(
- piece, ops,
+ piece,by_client, ops,
|pc, gen, by_client|
{
match *by_client {
}
#[throws(InternalError)]
- pub fn piece_update_image(&mut self, piece: PieceId) {
+ pub fn piece_update_image(&mut self, piece: PieceId,
+ by_client: &IsResponseToClientOp) {
// Use this only for updates which do not change the set of valid UOs
// or other operations or move the piece etc.
let ims = self.piece_update_fallible_players(
- piece, |_,_,_|(), |_,_|(),
+ piece,by_client, |_,_,_|(), |_,_|(),
|ioccults,gs,gpc,ipc,_player,pri| {
let im = pri.as_ref().map(|pri| {
self.us.push(PUE::Image(PreparedUpdateEntry_Image { ims }))
}
- pub fn piece_updates(&mut self, updates: Vec<(PieceId, PieceUpdateOps)>) {
+ pub fn piece_updates_nc(&mut self, updates: Vec<(PieceId, PieceUpdateOps)>) {
for (piece, ops) in updates {
- self.piece_update(piece, ops);
+ self.piece_update(piece,&None, ops);
}
}
#[ext(pub)]
impl Vec<(PieceId, PieceUpdateOps)> {
- fn into_unprepared(self) -> UnpreparedUpdates {
+ fn into_unprepared_nc(self) -> UnpreparedUpdates {
Some(Box::new(
move |buf: &mut PrepareUpdatesBuffer| {
- buf.piece_updates(self)
+ buf.piece_updates_nc(self)
}))
}
}