0031939: Coding - correction of spelling errors in comments
[occt.git] / src / IFSelect / IFSelect_SelectSignature.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14
15 #include <IFSelect_SelectSignature.hxx>
16 #include <IFSelect_Signature.hxx>
17 #include <IFSelect_SignCounter.hxx>
18 #include <Interface_Graph.hxx>
19 #include <Interface_InterfaceModel.hxx>
20 #include <Standard_Transient.hxx>
21 #include <Standard_Type.hxx>
22 #include <TCollection_AsciiString.hxx>
23
24 IMPLEMENT_STANDARD_RTTIEXT(IFSelect_SelectSignature,IFSelect_SelectExtract)
25
26 //  theexact : -1  OUI   0  NON une seule valeur  > 0 NON nb de valeurs
27 //  signmode : 1 prendre si contenu, 2 refuser si contenu
28 //             3 prendre si egal,    4 refuser si egal
29 //  ou test numerique, ajouter : 16 <  24 <=  32 >  40 >=
30 static Standard_Integer multsign
31   (const TCollection_AsciiString& signtext,
32    TColStd_SequenceOfAsciiString& signlist,
33    TColStd_SequenceOfInteger&     signmode)
34 {
35   Standard_Integer i, nb = signtext.Length(), mode = 0;
36   for (i = 1; i <= nb; i ++) {
37     char unsign = signtext.Value(i);
38     if (unsign == '|' || unsign == '!' || unsign == '=') { mode = 1; break; }
39     if (unsign == '<' || unsign == '>') { mode = 1; break; }
40   }
41   if (mode == 0) return mode;
42 //  On va tronconner
43   TCollection_AsciiString item;  Standard_Integer imod = 1;
44   for (i = 1; i <= nb; i ++) {
45     char unsign = signtext.Value(i);
46     if (unsign == '|' || unsign == '!') {
47       if (item.Length() > 0) {
48         signlist.Append (item);
49         signmode.Append (imod);
50         item.Clear();
51         mode ++;
52       }
53       imod = (unsign == '|' ? 1 : 2);
54     }
55     else if (unsign == '<') imod += 16;
56     else if (unsign == '>') imod += 32;
57     else if (unsign == '=') { if (imod < 8) imod += 2; else imod += 8; }
58     else item.AssignCat (unsign);
59   }
60   if (item.Length() > 0) {
61     signlist.Append (item);
62     signmode.Append (imod);
63 //    mode ++;  valait un au depart
64   }
65   return mode;
66 }
67
68
69
70     IFSelect_SelectSignature::IFSelect_SelectSignature
71   (const Handle(IFSelect_Signature)& matcher,
72    const TCollection_AsciiString& signtext, const Standard_Boolean exact)
73     : thematcher (matcher) , thesigntext (signtext) , theexact (exact ? -1 : 0)
74 {  if (!exact) theexact = multsign (thesigntext,thesignlist,thesignmode);  }
75
76     IFSelect_SelectSignature::IFSelect_SelectSignature
77   (const Handle(IFSelect_Signature)& matcher,
78    const Standard_CString signtext, const Standard_Boolean exact)
79     : thematcher (matcher) , thesigntext (signtext) , theexact (exact ? -1 : 0)
80 {  if (!exact) theexact = multsign (thesigntext,thesignlist,thesignmode);  }
81
82     IFSelect_SelectSignature::IFSelect_SelectSignature
83   (const Handle(IFSelect_SignCounter)& counter,
84    const Standard_CString signtext, const Standard_Boolean exact)
85     : thecounter (counter) , thesigntext (signtext) , theexact (exact ? -1 : 0)
86 {  if (!exact) theexact = multsign (thesigntext,thesignlist,thesignmode);  }
87
88     Handle(IFSelect_Signature)  IFSelect_SelectSignature::Signature () const
89       {  return thematcher;  }
90
91     Handle(IFSelect_SignCounter)  IFSelect_SelectSignature::Counter () const
92       {  return thecounter;  }
93
94
95     Standard_Boolean  IFSelect_SelectSignature::SortInGraph
96   (const Standard_Integer , const Handle(Standard_Transient)& ent,
97    const Interface_Graph& G) const
98 {
99   Standard_Boolean res;
100   Standard_CString txt;
101   Handle(Interface_InterfaceModel) model = G.Model();
102   if (theexact <= 0) {
103     if (!thematcher.IsNull()) return thematcher->Matches (ent,model,thesigntext, (theexact < 0));
104     txt = thecounter->ComputedSign(ent,G);
105     return IFSelect_Signature::MatchValue (txt,thesigntext , (theexact < 0));
106   }
107
108 //  sinon : liste
109 //  Analyse en sequence : si alternance prend/prend-pas, le dernier a raison
110 //   en consequence, si que des prend ou que des prend-pas, c est commutatif
111 //   DONC recommendation : mettre les prend-pas en fin
112
113 //  AU DEPART : prendre = ne prendre que. prend-pas = prend-tout-sauf ...
114 //  Donc si le premier est un prend-pas, je commence par tout prendre
115   Standard_Integer hmod = thesignmode.Value(1);
116   Standard_Integer jmod = hmod/8;
117   Standard_Integer imod = hmod - (jmod*8);
118   res = (imod == 2 || imod == 4);
119   for (Standard_Integer i = 1; i <= theexact; i ++) {
120     Standard_CString signtext = thesignlist.Value(i).ToCString();
121     hmod = thesignmode.Value(i);
122     jmod = hmod/8;
123     imod = hmod - (jmod*8);
124     Standard_Boolean quid;
125     if (jmod == 0) {
126       if (!thematcher.IsNull()) quid = thematcher->Matches (ent,model,signtext,(imod > 2));
127       else quid = IFSelect_Signature::MatchValue
128         ( thecounter->ComputedSign(ent,G),signtext, (imod > 2) );
129     }
130     else {
131       if (!thematcher.IsNull()) txt = thematcher->Value (ent,model);
132       else txt = thecounter->ComputedSign (ent,G);
133
134       Standard_Integer val = atoi(txt);
135       Standard_Integer lav = atoi (signtext);
136       switch (jmod) {
137         case 2 : quid = (val <  lav); break;
138         case 3 : quid = (val <= lav); break;
139         case 4 : quid = (val >  lav); break;
140         case 5 : quid = (val >= lav); break;
141         default : quid = Standard_False; break;
142       }
143     }
144     if ((imod == 1 || imod == 3) && quid) res = Standard_True;
145     if ((imod == 2 || imod == 4) && quid) res = Standard_False;
146   }
147   return res;
148 }
149
150     Standard_Boolean  IFSelect_SelectSignature::Sort
151   (const Standard_Integer , const Handle(Standard_Transient)& /*ent*/,
152    const Handle(Interface_InterfaceModel)& /*model*/) const
153 {  return Standard_True;  }
154
155     const TCollection_AsciiString&  IFSelect_SelectSignature::SignatureText () const
156       {  return thesigntext;  }
157
158     Standard_Boolean  IFSelect_SelectSignature::IsExact () const
159       {  return (theexact < 0);  }
160
161     TCollection_AsciiString  IFSelect_SelectSignature::ExtractLabel () const
162 {
163   TCollection_AsciiString lab;
164   if (!thematcher.IsNull()) lab.AssignCat (thematcher->Name());
165   else                      lab.AssignCat (thecounter->Name());
166   if      (theexact  < 0) lab.AssignCat(" matching ");
167   else if (theexact == 0) lab.AssignCat(" containing ");
168   else                    lab.AssignCat(" matching list ");
169   lab.AssignCat(thesigntext);
170   return lab;
171 }