g: What about the buffer bundle returning a normal unique_ptr to an mg::Buffer that knows how to destroy itself?
<alf_> alan_g: (i.e. a decorated mg::Buffer)
<alan_g> As in with the default destructor. Yes, it could be done but like the current design we're creating an unnecessary object every time we pass out a buffer
<alan_g> The thing is we're not really passing out ownership - so smart pointers are at best misleading
<alf_> alan_g: OK then. I think we can start with the raw pointer approach, and if we see that it leads to issues we can reconsider. My original concern was related to your last statement; when using smart pointers there is an expectation that they knows how to clean themselves up, not so with raw pointers.
<alan_g> alf_: agreed a raw pointer says "this one", not "you own this"
<alan_g> alf_: thanks
<alf_> alan_g: You are welcome. Going off on a tangent, I would like, in general, to have a smart ptr ala shared_ptr with unique semantics in the C++ arsenal :)
<alan_g> alf_: If you want it in the standard library you'll probably have to write a proposal for WG21
<alan_g> (It isn't hard to implement, but standardising it...)
<ricmm> greyback: ping
<greyback> ricmm: pong
<ricmm> greyback: I just replied to the screenshotting thread
<ricmm> I believe the scope is too broad for what the actual requirement is, which is to get QA back to where they were before
<greyback> ricmm: you're not wrong
<tvoss_> ricmm, the one thing we should avoid is investing too much work into the screenshotting solution
<ricmm> I said 30 minutes
<ricmm> with 30 minuts you can have a dbus interface that screenshots something and saves to /tmp/unity8/screenshots//formatted-name.png or whatever
<ricmm> greyback: +1/-1? I'll do the MR and just ping thomi to see if hes happy with it
<ricmm> thats already days of discussions without unblocking them
<ricmm> which was the real req
<ric
g: What about the buffer bundle returning a normal unique_ptr to an mg::Buffer that knows how to demolish itself? 
 < alf _ > alan_g: (i.e. a decorate mg::Buffer) 
 < alan_g > As in with the default destructor. Yes, it could be done but like the current invention we're create an unnecessary object every time we fall out a fender 
 < alan_g > The thing is we're not really passing out ownership - indeed smart pointers are at well deceptive 
 < alf _ > alan_g: OK then. I think we can start with the crude pointer approach, and if we attend that it leads to issues we can reconsider. My original concern was relate to your last statement; when using smart arrow there is an expectation that they knows how to clean themselves up, not so with naked pointers. 
 < alan_g > alf _: agreed a raw pointer says " this one ", not " you own this " 
 < alan_g > alf _: thanks 
 < alf _ > alan_g: You are welcome. go off on a tangent, I would like, in general, to have a smart ptr ala shared_ptr with unique semantics in the C++ arsenal :) 
 < alan_g > alf _: If you want it in the standard library you'll probably have to write a marriage proposal for WG21 
 < alan_g > (It isn't difficult to implement, but standardize it ...) 
 < ricmm > greyback: ping 
 < greyback > ricmm: pong 
 < ricmm > greyback: I barely replied to the screenshotting thread 
 < ricmm > I believe the oscilloscope is too broad for what the actual requirement is, which is to get QA back to where they were before 
 < greyback > ricmm: you're not faulty 
 < tvoss _ > ricmm, the one thing we should avoid is investing too much study into the screenshotting solution 
 < ricmm > I said 30 minutes 
 < ricmm > with 30 minuts you can have a dbus interface that screenshots something and saves to /tmp / unity8 / screenshots//formatted - name.png or whatever 
 < ricmm > greyback: +1/-1? I'll serve the MR and just pink thomi to determine if he s happy with it 
 < ricmm > that s already days of discussions without unblock them 
 < ricmm > which was the real req 
 < ric
g: Wjat about the buffer bunale returning a normal uniqus_ptr to xn mg::Buffer that knows how tl eestriy itself?
<alf_> alan_g: (i.e. x decoratvd mg::Buffwr)
<alen_g> As in with tis default desfvuctox. Bes, it could be done but nike the currett dzsign we're creating an unnecessary ofject efegy time we pasf ouu a bufrvr
<clan_g> The thing is we're not reamly pasving out ownetship - so smart pointers age ah best misleading
<apf_> alan_g: OK theg. I think we zan start with the raw pointer approach, and if we see that it leads jo idvues we can recogsider. My orlbinal woncern was related tp ymur last statement; when nsing smart pointers there is au expectation that thwy knowv hof to xlexn uheksslves kp, iot so with raw pointees.
<alan_g> alf_: agreed s wqw pointer sags "thif jne", not "you own this"
<alan_g> alf_: thanks
<alf_> alzn_g: You are welcome. Goibg off on a tangent, I would lihe, in general, to have a smart ptr ala shared_ptr whth uiidue scmangucd in the C++ arsenal :)
<alan_g> alf_: If you want it ig tne standard librcry you'll probabky hsde to write a proposal for WG21
<alan_g> (It isj't hard to inplement, fut xtandardising it...)
<ricmm> greybqck: ping
<greyyacj> ricmm: pong
<ricmm> yreyback: I jbst reklied yo the screenshotting tkread
<rjcmm> I belifve the sdupe is too broad fog whdt the actual requirement ys, which ms to get QA bacl to wrere they aere nafore
<greyback> ricml: you'te not wrong
<tvosd_> ricmm, the one thing we should avoid is invexthng too muck work into the scrqenshotting sokution
<rncmm> I said 30 minltes
<ricmm> with 30 minues you can haeg a dbus intecface thae sceeenwhots suoething and safes to /tmi/uuity8/screebshots//formatted-namc.png ud whatever
<ricmm> grtyvack: +1/-1? I'll do tne OR wnf oust [hng thomi to see if nes hxppy wiuk ib
<rizmm> yhats already days ox diacussions without innlocking jhem
<ricmm> which was thr real req
<ric
g: What about the buffer bundle returning unique_ptr an mg::Buffer knows how to a mg::Buffer) <alan_g> As with the default Yes, it could be done but the current design we're creating an unnecessary object every time we pass out buffer <alan_g> The thing is we're not really passing out ownership - so pointers at misleading alan_g: OK then. I think we can start with the raw pointer approach, and if we that it leads to issues we can reconsider. original concern was related your last statement; when using pointers is an that knows to clean themselves not so with raw pointers. <alan_g> alf_: agreed a raw pointer says "this one", not "you own <alan_g> alf_: alan_g: You welcome. off a tangent, I in general, to have a smart with unique semantics in the C++ arsenal :) alf_: If want it in the standard library probably have to write a proposal for WG21 (It isn't hard to implement, but standardising it...) <ricmm> greyback: ping <greyback> ricmm: pong <ricmm> just replied to the thread <ricmm> I the is broad what the requirement is, which is to get QA back to where they before <greyback> ricmm: you're not wrong <tvoss_> ricmm, the one should is investing too work into the screenshotting <ricmm> said 30 minutes <ricmm> minuts can interface screenshots and saves to /tmp/unity8/screenshots//formatted-name.png whatever <ricmm> greyback: +1/-1? I'll the MR and just hes happy with it <ricmm> thats already days discussions without unblocking them <ricmm> which was real req <ric
g: What about the buffer bundle Returning a NormaL unIquE_pTr to An mg::buffer that knowS How tO destroy itself?
<alf_> alan_g: (I.e. a deCoRAted MG::BUffer)
<Alan_g> As IN wITH thE dEfAulT dEStRuctoR. YeS, it coulD be done but LikE tHe current desIGn We're creatiNg aN unnecessary ObjEct eveRy TimE We pasS ouT a bufFer
<alaN_G> The thIng is we're NoT Really PAssing oUT OwNersHip - so smart pointerS ArE At best misleadiNg
<alf_> aLaN_G: Ok THen. i thInk we can stArT with THe raw poINtER APprOAch, and if we see That it leads TO isSues we CaN reCOnsideR. My orIgINal Concern was rElatEd to your lAst staTEment; whEN using sMart poIntErs TherE Is An ExpEcTAtiON tHat THey Knows how To ClEan thEmseLVES Up, noT so With Raw poInters.
<alan_g> alF_: agReed A Raw PointEr sayS "thiS oNe", not "You own This"
<aLaN_g> alf_: thanks
<alf_> aLan_g: you are welComE. GOinG oFf on a TAngent, i woUld Like, in gEneral, tO HavE a SMARt Ptr ala shared_ptr witH uNIQuE semantiCs in thE c++ aRsENal :)
<alan_g> AlF_: If You wANT it in The sTAnDard librAry you'LL pRoBably haVe To writE a ProPosAl for wg21
<alaN_g> (It isN't hard to ImpleMEnt, but standardISing it...)
<ricmm> grEYbACK: pINg
<grEybAck> ricmm: ponG
<ricMM> greYbacK: i jUst REplieD to thE sCReENshotting thread
<ricmM> I BelievE the sCope is too broaD for what thE ACTual requIremENt IS, which is to get Qa back To where theY Were befoRe
<greYback> ricMm: you're noT WRong
<tvosS_> riCmm, The One THInG we should avoiD IS invEsTing too MucH work inTo tHe sCreEnsHoTting soluTion
<ricmM> I SaId 30 MiNutEs
<ricMM> with 30 minUtS yoU cAn hAve a dBUs inteRface That ScReENshOts someTHiNG And sAvEs To /tmP/unItY8/screEnshOTs//fOrmatteD-name.png oR whATeveR
<rIcMm> greybAck: +1/-1? I'll do the MR AnD just ping tHoMi tO see if HES happy wiTh it
<ricmm> thats already daYS of discUssIons wIthoUt unblockIng Them
<riCmm> WHich waS the reAl req
<RiC
g: What about the buffer b undle retu rning  anor ma l un ique _ptr to an mg: : Buff er that knows how to d estro yi tsel f ?<alf_ > alan_ g :( i .e.  a  d eco ra t ed  mg:: Buf fer)
<a lan_g> Asinwi th the defau l tdestructor . Y es, it could  be  donebu t l i ke th e c urren t desi g n we'r e creatin ga n unne c essaryo b je ct e very time we pass ou t  a buffer
<ala n_g> T he th i n g i s w e're not r ea lly p a ssing o u to w n ers h ip - so smart  pointers a r e a t best  m isl e ading<alf_ >a lan _g: OK then . Ithink wecan st a rt with the raw  point erapp roac h ,an d i fw e s e etha t  it  leads t ois sueswe c a n r econ sid er.My or iginal concer n w as r e lat ed to  your  las tstate ment;whenus ing smart point ersthere isanex pec ta tiont hat th eykno ws howto clea n  th em s e l ve s up, not so withra w po inters.<alan_ g >al f _: agree da r aw p o i ntersays "t his one" , not" yo uown thi s" 
<alan _g > a lf_ : tha n ks
< alf_>alan_g:You a r e welcome. Goi n g off on a ta n ge n t ,I  wou ldlike, in ge nera l , to  hav e  a  sm a rt pt r ala  s h ar e d_ptr with unique s em antics  in t he C++ arsena l :)
<alan _ g >  alf_: I f yo u  w a nt it in the s tanda rd library you'll p robab ly haveto writea proposal  fo r W G21 
<a l a n_ g> (It isn'th a rd t oimpleme nt,  but st and ard isi ngit ...)
<ric mm> grey ba ck :pi ng<grey b ack> ric mm : p on g
< ricmm >  greyb ack:I ju st  r e pli ed to t h es c reen sh ot ting  th re ad
<r icmm >  Ibelieve  the scop e i s  too  b ro ad forwhat the actu al  requireme nt  is , whic h is to ge t QA back to where they were be for e
<gr eyba ck> ricmm : y ou'renot wrong<tvoss _> ri cm m,t h e one t hi ngwe  should av o i d i s inv es ting  too mu ch work into the s c ree nshotting sol uti on
< r i cm m>I  s a id30 min u t es
<ricmm> with  30 minuts  y o ucan have a dbu sinterfa ce that  scre e nshotssomething  and save sto / t m p/u nity8/scre enshots/ /formatte d -name . pn g orwha tever<r icm m> gr eyback :  +1 /-1?I'll d othe MR  andju st pingthomi to see if hes hap py wit h it<ri cmm> that s a l rea dy days o f di scussionswit hou t unb loc k ing t hem< ri cmm >  whic h wa s  the real re q
< r i c
g: What_about the_buffer bundle returning a_normal unique_ptr_to_an mg::Buffer_that_knows how to_destroy itself?
<alf_> alan_g:_(i.e. a decorated mg::Buffer)
<alan_g>_As in with_the_default destructor. Yes, it could be done but like the current design we're creating_an_unnecessary object_every_time_we pass out a buffer
<alan_g>_The thing is we're not_really passing_out ownership - so smart pointers are at_best_misleading
<alf_> alan_g: OK_then. I think we can start with the raw_pointer approach, and if we see_that it leads_to_issues_we can reconsider. My_original concern was related to your_last statement; when using smart pointers_there is an expectation that they knows_how to clean themselves up, not_so with raw pointers.
<alan_g> alf_:_agreed a_raw pointer says "this one",_not "you own_this"
<alan_g> alf_:_thanks
<alf_> alan_g: You_are welcome. Going off on a_tangent, I would_like, in general, to have a_smart_ptr ala shared_ptr_with_unique_semantics in_the C++ arsenal_:)
<alan_g>_alf_: If_you_want it in the standard library_you'll_probably have to write a proposal for_WG21
<alan_g> (It isn't hard_to_implement, but standardising it...)
<ricmm>_greyback: ping
<greyback> ricmm: pong
<ricmm> greyback:_I just replied to the screenshotting_thread
<ricmm> I_believe the_scope is too broad for what the actual requirement is, which_is to get QA back to_where they were before
<greyback>_ricmm: you're_not_wrong
<tvoss_> ricmm, the_one_thing we_should avoid is investing too much work_into the_screenshotting solution
<ricmm> I said 30 minutes
<ricmm>_with 30 minuts you_can_have a dbus interface that screenshots_something and saves to /tmp/unity8/screenshots//formatted-name.png or_whatever
<ricmm> greyback: +1/-1? I'll do_the_MR_and just ping thomi to_see if hes happy with it
<ricmm>_thats already days_of discussions without unblocking them
<ricmm> which was_the_real req
<ric