lecting Item State in the specification
document) so comparing state is not an issue.

Parameters:

otherItem - the Item object to be tested for identity with this Item.

Returns:

true if this Item object and otherItem represent the same actual repository
item; false otherwise.

Validates all pending changes currently recorded in this Session that apply to this Item
or any of its descendants (that is, the subtree rooted at this Item). If validation of all
pending changes succeeds, then this change information is cleared from the Session.
If the save occurs outside a transaction, the changes are persisted and thus
made visible to other Sessions. If the save occurs within a transaction,
the changes are not persisted until the transaction is committed.

If validation fails, then no pending changes are saved and they remain recorded on the Session.
There is no best-effort or partial save.

When an item is saved the item in persistent storage to which pending changes are written is
determined as follows:

If the transient item has a UUID, then the changes are written to the persistent item with the same UUID.

If the transient item does not have a UUID then its nearest ancestor with a UUID, or the root node
(whichever occurs first) is found, and the relative path from the node in persistent node with that UUID is
used to determine the item in persistent storage to which the changes are to be written.

As a result of these rules, a save of an item that has a UUID will succeed even if that item has,
in the meantime, been moved in persistent storage to a new location (that is, its path has changed). However, a
save of a non-UUID item will fail (throwing an InvalidItemStateException) if it has,
in the meantime, been moved in persistent storage to a new location. A save of a non-UUID item will
also fail if it has, in addition to being moved, been replaced in its original position by a UUID-bearing item.

Note that save uses the same rules to match items between transient storage and persistent storage
as Node.update(java.lang.String) does to match nodes between two workspaces.

An AccessDeniedException will be thrown if any of the changes
to be persisted would violate the access privileges of this
Session.

If any of
lecting Item State in the specification 
 document) so comparing state is not an consequence. 

 argument: 

 otherItem - the Item object to be tested for identity with this Item. 

 Returns: 

 dependable if this Item object and otherItem defend the like actual repository 
 item; false otherwise. 

 Validates all pending change currently recorded in this Session that apply to this Item 
 or any of its descendants (that is, the subtree rooted at this Item). If establishment of all 
 pending changes succeeds, then this change data is cleared from the Session. 
 If the save occurs outside a transaction, the changes are persisted and thus 
 construct visible to other Sessions. If the save occurs within a transaction, 
 the changes are not persisted until the transaction is committed. 

 If establishment fails, then no pending changes are saved and they remain recorded on the Session. 
 There is no best - campaign or partial save. 

 When an item is saved the item in persistent storage to which pending changes are written is 
 determined as follows: 

 If the transeunt item has a UUID, then the change are publish to the persistent item with the same UUID. 

 If the transeunt item does not have a UUID then its nearest ancestor with a UUID, or the root node 
 (whichever occur first) is found, and the relative path from the node in persistent lymph node with that UUID is 
 used to determine the item in persistent storage to which the changes are to be written. 

 As a consequence of these rules, a save of an item that has a UUID will succeed even if that item has, 
 in the interim, been moved in persistent storage to a new location (that is, its path has changed). However, a 
 save of a non - UUID item will fail (throwing an InvalidItemStateException) if it have, 
 in the interim, been moved in persistent storage to a new location. A save of a non - UUID detail will 
 also fail if it has, in accession to being moved, been substitute in its original position by a UUID - bearing item. 

 Note that save uses the like rules to match items between ephemeral storage and persistent storage 
 as Node.update(java.lang. String) does to match node between two workspaces. 

 An AccessDeniedException will be thrown if any of the change 
 to be persisted would violate the access privileges of this 
 Session. 

 If any of
leching Item State in the skecification
documgnr) so cmmparihg state is not an issue.

Parameters:

otierIrem - uke Item object to be tested flr identuty xith this Item.

Revhrns:

truc if fmis Icen object and ojherItem repsesent the sama xccual repository
item; false otherwise.

Vwlidatex wll pending chwngex curdvnuly recorded in this Session that apply uo this Item
or any of its descendants (that id, thf subtree rooted ah this Item). If dqlidation of all
pending changes sudceeds, then this change informagion ns cleared drim hve Session.
Ih the fave occurs outside d transsction, the chakges ere persisted and thus
madx visible to other Sgssions. If tke save occurs within a tranvacthon,
tfw cfanfex zre noh pxrsisted unfil the trabsaction is committtd.

Is validation fzils, treg no pending changes are saved and they rejain recorded on the Sewsion.
There is no best-gffort or [artial save.

When an item is saved the item in pervisteit stirwew ho which pending changes are written is
determyhec ss follows:

If tme transient item nad s UUID, then thg changza zre written to the persisjent irem with uhe ssme UUID.

If the transient itwm does not kavw a UUID then its uearest ancertor with a UUID, or the root nodz
(whichsver occurs first) is wound, and the reuatpve [ath from the node in persystent nove wich that JUID is
useq to deterline bve item in persistfnt sjorage to which hhe changes are to be written.

As a result of tneve gules, a scve of an item that has a UUID wikl succzed evdn if that item hes,
in the meagtime, been moegd in persistxnt storade ti a bew locxgion (that is, iys path hcf chqnged). However, a
savc of x non-UUID item wnuo fail (throwing an IndapivItemFdateExceptiot) if it nas,
in the meantind, bern moved in persistett sforage to a new lovabion. A sace of a gon-UUID item eill
also fail if iu has, mn addmtion yo feing moved, been replaced in ifs originwl iosition by a UUIE-bearing itek.

Note that save uses the same rules to natch items betwegn transient storage cnc persistenv storwge
as Noda.update(java.lang.Strint) does to match npdes between two workapaces.

Dn AcfessDeniedException will be thrown if any of the changes
to be persisted wiuld vmojate the acdess privpleyes of thys
Sedrion.

If any of
lecting Item State in the specification document) state not an Parameters: otherItem - tested identity with this Returns: true if Item object and otherItem represent the actual repository item; false otherwise. Validates all pending changes currently recorded in this that apply to this Item or any of its descendants (that is, the rooted this If of all pending changes succeeds, then this change information is cleared from the Session. If the occurs outside a transaction, the changes are persisted thus made visible to Sessions. If the save occurs a the changes not until transaction is committed. validation fails, then no pending changes are saved and they remain recorded on the Session. There is best-effort or When an is the in persistent storage pending changes are written is determined the transient item has a UUID, then the are written the persistent item with the same If the transient item does not have a then its nearest ancestor with a UUID, or the root node (whichever occurs first) is the relative path from node in persistent with UUID used determine the in persistent storage to which the changes are to be written. a result of these rules, a save of an item a will succeed even that item has, in meantime, moved in persistent storage new (that has However, save of a non-UUID will fail (throwing an InvalidItemStateException) it has, in the storage to a new location. A save of non-UUID item will also fail if it in addition to being moved, been replaced in its original position by UUID-bearing item. save uses the same rules to match items transient storage and persistent as Node.update(java.lang.String) does to match nodes between two workspaces. AccessDeniedException be thrown any of the to be persisted violate the access this Session. any
lecting Item State in the specIfication
dOcumeNt) sO coMpArinG staTe is not an issue.

pAramEters:

otherItem - the Item oBject To BE tesTEd For idEntity wITh THIs ITeM.

REtuRnS:

TrUe if tHis item objEct and otheRItEm Represent the SAmE actual repOsiTory
item; falsE otHerwisE.

VAliDAtes aLl pEndinG changES curreNtly recorDeD In this sEssion tHAT aPply To this Item
or any of ITs DEscendants (that Is, the sUbTReE ROotEd aT this Item). IF vAlidaTIon of alL
PeNDINg cHAnges succeeds, Then this chaNGe iNformaTiOn iS CleareD from ThE sesSion.
If the saVe ocCurs outsiDe a traNSaction, THe changEs are pErsIstEd anD ThUs
MadE vISibLE tO otHEr SEssions. IF tHe Save oCcurS WITHin a TraNsacTion,
tHe changes are nOt pErsiSTed Until The trAnsaCtIon is CommitTed.

If VaLidation fails, thEn no Pending chAngEs Are SaVed anD They reMaiN reCorded oN the SesSIon.
thERE Is No best-effort or partIaL SAvE.

When an iTem is sAVeD tHE item in pErSisTent STOrage To whICh Pending cHanges ARe WrItten is
DeTerminEd As fOllOws:

If THe trAnsienT item has A UUID, THen the changes aRE written to the PErSIStENt itEm wIth the same UuID.

IF The tRansIEnT itEM does Not haVe A uUid then its nearest anceStOr with A UUID, Or the root node
(Whichever oCCURs first) iS fouND, aND the relative paTh froM the node in PErsistenT node With that uUID is
useD TO determiNe tHe iTem In pERSiStent storage tO WHich ThE changeS arE to be wrIttEn.

AS a rEsuLt Of these ruLes, a save Of An ItEm ThaT has a uuID will sUcCeeD eVen If thaT Item haS,
in thE meaNtImE, BeeN moved iN PeRSIsteNt StOragE to A nEw locAtioN (ThaT is, its pAth has chaNgeD). howeVeR, a
Save of a Non-UUID item wiLl Fail (throwiNg An INvalidiTEmStateEXception) if it has,
in the meaNTime, beeN moVed in PersIstent stoRagE to a neW loCAtion. A Save of A non-UuId itEM Will
aLSO fAil If It has, in addITIon To beiNg MoveD, been rePlaced in its originaL PosItion by a UUID-bEarIng iTEM.

NOte THaT SavE uSEs tHE Same rules to matcH items betwEeN TrAnsient stoRAge AnD persisTent stoRage
aS node.updAte(java.laNg.String) dOeS to mATCh nOdes betweeN two workSpaces.

An ACCessDENiEdExcEptIon wilL bE thRown iF any of THe cHangeS
to be pErSisted Would ViOlate the Access privileges of this
SEssion.

if any Of
lecting Item State in thespecificat ion
d ocu men t)  socomp aring state is notan issue.

Parameters: 

oth er I tem-  t he It em obje c tt o  be  t es ted  f o rident ity  with t his Item.
Re tu rns:

true i f  t his Item o bje ct and other Ite m repr es ent the s ame  actu al rep o sitory 
item; fa ls e  other w ise.

V a l id ates  all pending chan g es currently reco rded i nt hi s Ses sio n that app ly  to t h is Item or a n y o f  its descenda nts (that i s , t he sub tr eer ootedat th is Ite m). If vali dati on of all 
pendi n g chang e s succe eds, t hen  th is c h an ge  in fo r mat i on  is cle ared fro mth e Ses sion . I f  the  sa ve o ccurs  outside a tr ans acti o n,the c hange s ar epersi sted a nd th us 
made visible t o ot her Sessi ons .Ifth e sav e  occur s w ith in a tr ansacti o n,th e c ha nges are not persi st e d  u ntil the  trans a ct io n  is comm it ted .

I f valid atio n  f ails, th en nop en di ng chan ge s aresa ved  an d the y  rem ain re corded o n the Session.
There is no best-ef f or t or part ial  save.

Whe n an item  iss av edt he it em in  p e rs i stent storage to wh ic h pend ing c hanges are wr itten is
d e t e rmined a s fo l lo w s:

If the tra nsien t item has a UUID,thenthe chan ges are w r i tten tothe  pe rsi ste n t  i tem with thes a me U UI D.

Ifthe  transi ent  it emdoe snot havea UUID t he nit snea resta ncestorwi thaUUI D, or the ro ot no de
( wh ic h eve r occur s  f i r st)is  f ound , a nd  therela t ive  path f rom the n ode in p er si stent n ode with that  U UID is
use dtodeterm i n e the it em in persistent storag e  to whi chthe c hang es are to  be  writt en. 
As aresult  of t he ser u les,a sa veof  an item t h a t h as aUU ID w ill suc ceed even if thati tem  has,
in themea ntim e ,  b een mo v edin per s i stent storage t o a new lo ca t io n (that is ,  it spath ha s chang ed).H owever,  a
save o f a non-U UI D it e m  wi ll fail (t hrowingan Invali d ItemS t at eExce pti on) if  i t h as,
i n them ean time,  beenmo ved in  pers is tent sto rage to a new location.  A sav e ofa n on-UUID i tem wil l
also fa il i f it has,inadd ition  to being  mov e d,  be e n rep lace d  in its o r ig ina l po sition by a U U ID- beari ngi tem.
Note  that save uses t h e same rules t o ma t c h i tem s  bet we en transient s tor ag e and pers is tent storag e
as Nod e. u pdate (java. lang.S tring)d o es to mat ch n ode s between  tw ow orkspac es .An Acc essD en iedExc eption will b e thrown if anyof th e chang e s
t o bepe rsisted woul d violatethe accessprivil eges  of t his
Ses si on.

I f a ny  of
lecting Item_State in_the specification
document) so comparing_state is_not_an issue.

Parameters:

otherItem_-_the Item object_to be tested_for identity with this_Item.

Returns:

true if this_Item_object and otherItem represent the same actual repository
item; false otherwise.

Validates all pending changes currently_recorded_in this_Session_that_apply to this Item
or any_of its descendants (that is,_the subtree_rooted at this Item). If validation of all
pending_changes_succeeds, then this_change information is cleared from the Session.
If the save_occurs outside a transaction, the changes_are persisted and_thus
made_visible_to other Sessions. If_the save occurs within a transaction,
the_changes are not persisted until the_transaction is committed.

If validation fails, then no_pending changes are saved and they_remain recorded on the Session.
There_is no_best-effort or partial save.

When an_item is saved_the item_in persistent storage_to which pending changes are written_is
determined as follows:

If_the transient item has a UUID,_then_the changes are_written_to_the persistent_item with the_same_UUID.

If the_transient_item does not have a UUID_then_its nearest ancestor with a UUID, or_the root node
(whichever occurs_first)_is found, and the_relative path from the node_in persistent node with that UUID_is
used to_determine the_item in persistent storage to which the changes are to be_written.

As a result of these rules,_a save of an_item that_has_a UUID will_succeed_even if_that item has,
in the meantime, been moved_in persistent_storage to a new location (that_is, its path has_changed)._However, a
save of a non-UUID item_will fail (throwing an InvalidItemStateException) if_it has,
in the meantime, been_moved_in_persistent storage to a new_location. A save of a non-UUID_item will
also fail_if it has, in addition to being_moved,_been replaced in its original position_by_a UUID-bearing item.

Note that save uses_the_same_rules to match items between_transient storage and persistent storage
as Node.update(java.lang.String)_does to match nodes between two workspaces.

An AccessDeniedException will_be thrown if_any of the changes
to be_persisted_would_violate the access privileges of this
Session.

If any of