src/TDataStd/TDataStd_NamedData.cxx

   1 // Created on: 2007-05-29
   2 // Created by: Vlad Romashko
   3 // Copyright (c) 2007-2012 OPEN CASCADE SAS
   4 //
   5 // The content of this file is subject to the Open CASCADE Technology Public
   6 // License Version 6.5 (the "License"). You may not use the content of this file
   7 // except in compliance with the License. Please obtain a copy of the License
   8 // at http://www.opencascade.org and read it completely before using this file.
   9 //
  10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  12 //
  13 // The Original Code and all software distributed under the License is
  14 // distributed on an "AS IS" basis, without warranty of any kind, and the
  15 // Initial Developer hereby disclaims all such warranties, including without
  16 // limitation, any warranties of merchantability, fitness for a particular
  17 // purpose or non-infringement. Please see the License for the specific terms
  18 // and conditions governing the rights and limitations under the License.
  19
  20
  21 #include <TDataStd_NamedData.ixx>
  22
  23 #include <TColStd_DataMapIteratorOfDataMapOfStringInteger.hxx>
  24 #include <TDataStd_DataMapIteratorOfDataMapOfStringReal.hxx>
  25 #include <TDataStd_DataMapIteratorOfDataMapOfStringString.hxx>
  26 #include <TDataStd_DataMapIteratorOfDataMapOfStringByte.hxx>
  27 #include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger.hxx>
  28 #include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal.hxx>
  29
  30 #ifdef WNT
  31 #define EXCEPTION ...
  32 #else
  33 #define EXCEPTION Standard_Failure
  34 #endif
  35 //=======================================================================
  36 //function : GetID
  37 //purpose  :
  38 //=======================================================================
  39 const Standard_GUID& TDataStd_NamedData::GetID()
  40 {
  41   static Standard_GUID TDataStd_NamedDataID ("F170FD21-CBAE-4e7d-A4B4-0560A4DA2D16");
  42   return TDataStd_NamedDataID;
  43 }
  44
  45 //=======================================================================
  46 //function : TDataStd_NamedData
  47 //purpose  : Empty Constructor
  48 //=======================================================================
  49 TDataStd_NamedData::TDataStd_NamedData()
  50 {
  51
  52 }
  53
  54 //=======================================================================
  55 //function : Set
  56 //purpose  :
  57 //=======================================================================
  58 Handle(TDataStd_NamedData) TDataStd_NamedData::Set(const TDF_Label& label)
  59 {
  60   Handle(TDataStd_NamedData) A;
  61   if (!label.FindAttribute (TDataStd_NamedData::GetID(), A))
  62   {
  63     A = new TDataStd_NamedData;
  64     label.AddAttribute(A);
  65   }
  66   return A;
  67 }
  68
  69
  70 //Category: Integers
  71
  72 //=======================================================================
  73 //function : HasInteger
  74 //purpose  : Returns true if the attribute contains this named integer.
  75 //=======================================================================
  76 Standard_Boolean TDataStd_NamedData::HasInteger(const TCollection_ExtendedString& theName) const
  77 {
  78   if(!HasIntegers()) return Standard_False;
  79   return myIntegers->Map().IsBound(theName);
  80 }
  81
  82 //=======================================================================
  83 //function :  GetInteger
  84 //purpose  : Returns the named integer. It returns 0 if there is no such
  85 //         : a named integer(use HasInteger()).
  86 //=======================================================================
  87 Standard_Integer TDataStd_NamedData::GetInteger(const TCollection_ExtendedString& theName)
  88 {
  89   if(!HasIntegers()) {
  90     TColStd_DataMapOfStringInteger aMap;
  91     myIntegers = new TDataStd_HDataMapOfStringInteger(aMap);
  92   }
  93   return myIntegers->Map()(theName);
  94 }
  95
  96 //=======================================================================
  97 //function : SetInteger
  98 //purpose  : Defines a named integer. If the integer already exists,
  99 //         : it changes its value to <theInteger>.
 100 //=======================================================================
 101 void TDataStd_NamedData::SetInteger(const TCollection_ExtendedString& theName,
 102                                     const Standard_Integer theInteger)
 103 {
 104   if(!HasIntegers()) {
 105     TColStd_DataMapOfStringInteger aMap;
 106     myIntegers = new TDataStd_HDataMapOfStringInteger(aMap);
 107   }
 108   if (!myIntegers->Map().IsBound(theName) || myIntegers->Map().Find(theName) != theInteger)
 109   {
 110     Backup();
 111     if (myIntegers->Map().IsBound(theName))
 112       myIntegers->ChangeMap().ChangeFind(theName) = theInteger;
 113     else
 114       myIntegers->ChangeMap().Bind(theName, theInteger);
 115   }
 116 }
 117
 118 //=======================================================================
 119 //function : GetIntegersContainer
 120 //purpose  : Returns the internal container of named integers.
 121 //         : Use before HasIntegers()
 122 //=======================================================================
 123 const TColStd_DataMapOfStringInteger& TDataStd_NamedData::GetIntegersContainer()
 124 {
 125   if(!HasIntegers()) {
 126     TColStd_DataMapOfStringInteger aMap;
 127     myIntegers = new TDataStd_HDataMapOfStringInteger(aMap);
 128   }
 129   return myIntegers->Map();
 130 }
 131
 132 //=======================================================================
 133 //function : ChangeIntegers
 134 //purpose  : Replace the container content by new content of the <theIntegers>.
 135 //=======================================================================
 136 void TDataStd_NamedData::ChangeIntegers(const TColStd_DataMapOfStringInteger& theIntegers)
 137 {
 138   if(!HasIntegers()) {
 139     TColStd_DataMapOfStringInteger aMap;
 140     myIntegers = new TDataStd_HDataMapOfStringInteger(aMap);
 141   };
 142   if (&myIntegers->Map() == &theIntegers) return;
 143   Backup();
 144   myIntegers->ChangeMap().Assign(theIntegers);
 145 }
 146
 147
 148 //Category: Reals
 149 //          =====
 150
 151 //=======================================================================
 152 //function : HasReal
 153 //purpose  : Returns true if the attribute contains this named real.
 154 //=======================================================================
 155 Standard_Boolean TDataStd_NamedData::HasReal(const TCollection_ExtendedString& theName) const
 156 {
 157   if(!HasReals()) return Standard_False;
 158   return myReals->Map().IsBound(theName);
 159 }
 160
 161 //=======================================================================
 162 //function : GetReal
 163 //purpose  : Returns the named real. It returns 0 if there is no such
 164 //         : a named real (use HasReal()).
 165 //=======================================================================
 166 Standard_Real TDataStd_NamedData::GetReal(const TCollection_ExtendedString& theName)
 167 {
 168   if(!HasReals()) {
 169     TDataStd_DataMapOfStringReal aMap;
 170     myReals = new TDataStd_HDataMapOfStringReal(aMap);
 171   }
 172   return myReals->Map()(theName);
 173 }
 174
 175 //=======================================================================
 176 //function : SetReal
 177 //purpose  : Defines a named real. If the real already exists,
 178 //         : it changes its value to <theReal>.
 179 //=======================================================================
 180 void TDataStd_NamedData::SetReal(const TCollection_ExtendedString& theName,
 181                                  const Standard_Real theReal)
 182 {
 183   if(!HasReals()) {
 184     TDataStd_DataMapOfStringReal aMap;
 185     myReals = new TDataStd_HDataMapOfStringReal(aMap);
 186  }
 187   if (!myReals->Map().IsBound(theName) || myReals->Map().Find(theName) != theReal)
 188   {
 189     Backup();
 190     if (myReals->Map().IsBound(theName))
 191       myReals->ChangeMap().ChangeFind(theName) = theReal;
 192     else
 193       myReals->ChangeMap().Bind(theName, theReal);
 194   }
 195 }
 196
 197 //=======================================================================
 198 //function : GetRealsContainer
 199 //purpose  : Returns the internal container of named reals.
 200 //=======================================================================
 201 const TDataStd_DataMapOfStringReal& TDataStd_NamedData::GetRealsContainer()
 202 {
 203   if(!HasReals()) {
 204     TDataStd_DataMapOfStringReal aMap;
 205     myReals = new TDataStd_HDataMapOfStringReal(aMap);
 206   }
 207   return myReals->Map();
 208 }
 209
 210 //=======================================================================
 211 //function : ChangeReals
 212 //purpose  : Replace the container content by new content of the <theReals>.
 213 //=======================================================================
 214 void TDataStd_NamedData::ChangeReals(const TDataStd_DataMapOfStringReal& theReals)
 215 {
 216   if(!HasReals()) {
 217     TDataStd_DataMapOfStringReal aMap;
 218     myReals = new TDataStd_HDataMapOfStringReal(aMap);
 219   }
 220   if (&myReals->Map() == &theReals) return;
 221   Backup();
 222   myReals->ChangeMap().Assign(theReals);
 223 }
 224
 225
 226 //Category: Strings
 227 //          =======
 228 //=======================================================================
 229 //function : HasString
 230 //purpose  : Returns true if the attribute contains this named string.
 231 //=======================================================================
 232 Standard_Boolean TDataStd_NamedData::HasString(const TCollection_ExtendedString& theName) const
 233 {
 234   if(!HasStrings()) return Standard_False;
 235   return myStrings->Map().IsBound(theName);
 236 }
 237
 238 //=======================================================================
 239 //function : GetString
 240 //purpose  : Returns the named string.It returns empty string if there is
 241 //         : string specified by the Name(use HasString()).
 242 //=======================================================================
 243 const TCollection_ExtendedString& TDataStd_NamedData::GetString(const TCollection_ExtendedString& theName)
 244 {
 245   if(!HasStrings()) {
 246     TDataStd_DataMapOfStringString aMap;
 247     myStrings = new TDataStd_HDataMapOfStringString(aMap);
 248   }
 249   return myStrings->Map()(theName);
 250 }
 251
 252 //=======================================================================
 253 //function : SetString
 254 //purpose  : Defines a named string. If the string already exists,
 255 //         : it changes its value to <theString>.
 256 //=======================================================================
 257 void TDataStd_NamedData::SetString(const TCollection_ExtendedString& theName,
 258                                    const TCollection_ExtendedString& theString)
 259 {
 260   if(!HasStrings()) {
 261     TDataStd_DataMapOfStringString aMap;
 262     myStrings = new TDataStd_HDataMapOfStringString(aMap);
 263   }
 264   if (!myStrings->Map().IsBound(theName) || myStrings->Map().Find(theName) != theString)
 265   {
 266     Backup();
 267     if (myStrings->Map().IsBound(theName))
 268       myStrings->ChangeMap().ChangeFind(theName) = theString;
 269     else
 270       myStrings->ChangeMap().Bind(theName, theString);
 271   }
 272 }
 273
 274 //=======================================================================
 275 //function : GetStringsContainer
 276 //purpose  : Returns the internal container of named strings.
 277 //=======================================================================
 278 const TDataStd_DataMapOfStringString& TDataStd_NamedData::GetStringsContainer()
 279 {
 280   if(!HasStrings()) {
 281     TDataStd_DataMapOfStringString aMap;
 282     myStrings = new TDataStd_HDataMapOfStringString(aMap);
 283   }
 284   return myStrings->Map();
 285 }
 286
 287 //=======================================================================
 288 //function : ChangeStrings
 289 //purpose  : Replace the container content by new content of the <theStrings>.
 290 //=======================================================================
 291 void TDataStd_NamedData::ChangeStrings(const TDataStd_DataMapOfStringString& theStrings)
 292 {
 293   if(!HasStrings()) {
 294     TDataStd_DataMapOfStringString aMap;
 295     myStrings = new TDataStd_HDataMapOfStringString(aMap);
 296   }
 297   if (&myStrings->Map() == &theStrings) return;
 298   Backup();
 299   myStrings->ChangeMap().Assign(theStrings);
 300 }
 301
 302
 303 //Category: Bytes
 304 //          =====
 305 //=======================================================================
 306 //function : HasByte
 307 //purpose  : Returns true if the attribute contains this named byte.
 308 //=======================================================================
 309 Standard_Boolean TDataStd_NamedData::HasByte(const TCollection_ExtendedString& theName) const
 310 {
 311   if(!HasBytes()) return Standard_False;
 312   return myBytes->Map().IsBound(theName);
 313 }
 314
 315 //=======================================================================
 316 //function : GetByte
 317 //purpose  : Returns the named byte. It returns 0 if there is no such
 318 //         : a named byte (use HasByte()).
 319 //=======================================================================
 320 Standard_Byte TDataStd_NamedData::GetByte(const TCollection_ExtendedString& theName)
 321 {
 322   if(!HasBytes()) {
 323     TDataStd_DataMapOfStringByte aMap;
 324     myBytes = new TDataStd_HDataMapOfStringByte(aMap);
 325   }
 326   return myBytes->Map()(theName);
 327 }
 328
 329 //=======================================================================
 330 //function : SetByte
 331 //purpose  : Defines a named byte. If the byte already exists,
 332 //         : it changes its value to <theByte>.
 333 //=======================================================================
 334 void TDataStd_NamedData::SetByte(const TCollection_ExtendedString& theName,
 335                                  const Standard_Byte theByte)
 336 {
 337   if(!HasBytes()) {
 338     TDataStd_DataMapOfStringByte aMap;
 339     myBytes = new TDataStd_HDataMapOfStringByte(aMap);
 340   }
 341   if (!myBytes->Map().IsBound(theName) || myBytes->Map().Find(theName) != theByte)
 342   {
 343     Backup();
 344     if (myBytes->Map().IsBound(theName))
 345       myBytes->ChangeMap().ChangeFind(theName) = theByte;
 346     else
 347       myBytes->ChangeMap().Bind(theName, theByte);
 348   }
 349 }
 350
 351 //=======================================================================
 352 //function : GetBytesContainer
 353 //purpose  : Returns the internal container of named bytes.
 354 //=======================================================================
 355 const TDataStd_DataMapOfStringByte& TDataStd_NamedData::GetBytesContainer()
 356 {
 357   if(!HasBytes()) {
 358     TDataStd_DataMapOfStringByte aMap;
 359     myBytes = new TDataStd_HDataMapOfStringByte(aMap);
 360   }
 361   return myBytes->Map();
 362 }
 363
 364 //=======================================================================
 365 //function : ChangeBytes
 366 //purpose  : Replace the container content by new content of the <theBytes>.
 367 //=======================================================================
 368 void TDataStd_NamedData::ChangeBytes(const TDataStd_DataMapOfStringByte& theBytes)
 369 {
 370   if(!HasBytes()) {
 371     TDataStd_DataMapOfStringByte aMap;
 372     myBytes = new TDataStd_HDataMapOfStringByte(aMap);
 373   }
 374   if (&myBytes->Map() == &theBytes) return;
 375   Backup();
 376   myBytes->ChangeMap().Assign(theBytes);
 377 }
 378
 379
 380 //Category: Arrays of integers
 381 //          ==================
 382 //=======================================================================
 383 //function : HasArrayOfIntegers
 384 //purpose  : Returns true if the attribute contains this named array
 385 //         : of integer values.
 386 //=======================================================================
 387 Standard_Boolean TDataStd_NamedData::HasArrayOfIntegers
 388                         (const TCollection_ExtendedString& theName) const
 389 {
 390   if(!HasArraysOfIntegers()) return Standard_False;
 391   return myArraysOfIntegers->Map().IsBound(theName);
 392 }
 393
 394 //=======================================================================
 395 //function : GetArrayOfIntegers
 396 //purpose  : Returns the named array of integer values. It returns a NULL
 397 //         : Handle if there is no such a named array of integers
 398 //=======================================================================
 399 const Handle(TColStd_HArray1OfInteger)& TDataStd_NamedData::GetArrayOfIntegers
 400                         (const TCollection_ExtendedString& theName)
 401 {
 402   if(!HasArraysOfIntegers()) {
 403     TDataStd_DataMapOfStringHArray1OfInteger aMap;
 404     myArraysOfIntegers = new TDataStd_HDataMapOfStringHArray1OfInteger(aMap);
 405   }
 406   return myArraysOfIntegers->Map().Find(theName);
 407 }
 408
 409 //=======================================================================
 410 //function : SetArrayOfIntegers
 411 //purpose  : Defines a named array of integer values.
 412 //         : If the array already exists, it changes its value to <theArrayOfIntegers>.
 413 //=======================================================================
 414 void TDataStd_NamedData::SetArrayOfIntegers(const TCollection_ExtendedString& theName,
 415                                             const Handle(TColStd_HArray1OfInteger)& theArrayOfIntegers)
 416 {
 417   if(!HasArraysOfIntegers()) {
 418     TDataStd_DataMapOfStringHArray1OfInteger aMap;
 419     myArraysOfIntegers = new TDataStd_HDataMapOfStringHArray1OfInteger(aMap);
 420   }
 421
 422   Backup();
 423   // Deep copy of the array
 424   Handle(TColStd_HArray1OfInteger) arr;
 425   if (!theArrayOfIntegers.IsNull())
 426   {
 427     Standard_Integer lower = theArrayOfIntegers->Lower(), i = lower, upper = theArrayOfIntegers->Upper();
 428     arr = new TColStd_HArray1OfInteger(lower, upper);
 429     for (; i <= upper; i++)
 430     {
 431       arr->SetValue(i, theArrayOfIntegers->Value(i));
 432     }
 433   }
 434
 435   if (myArraysOfIntegers->Map().IsBound(theName))
 436     myArraysOfIntegers->ChangeMap().ChangeFind(theName) = arr;
 437   else
 438     myArraysOfIntegers->ChangeMap().Bind(theName, arr);
 439 }
 440
 441 //=======================================================================
 442 //function : GetArraysOfIntegersContainer
 443 //purpose  : Returns the internal container of named arrays of integer values.
 444 //=======================================================================
 445 const TDataStd_DataMapOfStringHArray1OfInteger& TDataStd_NamedData::
 446                                      GetArraysOfIntegersContainer()
 447 {
 448   if(!HasArraysOfIntegers()) {
 449     TDataStd_DataMapOfStringHArray1OfInteger aMap;
 450     myArraysOfIntegers = new TDataStd_HDataMapOfStringHArray1OfInteger(aMap);
 451   }
 452   return myArraysOfIntegers->Map();
 453 }
 454
 455 //=======================================================================
 456 //function : ChangeArraysOfIntegers
 457 //purpose  : Replace the container content by new content of the <theIntegers>.
 458 //=======================================================================
 459 void TDataStd_NamedData::ChangeArraysOfIntegers
 460             (const TDataStd_DataMapOfStringHArray1OfInteger& theIntegers)
 461 {
 462   if(!HasArraysOfIntegers()) {
 463     TDataStd_DataMapOfStringHArray1OfInteger aMap;
 464     myArraysOfIntegers = new TDataStd_HDataMapOfStringHArray1OfInteger(aMap);
 465   }
 466   if (&myArraysOfIntegers->Map() == &theIntegers) return;
 467   Backup();
 468   myArraysOfIntegers->ChangeMap().Assign(theIntegers);
 469 }
 470
 471
 472 //Category: Arrays of reals
 473 //          ===============
 474 //=======================================================================
 475 //function : HasArrayOfReals
 476 //purpose  : Returns true if the attribute contains this named array of
 477 //         : real values.
 478 //=======================================================================
 479 Standard_Boolean TDataStd_NamedData::HasArrayOfReals
 480                         (const TCollection_ExtendedString& theName) const
 481 {
 482   if(!HasArraysOfReals()) return Standard_False;
 483   return myArraysOfReals->Map().IsBound(theName);
 484 }
 485
 486 //=======================================================================
 487 //function : GetArrayOfReals
 488 //purpose  : Returns the named array of real values. It returns a NULL
 489 //         : Handle if there is no such a named array of reals.
 490 //=======================================================================
 491 const Handle(TColStd_HArray1OfReal)& TDataStd_NamedData::GetArrayOfReals
 492                         (const TCollection_ExtendedString& theName)
 493 {
 494   if(!HasArraysOfReals()) {
 495     TDataStd_DataMapOfStringHArray1OfReal aMap;
 496     myArraysOfReals = new TDataStd_HDataMapOfStringHArray1OfReal(aMap);
 497   }
 498   return myArraysOfReals->Map().Find(theName);
 499 }
 500
 501 //=======================================================================
 502 //function : SetArrayOfReals
 503 //purpose  : Defines a named array of real values.
 504 //         : If the array already exists, it changes its value to <theArrayOfReals>.
 505 //=======================================================================
 506 void TDataStd_NamedData::SetArrayOfReals(const TCollection_ExtendedString& theName,
 507                                          const Handle(TColStd_HArray1OfReal)& theArrayOfReals)
 508 {
 509   if(!HasArraysOfReals()) {
 510     TDataStd_DataMapOfStringHArray1OfReal aMap;
 511     myArraysOfReals = new TDataStd_HDataMapOfStringHArray1OfReal(aMap);
 512   }
 513   Backup();
 514
 515   // Deep copy of the array
 516   Handle(TColStd_HArray1OfReal) arr;
 517   if (!theArrayOfReals.IsNull())
 518   {
 519     Standard_Integer lower = theArrayOfReals->Lower(), i = lower, upper = theArrayOfReals->Upper();
 520     arr = new TColStd_HArray1OfReal(lower, upper);
 521     for (; i <= upper; i++)
 522     {
 523       arr->SetValue(i, theArrayOfReals->Value(i));
 524     }
 525   }
 526
 527   if (myArraysOfReals->Map().IsBound(theName))
 528     myArraysOfReals->ChangeMap().ChangeFind(theName) = arr;
 529   else
 530     myArraysOfReals->ChangeMap().Bind(theName, arr);
 531 }
 532
 533 //=======================================================================
 534 //function : GetArraysOfRealsContainer
 535 //purpose  : Returns the internal container of named arrays of real values.
 536 //=======================================================================
 537 const TDataStd_DataMapOfStringHArray1OfReal& TDataStd_NamedData::
 538                                         GetArraysOfRealsContainer()
 539 {
 540   if(!HasArraysOfReals()) {
 541     TDataStd_DataMapOfStringHArray1OfReal aMap;
 542     myArraysOfReals = new TDataStd_HDataMapOfStringHArray1OfReal(aMap);
 543   }
 544   return myArraysOfReals->Map();
 545 }
 546
 547 //=======================================================================
 548 //function : ChangeArraysOfReals
 549 //purpose  : Replace the container content by new content of the <theReals>.
 550 //=======================================================================
 551 void TDataStd_NamedData::ChangeArraysOfReals
 552                    (const TDataStd_DataMapOfStringHArray1OfReal& theReals)
 553 {
 554   if(!HasArraysOfReals()) {
 555     TDataStd_DataMapOfStringHArray1OfReal aMap;
 556     myArraysOfReals = new TDataStd_HDataMapOfStringHArray1OfReal(aMap);
 557   }
 558   if (&myArraysOfReals->Map() == &theReals) return;
 559   Backup();
 560   myArraysOfReals->ChangeMap().Assign(theReals);
 561 }
 562
 563 //=======================================================================
 564 //function : ID
 565 //purpose  :
 566 //=======================================================================
 567 const Standard_GUID& TDataStd_NamedData::ID () const
 568 {
 569   return GetID();
 570 }
 571
 572 //=======================================================================
 573 //function : NewEmpty
 574 //purpose  :
 575 //=======================================================================
 576 Handle(TDF_Attribute) TDataStd_NamedData::NewEmpty () const
 577 {
 578   return new TDataStd_NamedData();
 579 }
 580
 581 //=======================================================================
 582 //function : Restore
 583 //purpose  :
 584 //=======================================================================
 585 void TDataStd_NamedData::Restore(const Handle(TDF_Attribute)& With)
 586 {
 587
 588   Handle(TDataStd_NamedData) ND = Handle(TDataStd_NamedData)::DownCast(With);
 589   if(ND.IsNull()) return;
 590   // Integers
 591   if (!ND->GetIntegersContainer().IsEmpty())
 592   {
 593     if(!HasIntegers()) {
 594       TColStd_DataMapOfStringInteger aMap;
 595       myIntegers = new TDataStd_HDataMapOfStringInteger(aMap);
 596     }
 597     myIntegers->ChangeMap().Assign(ND->GetIntegersContainer());
 598   }
 599
 600   // Reals
 601   if (!ND->GetRealsContainer().IsEmpty())
 602   {
 603     if(!HasReals()) {
 604       TDataStd_DataMapOfStringReal aMap;
 605       myReals = new TDataStd_HDataMapOfStringReal(aMap);
 606     }
 607     myReals->ChangeMap().Assign(ND->GetRealsContainer());
 608
 609   }
 610
 611   // Strings
 612   if (!ND->GetStringsContainer().IsEmpty())
 613   {
 614     if(!HasStrings()) {
 615       TDataStd_DataMapOfStringString aMap;
 616       myStrings = new TDataStd_HDataMapOfStringString(aMap);
 617     }
 618     myStrings->ChangeMap().Assign(ND->GetStringsContainer());
 619
 620   }
 621
 622   // Bytes
 623   if (!ND->GetBytesContainer().IsEmpty())
 624   {
 625     if(!HasBytes()) {
 626       TDataStd_DataMapOfStringByte aMap;
 627       myBytes = new TDataStd_HDataMapOfStringByte(aMap);
 628     }
 629     myBytes->ChangeMap().Assign(ND->GetBytesContainer());
 630
 631   }
 632
 633   // Arrays of integers
 634   if (!ND->GetArraysOfIntegersContainer().IsEmpty())
 635   {
 636     if(!HasArraysOfIntegers()) {
 637       TDataStd_DataMapOfStringHArray1OfInteger aMap;
 638       myArraysOfIntegers = new TDataStd_HDataMapOfStringHArray1OfInteger(aMap);
 639     }
 640     TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger itr(ND->GetArraysOfIntegersContainer());
 641     for (; itr.More(); itr.Next())
 642     {
 643       // Deep copy of the arrays
 644       const Handle(TColStd_HArray1OfInteger)& ints = itr.Value();
 645       Handle(TColStd_HArray1OfInteger) copied_ints;
 646       if (!ints.IsNull())
 647       {
 648         Standard_Integer lower = ints->Lower(), i = lower, upper = ints->Upper();
 649         copied_ints = new TColStd_HArray1OfInteger(lower, upper);
 650         for (; i <= upper; i++)
 651         {
 652           copied_ints->SetValue(i, ints->Value(i));
 653         }
 654       }
 655       myArraysOfIntegers->ChangeMap().Bind(itr.Key(), copied_ints);
 656     }
 657   }
 658
 659   // Arrays of realss
 660   if (!ND->GetArraysOfRealsContainer().IsEmpty())
 661   {
 662     if(!HasArraysOfReals()) {
 663       TDataStd_DataMapOfStringHArray1OfReal aMap;
 664       myArraysOfReals = new TDataStd_HDataMapOfStringHArray1OfReal(aMap);
 665     }
 666     TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal itr(ND->GetArraysOfRealsContainer());
 667     for (; itr.More(); itr.Next())
 668     {
 669       // Deep copy of the arrays
 670       const Handle(TColStd_HArray1OfReal)& dbls = itr.Value();
 671       Handle(TColStd_HArray1OfReal) copied_dbls;
 672       if (!dbls.IsNull())
 673       {
 674         Standard_Integer lower = dbls->Lower(), i = lower, upper = dbls->Upper();
 675         copied_dbls = new TColStd_HArray1OfReal(lower, upper);
 676         for (; i <= upper; i++)
 677         {
 678           copied_dbls->SetValue(i, dbls->Value(i));
 679         }
 680       }
 681       myArraysOfReals->ChangeMap().Bind(itr.Key(), copied_dbls);
 682     }
 683   }
 684 }
 685
 686 //=======================================================================
 687 //function : Paste
 688 //purpose  :
 689 //=======================================================================
 690 void TDataStd_NamedData::Paste (const Handle(TDF_Attribute)& Into,
 691                                   const Handle(TDF_RelocationTable)& ) const
 692 {
 693   Handle(TDataStd_NamedData) ND = Handle(TDataStd_NamedData)::DownCast(Into);
 694   if (ND.IsNull()) return;
 695
 696   // Integers
 697   if (HasIntegers() && !myIntegers->Map().IsEmpty())
 698   {
 699     if(!ND->HasIntegers()) {
 700       TColStd_DataMapOfStringInteger aMap;
 701       ND->myIntegers = new TDataStd_HDataMapOfStringInteger(aMap);
 702     };
 703     ND->myIntegers->ChangeMap().Assign(myIntegers->Map());
 704   }
 705
 706   // Reals
 707   if (HasReals() && !myReals->Map().IsEmpty())
 708   {
 709     if(!ND->HasReals()) {
 710       TDataStd_DataMapOfStringReal aMap;
 711       ND->myReals = new TDataStd_HDataMapOfStringReal(aMap);
 712     };
 713     ND->myReals->ChangeMap().Assign(myReals->Map());
 714
 715   }
 716
 717   // Strings
 718   if (HasStrings() && !myStrings->Map().IsEmpty())
 719   {
 720     if(!ND->HasStrings()) {
 721       TDataStd_DataMapOfStringString aMap;
 722       ND->myStrings = new TDataStd_HDataMapOfStringString(aMap);
 723     };
 724     ND->myStrings->ChangeMap().Assign(myStrings->Map());
 725   }
 726
 727   // Bytes
 728   if (HasBytes() && !myBytes->Map().IsEmpty())
 729   {
 730     if(!ND->HasBytes()) {
 731       TDataStd_DataMapOfStringByte aMap;
 732       ND->myBytes = new TDataStd_HDataMapOfStringByte(aMap);
 733     };
 734     ND->myBytes->ChangeMap().Assign(myBytes->Map());
 735   }
 736
 737   // Arrays of integers
 738   if (HasArraysOfIntegers() && !myArraysOfIntegers->Map().IsEmpty())
 739   {
 740     if(!ND->HasArraysOfIntegers()) {
 741       TDataStd_DataMapOfStringHArray1OfInteger aMap;
 742       ND->myArraysOfIntegers = new TDataStd_HDataMapOfStringHArray1OfInteger(aMap);
 743     }
 744
 745     TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger itr(myArraysOfIntegers->Map());
 746     for (; itr.More(); itr.Next())
 747     {
 748       const Handle(TColStd_HArray1OfInteger)& ints = itr.Value();
 749       Handle(TColStd_HArray1OfInteger) copied_ints;
 750       if (!ints.IsNull())
 751       {
 752         Standard_Integer lower = ints->Lower(), i = lower, upper = ints->Upper();
 753         copied_ints = new TColStd_HArray1OfInteger(lower, upper);
 754         for (; i <= upper; i++)
 755         {
 756           copied_ints->SetValue(i, ints->Value(i));
 757         }
 758       }
 759       ND->myArraysOfIntegers->ChangeMap().Bind(itr.Key(), copied_ints);
 760     }
 761   }
 762
 763   // Arrays of reals
 764   if (HasArraysOfReals() && !myArraysOfReals->Map().IsEmpty())
 765   {
 766     if(!ND->HasArraysOfReals()) {
 767       TDataStd_DataMapOfStringHArray1OfReal aMap;
 768       ND->myArraysOfReals = new TDataStd_HDataMapOfStringHArray1OfReal(aMap);
 769     }
 770     TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal itr(myArraysOfReals->Map());
 771     for (; itr.More(); itr.Next())
 772     {
 773       const Handle(TColStd_HArray1OfReal)& dbls = itr.Value();
 774       Handle(TColStd_HArray1OfReal) copied_dbls;
 775       if (!dbls.IsNull())
 776       {
 777         Standard_Integer lower = dbls->Lower(), i = lower, upper = dbls->Upper();
 778         copied_dbls = new TColStd_HArray1OfReal(lower, upper);
 779         for (; i <= upper; i++)
 780         {
 781           copied_dbls->SetValue(i, dbls->Value(i));
 782         }
 783       }
 784       ND->myArraysOfReals->ChangeMap().Bind(itr.Key(), copied_dbls);
 785     }
 786   }
 787 }
 788
 789 //=======================================================================
 790 //function : Dump
 791 //purpose  :
 792 //=======================================================================
 793 Standard_OStream& TDataStd_NamedData::Dump (Standard_OStream& anOS) const
 794 {
 795   anOS << "NamedData: ";
 796   anOS << "\tIntegers = " << HasIntegers() ? myIntegers->Map().Extent() : 0;
 797   anOS << "\tReals = " << HasReals() ? myReals->Map().Extent() : 0;
 798   anOS << "\tStrings = " << HasStrings() ? myStrings->Map().Extent() : 0;
 799   anOS << "\tBytes = " << HasBytes() ? myBytes->Map().Extent() : 0;
 800   anOS << "\tArraysOfIntegers = " << HasArraysOfIntegers() ? myArraysOfIntegers->Map().Extent() : 0;
 801   anOS << "\tArraysOfReals = " << HasArraysOfReals() ? myArraysOfReals->Map().Extent() : 0;
 802   return anOS;
 803 }