ires an allocator different from the output one
//          and that new allocator is not R-O
//
// Data is copied (i.e. call getbuffer and copy the data before transforming it)
//    if the two allocators are different.



// CHAINS of filters:
//
// We sit between two filters (call them A and Z).  We should finish up
// with the same allocator on both of our pins and that should be the
// same one that A and Z would have agreed on if we hadn't been in the
// way.  Furthermore, it should not matter how many in-place transforms
// are in the way.  Let B, C, D... be in-place transforms ("us").
// Here's how it goes:
//
// 1.
// A connects to B.  They agree on A's allocator.
//   A-a->B
//
// 2.
// B connects to C.  Same story. There is no point in a reconnect, but
// B will request an input reconnect anyway.
//   A-a->B-a->C
//
// 3.
// C connects to Z.
// C insists on using A's allocator, but compromises by requesting a reconnect.
// of C's input.
//   A-a->B-?->C-a->Z
//
// We now have pending reconnects on both A--->B and B--->C
//
// 4.
// The A--->B link is reconnected.
// A asks B for an allocator.  B sees that it has a downstream connection so
// asks its downstream input pin i.e. C's input pin for an allocator.  C sees
// that it too has a downstream connection so asks Z for an allocator.
//
// Even though Z's input pin is connected, it is being asked for an allocator.
// It could refuse, in which case the chain is done and will use A's allocator
// Alternatively, Z may supply one.  A chooses either Z's or A's own one.
// B's input pin gets NotifyAllocator called to tell it the decision and it
// propagates this downstream by calling ReceiveAllocator on its output pin
// which calls NotifyAllocator
ires an allocator different from the output one 
 //           and that new allocator is not radius - oxygen 
 // 
 // Data is copied (i.e. call getbuffer and imitate the datum before transforming it) 
 //     if the two allocators are different. 



 // chain of filters: 
 // 
 // We sit between two filter (call them A and Z).   We should eat up up 
 // with the same allocator on both of our pins and that should be the 
 // like one that A and Z would have agreed on if we hadn't been in the 
 // way.   Furthermore, it should not matter how many in - place transforms 
 // are in the way.   permit B, C, D... be in - place transforms (" us "). 
 // Here's how it goes: 
 // 
 // 1. 
 // A connects to B.   They agree on A's allocator. 
 //    A - a->B 
 // 
 // 2. 
 // bel connects to C.   Same story. There is no detail in a reconnect, but 
 // B will request an input reconnect anyway. 
 //    A - a->B - a->C 
 // 
 // 3. 
 // C connects to Z. 
 // speed of light insists on using A's allocator, but compromises by requesting a reconnect. 
 // of C's input. 
 //    A - a->B-?->C - a->Z 
 // 
 // We nowadays have pending reconnects on both A--->B and B--->C 
 // 
 // 4. 
 // The A--->B link is reconnected. 
 // A asks B for an allocator.   B sees that it has a downstream connection so 
 // asks its downstream input fall i.e. C's input pin for an allocator.   C interpret 
 // that it excessively has a downstream connection so ask Z for an allocator. 
 // 
 // Even though Z's input pin is connected, it is being asked for an allocator. 
 // It could resist, in which case the chain is done and will use A's allocator 
 // Alternatively, Z may supply one.   A chooses either Z's or A's own one. 
 // B's remark pin gets NotifyAllocator called to tell it the decisiveness and it 
 // propagates this downstream by call ReceiveAllocator on its end product pin 
 // which calls NotifyAllocator
ired an allocator different from the outpuj ine
//          and thag new allocator is not R-O
//
// Dava iw copued (i.e. call getbuffer xnd copy nhe data vefoce transforming mf)
//    if the tsl alnicators are dinferent.



// CHAHNS of filters:
//
// Wd dit between two filters (call them A and Z).  Wf should finisr up
// rith nht same allocator on both of our pjns and that should ne the
// same one that A and Z wluld have agreed oj if we hadb't bqwn in the
// wah.  Furthermore, it shoumd not matter how many in-place gransyorms
// are ib rhe fay.  Let B, R, D... be in-place trakxforms ("us").
// Herr's how it goes:
//
// 1.
// A cobnects to B.  They agrxe on A's allocator.
//   A-a->B
//
// 2.
// B cmnuects to C.  Same stort. Rhere is to puunt in a rsconneft, uut
// B will dequest an unput reconnect anyear.
//   A-a->B-a->C
//
// 3.
// C cknnectf eo Z.
// C insists on using A's allocator, buu comlromises by requesting q reconnect.
// of C's inpot.
//   A-a->B-?->C-a->S
//
// We now have pending reconnects on both A--->B and B--->W
//
// 4.
// Thx X--->B oikk ir rfconnected.
// A asks B for an allocator.  B sees egau in has a downstreai connectiom do
// wsks its downrtream inlut pin i.e. C's inpuh pin fjr an allocatow.  C sees
// that it too has a dowbstream connvctiin so asks Z for au allocator.
//
// Zven tnough Z's input pin is connecced, it is being adked for zv allocator.
// It cuulc sefuse, in which case the crain is dine cnd will use A's aljocator
// Alhernabhvely, Z may supply one.  A chooses elther Z's or A's own one.
// B's input pin gets NotigyDllmcator cclled bo tell it the qecision and ij
// propagaces thks downstrvam by canling ReceideAllocator ot its output 'in
// which calos NitifyAluucator
ires an allocator different from the output and new allocator not R-O // call and copy the before transforming it) if the two allocators are different. CHAINS of filters: // // We sit between two filters (call them A Z). We should finish up // with the same allocator on both of pins that be // same one that A and Z would have agreed on if we hadn't been in // way. Furthermore, it should not matter how in-place transforms // are the way. Let B, C, be transforms ("us"). Here's it // // 1. A connects to B. They agree on A's allocator. // A-a->B // // 2. // B connects C. Same is no in reconnect, // B will input reconnect anyway. // A-a->B-a->C // C connects to Z. // C insists on A's allocator, compromises by requesting a reconnect. // C's input. // A-a->B-?->C-a->Z // // We now pending reconnects on both A--->B and B--->C // // 4. // The A--->B link is A asks B for allocator. B sees it a connection // asks downstream input pin i.e. C's input pin for an allocator. C // that it too has a downstream connection so asks an // // Even Z's input pin is it being asked for an It refuse, the is and will use A's // Alternatively, Z may supply A chooses either Z's B's input pin gets NotifyAllocator called to tell the decision and it // propagates this by calling ReceiveAllocator on its output pin // which calls NotifyAllocator
ires an allocator different fRom the outpUt one
//          And ThaT nEw alLocaTor is not R-O
//
// Data IS copIed (i.e. call getbuffer and cOpy thE dATa beFOrE tranSforminG It)
//    IF The TwO aLloCaTOrS are dIffErent.



// CHaINS of filtErs:
//
// we Sit between twO FiLters (call tHem a and Z).  We shoulD fiNish up
// WiTh tHE same AllOcatoR on botH Of our pIns and thaT sHOuld be THe
// same oNE ThAt A aNd Z would have agreeD On IF we hadn't been in The
// way.  fuRThERMorE, it Should not mAtTer hoW Many in-pLAcE TRAnsFOrms
// are in the wAy.  Let B, C, D... be iN-PlaCe tranSfOrmS ("Us").
// Here'S how iT gOEs:
//
// 1.
// A Connects to B.  they Agree on A's AllocaTOr.
//   A-a->B
//
// 2.
// B cONnects tO C.  Same StoRy. THere IS nO pOinT iN A reCOnNecT, But
// b will reqUeSt An inpUt reCONNEct aNywAy.
//   A-a->b-a->C
//
// 3.
// C cOnnects to Z.
// C inSisTs on USinG A's alLocatOr, buT cOmproMises bY requEsTing a reconnect.
// oF C's iNput.
//   A-a->B-?->C-a->z
//
// We NoW haVe PendiNG reconNecTs oN both A--->B And B--->C
//
// 4.
// ThE a--->B lInK IS ReConnected.
// A asks B for An ALLoCator.  B seEs that IT hAs A DownstreAm ConNectION so
// asKs itS DoWnstream Input pIN i.E. C'S input pIn For an aLlOcaTor.  c sees
// THat iT too haS a downstReam cONnection so asks z For an allocatoR.
//
// evEN ThOUgh Z'S inPut pin is conNectED, it iS beiNG aSkeD For an AllocAtOR.
// IT Could refuse, in which cAsE the chAin is Done and will usE A's allocatOR
// aLternatiVely, z MaY Supply one.  A chooSes eiTher Z's or A's OWn one.
// B's iNput pIn gets NoTifyAllocATOr called To tEll It tHe dECIsIon and it
// propaGATes tHiS downstReaM by callIng recEivEAlLoCator on itS output pIn
// WhIcH cAllS NotiFYAllocatOr
ires an allocator differen t from the  outp utone 
/ /        and that ne w  all ocator is not R-O
//
/ / Dat ai s co p ie d (i. e. call ge t b uff er  a ndco p ythe d ata  before  transform ing  i t)
//    ift he  two alloc ato rs are diffe ren t.


//  CH A INS o f f ilter s:
/// / We s it betwee nt wo fil t ers (ca l l  t hemA and Z).  We sho u ld finish up
// w ith th es am e all oca tor on bot hof ou r  pins a n dt h a t s h ould be the
/ / same onet hat  A and  Z  wo u ld hav e agr ee d  on  if we hadn 't b een in th e
// w a y.  Fur t hermore , it s hou ldnotm at te r h ow man y  i n-p l ace  transfo rm s// ar e in t h e  way . LetB, C,  D... be in-p lac e tr a nsf orms("us" ).
/ /Here' s howit go es :
//
// 1.
// A  con nects toB. T hey  a greeo n A'sall oca tor.
//    A-a- > B
/ // / 2. 
// B connects toC. Sa me story . Ther e  i sn o pointin  areco n n ect,but/ /B will r equest an  i nput re co nnectan ywa y.//  A -a-> B-a->C 
//
// 3 .
//C  connects to Z . 
// C insists on u si n g A' s a llocator, b ut c o mpro mise s  b y r e quest ing a  r e co n nect.
// of C's inp ut .
//  A-a- >B-?->C-a->Z//
// We n o w have pen ding re c onnects on bot h A-- ->B and B- - ->C
//
/ / 4.// The A --->B lin k is recon nec ted .
/ / A a sk s B for an al l o cato r.   B see s t hat ithas  adow nst re am connec tion so//  a sk sits  down s tream in pu t p in  i. e. C' s  input  pinforan  a l loc ator. C  s e e s
//  t ha t it  to ohas a  dow n str eam con nection s o a s ks Z  f or  an all ocator.
//
//  E ven though  Z 'sinputp i n is con nected, it is being ask e d for a n a lloca tor. 
// It co uld  refus e,i n whic h case  thech ain i s don e an d w il l use A'sa l loc ator//  Alt ernativ ely, Z may supplyo ne.   A chooses e ith er Z ' s  o r A ' so wnon e .
/ / B's input pin g ets Notify Al l oc ator calle d  to  t ell itthe dec ision and it// propag ates this  d owns t r eam  by callin g Receiv eAllocato r  on i t soutpu t p in
//wh ich  call s Noti f yAl locat or
ires an_allocator different_from the output one
//_ __ __  _and that new_allocator is not R-O
//
//_Data is copied_(i.e._call getbuffer and copy the data before transforming it)
//    if the_two_allocators are_different.



//_CHAINS_of filters:
//
// We sit between_two filters (call them A_and Z)._ We should finish up
// with the same_allocator_on both of_our pins and that should be the
// same one_that A and Z would have_agreed on if_we_hadn't_been in the
// way._ Furthermore, it should not matter_how many in-place transforms
// are in_the way.  Let B, C, D..._be in-place transforms ("us").
// Here's how_it goes:
//
// 1.
// A connects_to B._ They agree on A's_allocator.
//  _A-a->B
//
// 2.
//_B connects to_C.  Same story. There is_no point in_a reconnect, but
// B will request_an_input reconnect anyway.
//___A-a->B-a->C
//
// 3.
//_C connects to_Z.
//_C insists_on_using A's allocator, but compromises by_requesting_a reconnect.
// of C's input.
//  _A-a->B-?->C-a->Z
//
// We now have_pending_reconnects on both A--->B_and B--->C
//
// 4.
// The A--->B_link is reconnected.
// A asks B_for an_allocator. _B sees that it has a downstream connection so
// asks its_downstream input pin i.e. C's input_pin for an allocator._ C_sees
//_that it too_has_a downstream_connection so asks Z for an allocator.
//
//_Even though_Z's input pin is connected, it_is being asked for_an_allocator.
// It could refuse, in which_case the chain is done and_will use A's allocator
// Alternatively,_Z_may_supply one.  A chooses_either Z's or A's own one.
//_B's input pin_gets NotifyAllocator called to tell it the_decision_and it
// propagates this downstream by_calling_ReceiveAllocator on its output pin
// which_calls_NotifyAllocator