include/opencascade/LibCtl_Library.gxx

0001 // Copyright (c) 1998-1999 Matra Datavision
0002 // Copyright (c) 1999-2014 OPEN CASCADE SAS
0003 //
0004 // This file is part of Open CASCADE Technology software library.
0005 //
0006 // This library is free software; you can redistribute it and/or modify it under
0007 // the terms of the GNU Lesser General Public License version 2.1 as published
0008 // by the Free Software Foundation, with special exception defined in the file
0009 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
0010 // distribution for complete text of the license and disclaimer of any warranty.
0011 //
0012 // Alternatively, this file may be used under the terms of Open CASCADE
0013 // commercial license or contractual agreement.
0014
0015 //#include <LibCtl_Library.ixx>
0016 #include <Standard_NoSuchObject.hxx>
0017
0018
0019 //  Liste Globale des Modules, dans laquelle on va se servir
0020
0021 static Handle(LibCtl_GlobalNode) theglobal;
0022
0023 //  Donnees pour optimisation (dernier Protocole demande)
0024
0025 static Handle(TheProtocol) theprotocol;
0026 static Handle(LibCtl_Node) thelast;
0027
0028
0029 //  Alimentation de la liste globale
0030 //  ATTENTION : SetGlobal fait de la substitution, c-a-d que c est le dernier
0031 //   qui a raison pour un Protocol donne
0032     void LibCtl_Library::SetGlobal
0033   (const Handle(TheModule)& amodule, const Handle(TheProtocol)& aprotocol)
0034 {
0035   if (theglobal.IsNull()) theglobal = new LibCtl_GlobalNode;
0036   theglobal->Add(amodule,aprotocol);
0037 }
0038
0039 // Constructeur d apres Protocole
0040     LibCtl_Library::LibCtl_Library (const Handle(TheProtocol)& aprotocol)
0041 {
0042   Standard_Boolean last = Standard_False;
0043   if (aprotocol.IsNull()) return;    // PAS de protocole = Lib VIDE
0044   if (!theprotocol.IsNull()) last =
0045     (theprotocol == aprotocol);
0046
0047   if (last) thelist = thelast;
0048 //  Si Pas d optimisation disponible : construire la liste
0049   else {
0050     AddProtocol(aprotocol);
0051 //  Ceci definit l optimisation (pour la fois suivante)
0052     thelast     = thelist;
0053     theprotocol = aprotocol;
0054   }
0055 }
0056
0057 //  Constructeur vide
0058     LibCtl_Library::LibCtl_Library ()    {  }
0059
0060
0061 //  Ajout d un Protocol : attention, desoptimise (sinon risque de confusion !)
0062     void LibCtl_Library::AddProtocol
0063   (const Handle(Standard_Transient)& aprotocol)
0064 {
0065 //  DownCast car Protocol->Resources, meme redefini et utilise dans d autres
0066 //  librairies, doit toujours renvoyer le type le plus haut
0067   Handle(TheProtocol) aproto = Handle(TheProtocol)::DownCast(aprotocol);
0068   if (aproto.IsNull()) return;
0069
0070 //  D abord, ajouter celui-ci a la liste : chercher le Node
0071   Handle(LibCtl_GlobalNode) curr;
0072   for (curr = theglobal; !curr.IsNull(); ) {        // curr->Next : plus loin
0073     const Handle(TheProtocol)& protocol = curr->Protocol();
0074     if (!protocol.IsNull()) {
0075 //  Match Protocol ?
0076       if (protocol->DynamicType() == aprotocol->DynamicType()) {
0077         if (thelist.IsNull()) thelist = new LibCtl_Node;
0078         thelist->AddNode(curr);
0079         break;  // UN SEUL MODULE PAR PROTOCOLE
0080       }
0081     }
0082     curr = curr->Next();  // cette formule est refusee dans "for"
0083   }
0084 //  Ensuite, Traiter les ressources
0085   Standard_Integer nb = aproto->NbResources();
0086   for (Standard_Integer i = 1; i <= nb; i ++) {
0087     AddProtocol (aproto->Resource(i));
0088   }
0089 //  Ne pas oublier de desoptimiser
0090   theprotocol.Nullify();
0091   thelast.Nullify();
0092 }
0093
0094     void LibCtl_Library::Clear ()
0095       {  thelist = new LibCtl_Node;  }
0096
0097     void LibCtl_Library::SetComplete ()
0098 {
0099   thelist = new LibCtl_Node;
0100 //    On prend chacun des Protocoles de la Liste Globale et on l ajoute
0101   Handle(LibCtl_GlobalNode) curr;
0102   for (curr = theglobal; !curr.IsNull(); ) {        // curr->Next : plus loin
0103     const Handle(TheProtocol)& protocol = curr->Protocol();
0104 //    Comme on prend tout tout tout, on ne se preoccupe pas des Ressources !
0105     if (!protocol.IsNull()) thelist->AddNode(curr);
0106     curr = curr->Next();  // cette formule est refusee dans "for"
0107   }
0108 }
0109
0110
0111 //  Selection : Tres fort, on retourne le Module correspondant a un Type
0112 //  (ainsi que le CaseNumber retourne par le protocole correspondant)
0113
0114     Standard_Boolean LibCtl_Library::Select
0115   (const TheObject& obj,
0116    Handle(TheModule)& module, Standard_Integer& CN) const
0117 {
0118   module.Nullify();  CN = 0;    // Reponse "pas trouve"
0119   if (thelist.IsNull()) return Standard_False;
0120   Handle(LibCtl_Node) curr = thelist;
0121   for (curr = thelist; !curr.IsNull(); ) {        // curr->Next : plus loin
0122     const Handle(TheProtocol)& protocol = curr->Protocol();
0123     if (!protocol.IsNull()) {
0124       CN = protocol->CaseNumber(obj);
0125       if (CN > 0) {
0126         module = curr->Module();
0127         return Standard_True;
0128       }
0129     }
0130     curr = curr->Next();        // cette formule est refusee dans "for"
0131   }
0132   return Standard_False;        // ici, pas trouce
0133 }
0134
0135
0136 //  ....                        Iteration                        ....
0137
0138     void LibCtl_Library::Start ()
0139       {  thecurr = thelist;  }
0140
0141     Standard_Boolean LibCtl_Library::More () const
0142       {  return (!thecurr.IsNull());  }
0143
0144     void LibCtl_Library::Next ()
0145       {  if (!thecurr.IsNull()) thecurr = thecurr->Next();  }
0146
0147     const Handle(TheModule)& LibCtl_Library::Module () const
0148 {
0149   if (thecurr.IsNull()) throw Standard_NoSuchObject("Library from LibCtl");
0150   return thecurr->Module();
0151 }
0152
0153     const Handle(TheProtocol)& LibCtl_Library::Protocol () const
0154 {
0155   if (thecurr.IsNull()) throw Standard_NoSuchObject("Library from LibCtl");
0156   return thecurr->Protocol();
0157 }