]> SALOME platform Git repositories - modules/yacs.git/blob - src/yacsloader/procParsers.hxx
Salome HOME
Deleted deprecated code
[modules/yacs.git] / src / yacsloader / procParsers.hxx
1 // Copyright (C) 2006-2016  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #ifndef _PROCPARSER_HXX_
21 #define _PROCPARSER_HXX_
22
23 #include "blocParsers.hxx"
24 #include "typeParsers.hxx"
25 #include "containerParsers.hxx"
26 #include "componentinstanceParsers.hxx"
27 #include "nodeParsers.hxx"
28
29 #include "Proc.hxx"
30 #include "Container.hxx"
31 #include "TypeCode.hxx"
32
33 extern YACS::ENGINE::Proc* currentProc;
34
35 namespace YACS
36 {
37
38 template <class T=YACS::ENGINE::Proc*>
39 struct proctypeParser: bloctypeParser<T>
40 {
41
42   static proctypeParser<T> procParser;
43
44   proctypeParser():bloctypeParser<T>()
45   {
46     this->_orders["type"]=1;
47     this->_orders["sequence"]=1;
48     this->_orders["objref"]=1;
49   }
50   void onStart(const XML_Char* el, const XML_Char** attr);
51   virtual void onEnd(const char *el,parser* child);
52   virtual void buildAttr(const XML_Char** attr)
53     {
54           if (!attr)
55                 return;
56       for (int i = 0; attr[i]; i += 2) 
57         {
58           if(std::string(attr[i]) == "state")
59             this->state(attr[i+1]);
60           if(std::string(attr[i]) == "name")
61             name(attr[i+1]);
62         }
63     }
64   virtual void pre()
65     {
66         std::string name("proc");
67         currentProc=theRuntime->createProc(name);
68         this->_bloc=currentProc;
69         currentProc->names.push_back("");
70     }
71
72   virtual void name(const std::string& name)
73     {
74       currentProc->setName(name);
75     }
76
77   virtual void type(const mytype& t)
78     {
79         DEBTRACE( "type_set" );
80         YACS::ENGINE::TypeCode* tt=currentProc->createType(t._name,t._kind);
81         tt->decrRef();
82     }
83   virtual void sequence(ENGINE::TypeCode* const& t)
84     {
85         DEBTRACE( "sequence_set" );
86         t->decrRef();
87     }
88   virtual void objref(ENGINE::TypeCode* const& t)
89     {
90         DEBTRACE( "objref_set" );
91         t->decrRef();
92     }
93   virtual void struct_(ENGINE::TypeCode* const& t)
94     {
95         DEBTRACE( "struct_set" );
96         t->decrRef();
97     }
98
99   virtual void componentinstance(const mycomponentinstance& t)
100     {
101       DEBTRACE( "componentinstance: " << t._name );
102       YACS::ENGINE::ComponentInstance* inst=currentProc->createComponentInstance(t._component,t._name,t._kind);
103
104       // Set all properties for this component instance
105       std::map<std::string, std::string>::const_iterator pt;
106       for(pt=t._props.begin();pt!=t._props.end();pt++)
107         inst->setProperty((*pt).first,(*pt).second);
108
109       //associate a container to the component instance
110       if(currentProc->containerMap.count(t._container) != 0)
111         {
112           inst->setContainer(currentProc->containerMap[t._container]);
113         }
114       else if(t._container == "")
115         {
116           if(currentProc->containerMap.count("DefaultContainer") != 0)
117           {
118             //a default container is defined : use it if supported
119             try
120             {
121               currentProc->containerMap["DefaultContainer"]->checkCapabilityToDealWith(inst);
122               inst->setContainer(currentProc->containerMap["DefaultContainer"]);
123             }
124             catch(YACS::Exception){}
125           }
126         }
127       else
128         {
129           std::cerr << "WARNING: Unknown container " << t._container << " ignored" << std::endl;
130         }
131
132       inst->decrRef();
133     }
134
135   virtual void container(const mycontainer& t)
136     {
137       DEBTRACE( "container_set: " << t._name )             
138       std::vector<machine>::const_iterator iter;
139       for(iter=t._machs.begin();iter!=t._machs.end();iter++)
140         {
141           DEBTRACE( "machine name: " << (*iter)._name )             
142         }
143
144       if(currentProc->containerMap.count(t._name) != 0 && t._name != "DefaultContainer")
145         {
146           std::cerr << "Warning: container " << t._name << " already defined. It will be ignored" << std::endl;
147         }
148       else
149         {
150           // Set all properties for this container
151           std::string kindOfContainer;
152           std::map<std::string, std::string>::const_iterator pt(t._props.find(std::string(ENGINE::Container::KIND_ENTRY)));
153           if(pt!=t._props.end())
154             kindOfContainer=pt->second;
155           YACS::ENGINE::Container *cont(currentProc->createContainer(t._name,kindOfContainer));
156           for(pt=t._props.begin();pt!=t._props.end();pt++)
157             if((*pt).second!=ENGINE::Container::KIND_ENTRY)
158               cont->setProperty((*pt).first,(*pt).second);
159           cont->decrRef();
160         }
161     }
162
163   T post() { return this->_bloc; }
164 };
165
166 template <class T> proctypeParser<T> proctypeParser<T>::procParser;
167
168 }
169
170 namespace YACS
171 {
172 template <class T>
173 void proctypeParser<T>::onStart(const XML_Char* el, const XML_Char** attr)
174   {
175     DEBTRACE( "proctypeParser::onStart: " << el )
176     std::string element(el);
177     this->checkOrder(element);
178     parser* pp=&parser::main_parser;
179     if(element == "property")pp=&propertytypeParser::propertyParser;
180     else if(element == "type")pp=&typetypeParser::typeParser;
181     else if(element == "sequence")pp=&seqtypeParser::seqParser;
182     else if(element == "objref")pp=&objtypeParser::objParser;
183     else if(element == "struct")pp=&structtypeParser::structParser;
184     else if(element == "container")pp=&containertypeParser::containerParser;
185     else if(element == "componentinstance")pp=&componentinstancetypeParser::componentinstanceParser;
186
187     else if(element == "inline")pp=&inlinetypeParser<>::inlineParser;
188     else if(element == "sinline")pp=&sinlinetypeParser<>::sinlineParser;
189     else if(element == "service")pp=&servicetypeParser<>::serviceParser;
190     else if(element == "server")pp=&servertypeParser<>::serverParser;
191     else if(element == "remote")pp=&remotetypeParser<>::remoteParser;
192     else if(element == "node")pp=&nodetypeParser<>::nodeParser;
193     else if(element == "datanode")pp=&presettypeParser<>::presetParser;
194     else if(element == "outnode")pp=&outnodetypeParser<>::outnodeParser;
195
196     else if(element == "bloc")pp=&bloctypeParser<>::blocParser;
197     else if(element == "forloop")pp=&forlooptypeParser<>::forloopParser;
198     else if(element == "foreach")pp=&foreachlooptypeParser<>::foreachloopParser;
199     else if(element == "optimizer")pp=&optimizerlooptypeParser<>::optimizerloopParser;
200     else if(element == "while")pp=&whilelooptypeParser<>::whileloopParser;
201     else if(element == "switch")pp=&switchtypeParser::switchParser;
202
203     else if(element == "control")pp=&controltypeParser<>::controlParser;
204     else if(element == "datalink")pp=&linktypeParser<>::linkParser;
205     else if(element == "stream")pp=&streamtypeParser<>::streamParser;
206     else if(element == "parameter")pp=&parametertypeParser::parameterParser;
207     else
208       {
209         // OCC: san -- Allow external parsers for handling of unknown elements
210         // and attributes. This capability is used by YACS GUI to read
211         // graph presentation data
212         if ( this->_defaultParsersMap )
213           {
214             if((this->_defaultParsersMap)->count(element) != 0)
215               {
216                 pp=(*(this->_defaultParsersMap))[element];
217               }
218             else
219               {
220                 std::cerr << "There is no parser for this element type. It will be ignored! " << element << std::endl;
221               }
222           }
223       }
224     this->SetUserDataAndPush(pp);
225     pp->init();
226     pp->pre();
227     pp->buildAttr(attr);
228   }
229
230 template <class T>
231 void proctypeParser<T>::onEnd(const char *el,parser* child)
232     {
233       DEBTRACE( "proctypeParser::onEnd: " << el )
234       std::string element(el);
235       if(element == "property")this->property(((propertytypeParser*)child)->post());
236       else if(element == "type")type(((typetypeParser*)child)->post());
237       else if(element == "sequence")sequence(((seqtypeParser*)child)->post());
238       else if(element == "objref")objref(((objtypeParser*)child)->post());
239       else if(element == "struct")struct_(((structtypeParser*)child)->post());
240       else if(element == "container")container(((containertypeParser*)child)->post());
241       else if(element == "componentinstance")componentinstance(((componentinstancetypeParser*)child)->post());
242
243       else if(element == "inline")this->inline_(((inlinetypeParser<>*)child)->post());
244       else if(element == "sinline")this->sinline(((sinlinetypeParser<>*)child)->post());
245       else if(element == "service")this->service(((servicetypeParser<>*)child)->post());
246       else if(element == "server")this->server(((servertypeParser<>*)child)->post());
247       else if(element == "remote")this->remote(((remotetypeParser<>*)child)->post());
248       else if(element == "node")this->node(((nodetypeParser<>*)child)->post());
249       else if(element == "datanode")this->preset(((presettypeParser<>*)child)->post());
250       else if(element == "outnode")this->outnode(((outnodetypeParser<>*)child)->post());
251
252       else if(element == "bloc")this->bloc(((bloctypeParser<>*)child)->post());
253       else if(element == "forloop")this->forloop(((forlooptypeParser<>*)child)->post());
254       else if(element == "foreach")this->foreach(((foreachlooptypeParser<>*)child)->post());
255       else if(element == "optimizer")this->optimizer(((optimizerlooptypeParser<>*)child)->post());
256       else if(element == "while")this->while_(((whilelooptypeParser<>*)child)->post());
257       else if(element == "switch")this->switch_(((switchtypeParser*)child)->post());
258  
259       else if(element == "control") this->control(((controltypeParser<>*)child)->post());
260       else if(element == "datalink") this->datalink(((linktypeParser<>*)child)->post());
261       else if(element == "stream") this->stream(((streamtypeParser<>*)child)->post());
262       else if(element == "parameter") this->parameter(((parametertypeParser*)child)->post());
263     }
264
265 }
266
267 #endif