ContextManager.cpp Source File - SOAP to CORBA bridge

00001 // /******************************************************************************\
00002 // *
00003 // * File:          ContextManager.cpp
00004 // * Creation date: June 22, 2001 11:59
00005 // * Author:        ClassBuilder
00006 // *                XXXX
00007 // * Purpose:       Method implementations of class 'SqContextManager'
00008 // *
00009 // * Modifications: @INSERT_MODIFICATIONS(* )
00010 // *
00011 // *
00012 // \******************************************************************************/
00013 //@START_USER1
00018 /* --------------------------------------------------------------
00019 Copyright (C) 2001 LifeLine Networks BV <soap2corba@lifeline.nl>
00020 
00021 This program is free software; you can redistribute it and/or
00022 modify it under the terms of the GNU General Public License
00023 as published by the Free Software Foundation; either
00024 version 2 of the License, or (at your option) any later
00025 version.
00026 
00027 This program is distributed in the hope that it will be useful,
00028 but WITHOUT ANY WARRANTY; without even the implied warranty of
00029 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00030 GNU General Public License for more details.
00031 
00032 You should have received a copy of the GNU General Public License
00033 along with this program; if not, write to the Free Software
00034 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00035 -------------------------------------------------------------- */
00036 //@END_USER1
00037 
00038 
00039 // Master include file
00040 #include "ObjCtx.h"
00041 
00042 
00043 //@START_USER2
00044 //@END_USER2
00045 
00046 
00047 // Static members
00048 
00049 
00053 SqContextManager::SqContextManager() //@INIT_757
00054 {//@CODE_757
00055     ConstructorInclude();
00056 
00057     unsigned long key = DecodeKey ("GL0BAL");
00058     SqContext *pCtx = new SqContext (this, key, 0);
00059     pCtx->SetContextKey ("GL0BAL");
00060 }//@CODE_757
00061 
00062 
00066 SqContextManager::~SqContextManager()
00067 {//@CODE_630
00068     DestructorInclude();
00069 
00070 }//@CODE_630
00071 
00072 
00080 CString SqContextManager::CreateContext(unsigned short timeout,
00081                                         CString UserData)
00082 {//@CODE_741
00083     CString value;
00084     unsigned long key;
00085 
00086     srand ((unsigned long) time (NULL));
00087     do {
00088         value.Empty ();
00089         int i;
00090         for (i = 0; i < 7; i ++) {
00091             int r = rand () % 23;
00092             if (r < 10) {
00093                 value += ('0' + r);
00094             } else {
00095                 value += ('A' + r - 10);
00096             }
00097         }
00098         key = DecodeKey (value);
00099     } while (this->FindContext (key));
00100     SqContext *pCtx = new SqContext (this, key, timeout);
00101     pCtx->SetContextKey (value);
00102     pCtx->SetUserData (UserData);
00103     return value;
00104 }//@CODE_741
00105 
00106 
00110 unsigned long SqContextManager::DecodeKey(const char* contextKey)
00111 {//@CODE_758
00112     unsigned long value = strtoul (contextKey, NULL, 23);
00113 
00114     return value;
00115 }//@CODE_758
00116 
00117 
00118 //{{AFX DO NOT EDIT CODE BELOW THIS LINE !!!
00119 
00123 void SqContextManager::ConstructorInclude()
00124 {
00125     // INIT_UNIQUEVALUETREE_OWNED_ACTIVE(SqContextManager, ContextManager, SqContext, Context)
00126    
00127     _firstContext = (SqContext*)0;
00128     _countContext = 0;
00129 }
00130 
00131 
00135 void SqContextManager::DestructorInclude()
00136 {
00137     // EXIT_UNIQUEVALUETREE_OWNED_ACTIVE(SqContextManager, ContextManager, SqContext, Context)
00138     { for (SqContext* item = GetFirstContext(); item; item = GetFirstContext())
00139           delete item; }
00140 }
00141 
00142 
00143 SqContext* SqContextManager::FindContext(unsigned long key)
00144 {
00145     // BODY_UNIQUEVALUETREE_FIND(GetKey(), key, SqContextManager, ContextManager, SqContext, Context)
00146     
00147     SqContext* result = 0;
00148     if (_firstContext)
00149     {
00150         SqContext* item = _firstContext;
00151         unsigned long bit = 0x1;
00152         while (1)
00153         {
00154             if (item->GetKey() == key)
00155             {
00156                 result = item;
00157                 break;
00158             }
00159 
00160             if ((item->GetKey() & bit) == (key & bit))
00161             {
00162                 if (item->_leftContextManager)
00163                 {
00164                     item = item->_leftContextManager;
00165                 }
00166                 else
00167                 {
00168                     break;
00169                 }
00170             }
00171             else
00172             {
00173                 if (item->_rightContextManager)
00174                 {
00175                     item = item->_rightContextManager;
00176                 }
00177                 else
00178                 {
00179                     break;
00180                 }
00181             }
00182 
00183             bit <<= 1;
00184         }
00185     } 
00186     return result;
00187 }
00188 
00189 
00190 // Methods for the relation(s) of the class
00191 // METHODS_UNIQUEVALUETREE_OWNED_ACTIVE(GetKey(), SqContextManager, ContextManager, SqContext, Context)
00192 void SqContextManager::AddContext(SqContext* item)
00193 {
00194     
00195     assert(this);
00196 
00197     assert(item);
00198     assert(item->_refContextManager == (SqContextManager*)0);
00199 
00200     _countContext++;
00201 
00202     item->_refContextManager = this;
00203 
00204     if (_firstContext)
00205     {
00206         SqContext* current = _firstContext;
00207         unsigned long bit = 0x1;
00208         while (1)
00209         {
00210             assert(current->GetKey() != item->GetKey());
00211 
00212             if ((current->GetKey() & bit) == (item->GetKey() & bit))
00213             {
00214                 if (current->_leftContextManager)
00215                 {
00216                     current = current->_leftContextManager;
00217                 }
00218                 else
00219                 {
00220                     current->_leftContextManager = item;
00221                     item->_parentContextManager = current;
00222                     break;
00223                 }
00224             }
00225             else
00226             {
00227                 if (current->_rightContextManager)
00228                 {
00229                     current = current->_rightContextManager;
00230                 }
00231                 else
00232                 {
00233                     current->_rightContextManager = item;
00234                     item->_parentContextManager = current;
00235                     break;
00236                 }
00237             }
00238 
00239             bit <<= 1;
00240         }
00241     }
00242     else
00243     {
00244         _firstContext = item;
00245     } 
00246 }
00247 
00248 void SqContextManager::RemoveContext(SqContext* item)
00249 {
00250     
00251     assert(this);
00252 
00253     assert(item);
00254     assert(item->_refContextManager == this);
00255 
00256     SqContextManager::ContextIterator::Check(item);
00257 
00258     _countContext--;
00259 
00260     SqContext* replacement = 0;
00261     SqContext* move = 0;
00262     if (item->_leftContextManager)
00263     {
00264         replacement = item->_leftContextManager;
00265         replacement->_parentContextManager = item->_parentContextManager;
00266         move = item->_rightContextManager;
00267     }
00268     else if (item->_rightContextManager)
00269     {
00270         replacement = item->_rightContextManager;
00271         replacement->_parentContextManager = item->_parentContextManager;
00272     }
00273 
00274     SqContext* parent = item->_parentContextManager;
00275     if (parent)
00276     {
00277         if (parent->_leftContextManager == item)
00278         {
00279             parent->_leftContextManager = replacement;
00280         }
00281         else
00282         {
00283             parent->_rightContextManager = replacement;
00284         }
00285     }
00286     else
00287     {
00288         _firstContext = replacement;
00289     }
00290 
00291     if (replacement)
00292     {
00293         while (1)
00294         {
00295             SqContext* tmp = replacement->_rightContextManager;
00296             replacement->_rightContextManager = move;
00297             if (move)
00298             {
00299                 move->_parentContextManager = replacement;
00300             }
00301             
00302             if (!replacement->_leftContextManager)
00303             {
00304                 if (tmp)
00305                 {
00306                     replacement->_leftContextManager = tmp;
00307                     tmp = 0;
00308                 }
00309                 else
00310                 {
00311                     break;
00312                 }
00313             }
00314             move = tmp;
00315             replacement = replacement->_leftContextManager;
00316         }
00317     }
00318 
00319     item->_refContextManager = (SqContextManager*)0;
00320     item->_parentContextManager = (SqContext*)0;
00321     item->_leftContextManager = (SqContext*)0;
00322     item->_rightContextManager = (SqContext*)0; 
00323 }
00324 
00325 void SqContextManager::DeleteAllContext()
00326 {
00327     
00328     assert(this);
00329 
00330     for (SqContext* item = GetFirstContext(); item; item = GetFirstContext())
00331           delete item; 
00332 }
00333 
00334 void SqContextManager::ReplaceContext(SqContext* item, SqContext* newItem)
00335 {
00336     
00337     assert(this);
00338 
00339     assert(item);
00340     assert(item->_refContextManager == this);
00341 
00342     assert(newItem);
00343     assert(newItem->_refContextManager == (SqContextManager*)0);
00344 
00345     if (item->GetKey() == newItem->GetKey())
00346     {
00347         SqContextManager::ContextIterator::Check(item, newItem);
00348         if (_firstContext == item)
00349         {
00350             _firstContext = newItem;
00351         }
00352         if (item->_parentContextManager)
00353         {
00354             if (item->_parentContextManager->_leftContextManager == item)
00355             {
00356                 item->_parentContextManager->_leftContextManager = newItem;
00357             }
00358             else if (item->_parentContextManager->_rightContextManager == item)
00359             {
00360                 item->_parentContextManager->_rightContextManager = newItem;
00361             }
00362         }
00363         newItem->_refContextManager = this;
00364         newItem->_parentContextManager = item->_parentContextManager;
00365         newItem->_leftContextManager = item->_leftContextManager;
00366         newItem->_rightContextManager = item->_rightContextManager;
00367         item->_refContextManager = (SqContextManager*)0;
00368         item->_parentContextManager = (SqContext*)0;
00369         item->_leftContextManager = (SqContext*)0;
00370         item->_rightContextManager = (SqContext*)0;
00371     }
00372     else
00373     {
00374         SqContextManager::ContextIterator::Check(item);
00375         RemoveContext(item);
00376         AddContext(newItem);
00377     } 
00378 }
00379 
00380 SqContext* SqContextManager::GetFirstContext() const
00381 {
00382     
00383     assert(this);
00384     return _firstContext; 
00385 }
00386 
00387 SqContext* SqContextManager::GetLastContext() const
00388 {
00389     
00390     assert(this);
00391 
00392     SqContext* result = _firstContext;
00393     while (result)
00394     {
00395         while (result->_rightContextManager)
00396         {
00397             result = result->_rightContextManager;
00398         }
00399 
00400         if (result->_leftContextManager)
00401         {
00402             result = result->_leftContextManager;
00403         }
00404         else
00405         {
00406             break;
00407         }
00408     }
00409 
00410     return result; 
00411 }
00412 
00413 SqContext* SqContextManager::GetNextContext(SqContext* pos) const
00414 {
00415     
00416     assert(this);
00417 
00418     SqContext* result = 0;
00419     if (pos == (SqContext*)0)
00420         result = _firstContext;
00421     else
00422     {
00423         assert(pos->_refContextManager == this);
00424 
00425         if (pos->_leftContextManager)
00426         {
00427             result = pos->_leftContextManager;
00428         }
00429         else
00430         {
00431             if (pos->_rightContextManager)
00432             {
00433                 result = pos->_rightContextManager;
00434             }
00435             else
00436             {
00437                 SqContext* parent = pos->_parentContextManager;
00438                 while (parent && (parent->_rightContextManager == 0 || parent->_rightContextManager == pos))
00439                 {
00440                     pos = parent;
00441                     parent = parent->_parentContextManager;
00442                 }
00443 
00444                 if (parent)
00445                 {
00446                     result = parent->_rightContextManager;
00447                 }
00448             }
00449         }
00450     }
00451 
00452     return result; 
00453 }
00454 
00455 SqContext* SqContextManager::GetPrevContext(SqContext* pos) const
00456 {
00457     
00458     assert(this);
00459 
00460     SqContext* result = 0;
00461     if (pos == (SqContext*)0)
00462         result = GetLastContext();
00463     else
00464     {
00465         assert(pos->_refContextManager == this);
00466 
00467         if (pos->_parentContextManager)
00468         {
00469             if (pos->_parentContextManager->_leftContextManager == pos || pos->_parentContextManager->_leftContextManager == 0)
00470             {
00471                 result = pos->_parentContextManager;
00472             }
00473             else /* Right branche and valid left branche */
00474             {
00475                 result = pos->_parentContextManager->_leftContextManager;
00476                 while (1)
00477                 {
00478                     while (result->_rightContextManager)
00479                     {
00480                         result = result->_rightContextManager;
00481                     }
00482 
00483                     if (result->_leftContextManager)
00484                     {
00485                         result = result->_leftContextManager;
00486                     }
00487                     else
00488                     {
00489                         break;
00490                     }
00491                 }
00492             }
00493         }
00494     }
00495 
00496     return result; 
00497 }
00498 
00499 int SqContextManager::GetContextCount() const
00500 {
00501     
00502     assert(this);
00503     return _countContext; 
00504 }
00505 // METHODS_ITERATOR_MULTI_ACTIVE(SqContextManager, ContextManager, SqContext, Context)
00506 SqContextManager::ContextIterator* SqContextManager::ContextIterator::_first = 0;
00507 SqContextManager::ContextIterator* SqContextManager::ContextIterator::_last = 0;
00508 
00509 SqContextManager::ContextIterator::ContextIterator(
00510     const SqContextManager* iterContextManager,
00511     int (SqContext::*method)() const,
00512     SqContext* refContext)
00513 {
00514     assert(iterContextManager);
00515 
00516     _iterContextManager = iterContextManager;
00517     _refContext = _prevContext = _nextContext = refContext;
00518     _prev = (ContextIterator*)0;
00519     _next = (ContextIterator*)0;
00520     _method = method;
00521     if (_last)
00522     {
00523         _last->_next = this;
00524         _prev = _last;
00525         _last = this;
00526     }
00527     else
00528         _first = _last = this;
00529 }
00530 
00531 SqContextManager::ContextIterator::ContextIterator(
00532     const SqContextManager& iterContextManager,
00533     int (SqContext::*method)() const,
00534     SqContext* refContext)
00535 {
00536     assert(&iterContextManager);
00537 
00538     _iterContextManager = &iterContextManager;
00539     _refContext = _prevContext = _nextContext = refContext;
00540     _prev = (ContextIterator*)0;
00541     _next = (ContextIterator*)0;
00542     _method = method;
00543     if (_last)
00544     {
00545         _last->_next = this;
00546         _prev = _last;
00547         _last = this;
00548     }
00549     else
00550         _first = _last = this;
00551 }
00552 
00553 SqContextManager::ContextIterator::ContextIterator(
00554     const ContextIterator& iterator,
00555     int (SqContext::*method)() const)
00556 {
00557     _iterContextManager = iterator._iterContextManager;
00558     _refContext = iterator._refContext;
00559     _prevContext = iterator._prevContext;
00560     _nextContext = iterator._nextContext;
00561     _prev = (ContextIterator*)0;
00562     _next = (ContextIterator*)0;
00563     _method = method;
00564     if (_last)
00565     {
00566         _last->_next = this;
00567         _prev = _last;
00568         _last = this;
00569     }
00570     else
00571         _first = _last = this;
00572 }
00573 
00574 SqContextManager::ContextIterator::~ContextIterator()
00575 {
00576     if (_next)
00577         _next->_prev = _prev;
00578     else
00579         _last = _prev;
00580 
00581     if (_prev)
00582         _prev->_next = _next;
00583     else
00584         _first = _next;
00585 }
00586 
00587 void SqContextManager::ContextIterator::Check(SqContext* itemContext)
00588 {
00589     for (ContextIterator* item = _first; item; item = item->_next)
00590     {
00591         if (item->_prevContext == itemContext)
00592         {
00593             item->_prevContext = item->_iterContextManager->GetNextContext(item->_prevContext);
00594             item->_refContext = 0;
00595         }
00596         if (item->_nextContext == itemContext)
00597         {
00598             item->_nextContext = item->_iterContextManager->GetPrevContext(item->_nextContext);
00599             item->_refContext = 0;
00600         }
00601     }
00602 }
00603 
00604 void SqContextManager::ContextIterator::Check(SqContext* itemContext, SqContext* newItemContext)
00605 {
00606     for (ContextIterator* item = _first; item; item = item->_next)
00607     {
00608         if (item->_refContext == itemContext)
00609         {
00610             item->_refContext = item->_prevContext = item->_nextContext = newItemContext;
00611         }
00612         if (item->_prevContext == itemContext)
00613         {
00614             item->_prevContext = newItemContext;
00615             item->_refContext = 0;
00616         }
00617         if (item->_nextContext == itemContext)
00618         {
00619             item->_nextContext = newItemContext;
00620             item->_refContext = 0;
00621         }
00622     }
00623 }
00624 
00625 //}}AFX DO NOT EDIT CODE ABOVE THIS LINE !!!
00626 
00627 //@START_USER3
00628