Back to index

salome-geom  6.5.0
NMTDS_PassKey.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 // File:        NMTDS_PassKey.cxx
00024 // Created:     
00025 // Author:      Peter KURNEV
00026 //              <peter@PREFEX>
00027 //
00028 #include <NMTDS_PassKey.hxx>
00029 
00030 #include <stdio.h>
00031 #include <string.h>
00032 #include <TColStd_ListIteratorOfListOfInteger.hxx>
00033 #include <TColStd_ListOfInteger.hxx>
00034 
00035 #ifdef WNT
00036 #pragma warning( disable : 4101) 
00037 #endif
00038 
00039 static
00040   Standard_Integer NormalizedId(const Standard_Integer aId,
00041                                 const Standard_Integer aDiv);
00042 
00043 //=======================================================================
00044 //function :
00045 //purpose  : 
00046 //=======================================================================
00047   NMTDS_PassKey::NMTDS_PassKey()
00048 {
00049  Clear(); 
00050 }
00051 //=======================================================================
00052 //function :
00053 //purpose  : 
00054 //=======================================================================
00055   NMTDS_PassKey::NMTDS_PassKey(const NMTDS_PassKey& aOther)
00056 {
00057   myNbIds=aOther.myNbIds;
00058   mySum=aOther.mySum;
00059   myMap=aOther.myMap;
00060 }
00061 //=======================================================================
00062 //function :operator =
00063 //purpose  : 
00064 //=======================================================================
00065   NMTDS_PassKey& NMTDS_PassKey::operator =(const NMTDS_PassKey& aOther)
00066 {
00067   myNbIds=aOther.myNbIds;
00068   mySum=aOther.mySum;
00069   myMap=aOther.myMap;
00070   return *this;
00071 }
00072 //=======================================================================
00073 //function :~
00074 //purpose  : 
00075 //=======================================================================
00076   NMTDS_PassKey::~NMTDS_PassKey()
00077 {
00078 }
00079 //=======================================================================
00080 //function :Clear
00081 //purpose  : 
00082 //=======================================================================
00083   void NMTDS_PassKey::Clear()
00084 {
00085   myNbIds=0;
00086   mySum=0;
00087   myMap.Clear();
00088 }
00089 //=======================================================================
00090 //function :SetIds
00091 //purpose  : 
00092 //=======================================================================
00093   void NMTDS_PassKey::SetIds(const Standard_Integer aId1)
00094                                
00095 {
00096   Clear();
00097   myNbIds=1;
00098   myMap.Add(aId1);
00099   mySum=NormalizedId(aId1, myNbIds);
00100 }
00101 //=======================================================================
00102 //function :SetIds
00103 //purpose  : 
00104 //=======================================================================
00105   void NMTDS_PassKey::SetIds(const Standard_Integer aId1,
00106                              const Standard_Integer aId2)
00107 {
00108   TColStd_ListOfInteger aLI;
00109   //
00110   aLI.Append(aId1);
00111   aLI.Append(aId2);
00112   SetIds(aLI);
00113 }
00114 //=======================================================================
00115 //function :SetIds
00116 //purpose  : 
00117 //=======================================================================
00118   void NMTDS_PassKey::SetIds(const Standard_Integer aId1,
00119                              const Standard_Integer aId2,
00120                              const Standard_Integer aId3)
00121 {
00122   TColStd_ListOfInteger aLI;
00123   //
00124   aLI.Append(aId1);
00125   aLI.Append(aId2);
00126   aLI.Append(aId3);
00127   SetIds(aLI);
00128 }
00129 //=======================================================================
00130 //function :SetIds
00131 //purpose  : 
00132 //=======================================================================
00133   void NMTDS_PassKey::SetIds(const Standard_Integer aId1,
00134                              const Standard_Integer aId2,
00135                              const Standard_Integer aId3,
00136                              const Standard_Integer aId4)
00137 { 
00138   TColStd_ListOfInteger aLI;
00139   //
00140   aLI.Append(aId1);
00141   aLI.Append(aId2);
00142   aLI.Append(aId3);
00143   aLI.Append(aId4);
00144   SetIds(aLI);
00145 }
00146 //=======================================================================
00147 //function :SetIds
00148 //purpose  : 
00149 //=======================================================================
00150   void NMTDS_PassKey::SetIds(const TColStd_ListOfInteger& aLI)
00151 {
00152   Standard_Integer i, aId, aIdN;
00153   TColStd_ListIteratorOfListOfInteger aIt;
00154   //
00155   Clear();
00156   aIt.Initialize(aLI);
00157   for (; aIt.More(); aIt.Next()) {
00158     aId=aIt.Value();
00159     myMap.Add(aId);
00160   }
00161   myNbIds=myMap.Extent();
00162   for(i=1; i<=myNbIds; ++i) {
00163     aId=myMap(i);
00164     aIdN=NormalizedId(aId, myNbIds);
00165     mySum+=aIdN;
00166   }
00167 }
00168 
00169 //=======================================================================
00170 //function :NbIds
00171 //purpose  : 
00172 //=======================================================================
00173   Standard_Integer NMTDS_PassKey::NbIds()const
00174 {
00175   return myNbIds;
00176 }
00177 //=======================================================================
00178 //function :Id
00179 //purpose  : 
00180 //=======================================================================
00181   Standard_Integer NMTDS_PassKey::Id(const Standard_Integer aIndex) const
00182 {
00183   if (aIndex<1 || aIndex>myNbIds) {
00184     return -1;
00185   }
00186   return myMap(aIndex);
00187 }
00188 //=======================================================================
00189 //function :Ids
00190 //purpose  : 
00191 //=======================================================================
00192   void NMTDS_PassKey::Ids(Standard_Integer& aId1,
00193                           Standard_Integer& aId2) const
00194 {
00195   aId1=0;
00196   aId2=0;
00197   if (myNbIds>1) {
00198     aId1=myMap(1);
00199     aId2=myMap(2);
00200   }
00201 }
00202 //=======================================================================
00203 //function :IsEqual
00204 //purpose  : 
00205 //=======================================================================
00206   Standard_Boolean NMTDS_PassKey::IsEqual(const NMTDS_PassKey& aOther) const
00207 {
00208   Standard_Boolean bRet;
00209   Standard_Integer i, aId;
00210   //
00211   bRet=Standard_False;
00212   //
00213   if (myNbIds!=aOther.myNbIds) {
00214     return bRet;
00215   }
00216   for (i=1; i<=myNbIds; ++i) {
00217     aId=myMap(i);
00218     if (!aOther.myMap.Contains(aId)) {
00219       return bRet;
00220     }
00221   }
00222   return !bRet;
00223 }
00224 //=======================================================================
00225 //function : HashCode
00226 //purpose  : 
00227 //=======================================================================
00228   Standard_Integer NMTDS_PassKey::HashCode(const Standard_Integer aUpper) const
00229 {
00230   return ::HashCode(mySum, aUpper);
00231 }
00232 //=======================================================================
00233 //function : Dump
00234 //purpose  : 
00235 //=======================================================================
00236   void NMTDS_PassKey::Dump(const Standard_Integer )const
00237 {
00238 }
00239 
00240 //=======================================================================
00241 // function: NormalizedId
00242 // purpose : 
00243 //=======================================================================
00244 Standard_Integer NormalizedId(const Standard_Integer aId,
00245                               const Standard_Integer aDiv)
00246 {
00247   Standard_Integer aMax, aTresh, aIdRet;
00248   //
00249   aIdRet=aId;
00250   aMax=::IntegerLast();
00251   aTresh=aMax/aDiv;
00252   if (aId>aTresh) {
00253     aIdRet=aId%aTresh;
00254   }
00255   return aIdRet;
00256 }
00257 /*
00258 //=========
00259 //=======================================================================
00260 //function : Contains
00261 //purpose  : 
00262 //=======================================================================
00263   Standard_Boolean NMTDS_PassKey::Contains(const Standard_Integer aId) const
00264 {
00265   return myMap.Contains(aId);
00266 }
00267 //=======================================================================
00268 //function :Contains
00269 //purpose  : 
00270 //=======================================================================
00271   Standard_Boolean NMTDS_PassKey::Contains(const NMTDS_PassKey& aOther) const
00272 {
00273   Standard_Boolean bRet;
00274   Standard_Integer i, aId;
00275   //
00276   bRet=Standard_False;
00277   //
00278   if (myNbIds<aOther.myNbIds) {
00279     return bRet;
00280   }
00281   for (i=1; i<=aOther.myNbIds; ++i) {
00282     aId=aOther.myMap(i);
00283     if (!myMap.Contains(aId)) {
00284       return bRet;
00285     }
00286   }
00287   return !bRet;
00288 }
00289 //=======================================================================
00290 //function :Intersected
00291 //purpose  : 
00292 //=======================================================================
00293   Standard_Boolean NMTDS_PassKey::Intersected(const NMTDS_PassKey& aOther) const
00294 {
00295   Standard_Boolean bRet;
00296   Standard_Integer i, aId;
00297   //
00298   bRet=Standard_False;
00299   //
00300   for (i=1; i<=myNbIds; ++i) {
00301     aId=myMap(i);
00302     if (aOther.Contains(aId)) {
00303       return !bRet;
00304     }
00305   }
00306   return bRet;
00307 }
00308 //=======================================================================
00309 //function : Add
00310 //purpose  : 
00311 //=======================================================================
00312   void NMTDS_PassKey::Add(const Standard_Integer aId)
00313 {
00314   TColStd_ListOfInteger aLI;
00315   aLI.Append(aId);
00316   //
00317   Add(aLI);
00318 }
00319 //=======================================================================
00320 //function : Add
00321 //purpose  : 
00322 //=======================================================================
00323   void NMTDS_PassKey::Add(const NMTDS_PassKey& aOther) 
00324 {
00325   Standard_Integer i, aId;
00326   TColStd_ListOfInteger aLS;
00327   //
00328   for(i=1; i<=myNbIds; ++i) {
00329     aId=myMap(i);
00330     aLS.Append(aId);
00331   }
00332   for(i=1; i<=aOther.myNbIds; ++i) {
00333     aId=aOther.myMap(i);
00334     aLS.Append(aId);
00335   }
00336   //
00337   Add(aLS);
00338 }
00339 //=======================================================================
00340 //function : Add
00341 //purpose  : 
00342 //=======================================================================
00343   void NMTDS_PassKey::Add(const TColStd_ListOfInteger& aLI)
00344 {
00345   Standard_Integer i, aId;
00346   TColStd_ListOfInteger aLS;
00347   TColStd_ListIteratorOfListOfInteger aIt;
00348   //
00349   for(i=1; i<=myNbIds; ++i) {
00350     aId=myMap(i);
00351     aLS.Append(aId);
00352   }
00353   aIt.Initialize(aLI);
00354   for (; aIt.More(); aIt.Next()) {
00355     aId=aIt.Value();
00356     aLS.Append(aId);
00357   }
00358   //
00359   SetIds(aLS);
00360 }
00361 //=========
00362 */