|
GME
13
|
00001 //############################################################################################################################################### 00002 // 00003 // Object Constraint Language Generic Manager 00004 // OCLObjectExBasic.cpp 00005 // 00006 //############################################################################################################################################### 00007 #include "StdAfx.h" 00008 #include "Solve4786.h" 00009 #include "OCLObjectExBasic.h" 00010 #include "OCLType.h" 00011 #include <algorithm> 00012 00013 namespace OclBasic 00014 { 00015 00016 //############################################################################################################################################## 00017 // 00018 // F U N C T I O N S 00019 // 00020 //############################################################################################################################################## 00021 00022 std::string PrintCollection( const std::string& strTypeName, const OclMeta::ObjectVector& vecElements ) 00023 { 00024 CString chBuffer; 00025 chBuffer.Format( _T("%lu"), vecElements.size() ); 00026 return strTypeName + " { size: " + std::string( CStringA(chBuffer) ) + "; } "; 00027 /* 00028 std::string strObject = strTypeName + " { " + std::string( chBuffer ) + " , [ "; 00029 for ( int i = 0 ; i < vecElements.size() ; i++ ) { 00030 strObject = vecElements[ i ].Print(); 00031 if ( i != vecElements.size() - 1 ) 00032 strObject += ", "; 00033 } 00034 return strObject + " ] }"; 00035 */ 00036 00037 } 00038 00039 int GetObjectCountInVector( OclMeta::ObjectVector& vecObjects, OclMeta::Object& object ) 00040 { 00041 int i = 0; 00042 OclMeta::ObjectVector::iterator j = std::find( vecObjects.begin(), vecObjects.end(), object ); 00043 while ( j != vecObjects.end() ) { 00044 i++; 00045 vecObjects.erase( j ); 00046 j = std::find( vecObjects.begin(), vecObjects.end(), object ); 00047 } 00048 return i; 00049 } 00050 00051 //############################################################################################################################################## 00052 // 00053 // C L A S S : OclBasic::String <<< + OclBasic::Any 00054 // 00055 //############################################################################################################################################## 00056 00057 String::String( OclMeta::TypeManager* pManager, const std::string& strTypeName, const std::string& value ) 00058 : Any( pManager, strTypeName ), m_Value( value ) 00059 { 00060 } 00061 00062 00063 String::String( OclMeta::TypeManager* pManager, const std::string& value ) 00064 : Any( pManager, "ocl::String" ), m_Value( value ) 00065 { 00066 } 00067 00068 void String::GetValue( std::string& value ) const 00069 { 00070 value = m_Value; 00071 } 00072 00073 void String::SetValue( const std::string& value ) 00074 { 00075 m_Value = value; 00076 } 00077 00078 Any* String::Clone() const 00079 { 00080 return new String( GetTypeManager(), m_Value ); 00081 } 00082 00083 bool String::Equals( const Any& object ) const 00084 { 00085 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::String" ) >= 0 ) 00086 return m_Value == ( ( String* ) &object )->m_Value; 00087 else 00088 return false; 00089 } 00090 00091 bool String::operator==( const String& object ) const 00092 { 00093 return Equals( object ); 00094 } 00095 00096 bool String::operator!=( const String& object ) const 00097 { 00098 return ! ( *this == object ); 00099 } 00100 00101 std::string String::Print() const 00102 { 00103 return "ocl::String { \"" + m_Value + "\" }"; 00104 } 00105 00106 //############################################################################################################################################## 00107 // 00108 // C L A S S : OclBasic::Enumeration <<< + OclBasic::Any 00109 // 00110 //############################################################################################################################################## 00111 00112 Enumeration::Enumeration( OclMeta::TypeManager* pManager, const std::string& strTypeName, const std::string& value ) 00113 : Any( pManager, strTypeName ), m_Value( value ) 00114 { 00115 } 00116 00117 Enumeration::Enumeration( OclMeta::TypeManager* pManager, const std::string& value ) 00118 : Any( pManager, "ocl::Enumeration" ), m_Value( value ) 00119 { 00120 } 00121 00122 void Enumeration::GetValue( std::string& value ) const 00123 { 00124 value = m_Value; 00125 } 00126 00127 void Enumeration::SetValue( const std::string& value ) 00128 { 00129 m_Value = value; 00130 } 00131 00132 Any* Enumeration::Clone() const 00133 { 00134 return new Enumeration( GetTypeManager(), m_Value ); 00135 } 00136 00137 bool Enumeration::Equals( const Any& object ) const 00138 { 00139 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::Enumeration" ) >= 0 ) 00140 return m_Value == ( ( Enumeration* ) &object )->m_Value; 00141 else 00142 return false; 00143 } 00144 00145 bool Enumeration::operator==( const Enumeration& object ) const 00146 { 00147 return Equals( object ); 00148 } 00149 00150 bool Enumeration::operator!=( const Enumeration& object ) const 00151 { 00152 return ! ( *this == object ); 00153 } 00154 00155 std::string Enumeration::Print() const 00156 { 00157 return "ocl::Enumeration { #" + m_Value + " }"; 00158 } 00159 00160 //############################################################################################################################################## 00161 // 00162 // C L A S S : OclBasic::Boolean <<< + OclBasic::Any 00163 // 00164 //############################################################################################################################################## 00165 00166 Boolean::Boolean( OclMeta::TypeManager* pManager, const std::string& strTypeName, bool value ) 00167 : Any( pManager, strTypeName ), m_Value( value ) 00168 { 00169 } 00170 00171 Boolean::Boolean( OclMeta::TypeManager* pManager, bool value ) 00172 : Any( pManager, "ocl::Boolean" ), m_Value( value ) 00173 { 00174 } 00175 00176 void Boolean::GetValue( bool& value ) const 00177 { 00178 value = m_Value; 00179 } 00180 00181 void Boolean::SetValue( bool value ) 00182 { 00183 m_Value = value; 00184 } 00185 00186 Any* Boolean::Clone() const 00187 { 00188 return new Boolean( GetTypeManager(), m_Value ); 00189 } 00190 00191 bool Boolean::Equals( const Any& object ) const 00192 { 00193 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::Boolean" ) >= 0 ) 00194 return m_Value == ( ( Boolean* ) &object )->m_Value; 00195 else 00196 return false; 00197 } 00198 00199 bool Boolean::operator==( const Boolean& object ) const 00200 { 00201 return Equals( object ); 00202 } 00203 00204 bool Boolean::operator!=( const Boolean& object ) const 00205 { 00206 return ! ( *this == object ); 00207 } 00208 00209 std::string Boolean::Print() const 00210 { 00211 return ( m_Value ) ? "ocl::Boolean { true }" : "ocl::Boolean { false }"; 00212 } 00213 00214 //############################################################################################################################################## 00215 // 00216 // C L A S S : OclBasic::Real <<< + OclBasic::Any 00217 // 00218 //############################################################################################################################################## 00219 00220 Real::Real( OclMeta::TypeManager* pManager, const std::string& strTypeName, double value ) 00221 : Any( pManager, strTypeName ), m_Value( value ) 00222 { 00223 } 00224 00225 Real::Real( OclMeta::TypeManager* pManager, double value ) 00226 : Any( pManager, "ocl::Real" ), m_Value( value ) 00227 { 00228 } 00229 00230 void Real::GetValue( double& value ) const 00231 { 00232 value = m_Value; 00233 } 00234 00235 void Real::SetValue( double value ) 00236 { 00237 m_Value = value; 00238 } 00239 00240 Any* Real::Clone() const 00241 { 00242 return new Real( GetTypeManager(), m_Value ); 00243 } 00244 00245 bool Real::Equals( const Any& object ) const 00246 { 00247 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::Real" ) >= 0 ) { 00248 double v = ( ( Real* ) &object )->m_Value; 00249 return m_Value == v; 00250 } 00251 else 00252 return false; 00253 } 00254 00255 bool Real::operator==( const Real& object ) const 00256 { 00257 return Equals( object ); 00258 } 00259 00260 bool Real::operator!=( const Real& object ) const 00261 { 00262 return ! ( *this == object ); 00263 } 00264 00265 std::string Real::Print() const 00266 { 00267 char chBuffer[ 100 ]; 00268 sprintf_s( chBuffer, "%lf", m_Value ); 00269 return "ocl::Real { " + std::string( chBuffer ) + " }"; 00270 } 00271 00272 //############################################################################################################################################## 00273 // 00274 // C L A S S : OclBasic::Integer <<< + OclBasic::Real 00275 // 00276 //############################################################################################################################################## 00277 00278 Integer::Integer( OclMeta::TypeManager* pManager, const std::string& strTypeName, long value ) 00279 : Real( pManager, strTypeName, (double) value ) 00280 { 00281 } 00282 00283 Integer::Integer( OclMeta::TypeManager* pManager, long value ) 00284 : Real( pManager, "ocl::Integer", (double) value ) 00285 { 00286 } 00287 00288 void Integer::GetValue( long& value ) const 00289 { 00290 double dValue; 00291 Real::GetValue( dValue ); 00292 value = (long) dValue; 00293 } 00294 00295 void Integer::SetValue( long value ) 00296 { 00297 Real::SetValue( (double) value ); 00298 } 00299 00300 Any* Integer::Clone() const 00301 { 00302 long lValue; 00303 GetValue( lValue ); 00304 return new Integer( GetTypeManager(), lValue ); 00305 } 00306 00307 bool Integer::operator==( const Integer& object ) const 00308 { 00309 return Real::operator==( object ); 00310 } 00311 00312 bool Integer::operator!=( const Integer& object ) const 00313 { 00314 return ! ( *this == object ); 00315 } 00316 00317 std::string Integer::Print() const 00318 { 00319 double lValue; 00320 Real::GetValue( lValue ); 00321 char chBuffer[ 100 ]; 00322 sprintf_s( chBuffer, "%ld", (long) lValue ); 00323 return "ocl::Integer { " + std::string( chBuffer ) + " }"; 00324 } 00325 00326 //############################################################################################################################################## 00327 // 00328 // C L A S S : OclBasic::Type <<< + OclBasic::Any 00329 // 00330 //############################################################################################################################################## 00331 00332 Type::Type( OclMeta::TypeManager* pManager, const std::string& strTypeName, const std::string& value ) 00333 : Any( pManager, strTypeName ), m_Value( value ) 00334 { 00335 } 00336 00337 00338 Type::Type( OclMeta::TypeManager* pManager, const std::string& value ) 00339 : Any( pManager, "ocl::Type" ), m_Value( value ) 00340 { 00341 } 00342 00343 void Type::GetValue( std::string& value ) const 00344 { 00345 value = m_Value; 00346 } 00347 00348 void Type::SetValue( const std::string& value ) 00349 { 00350 m_Value = value; 00351 } 00352 00353 Any* Type::Clone() const 00354 { 00355 return new Type( GetTypeManager(), m_Value ); 00356 } 00357 00358 bool Type::Equals( const Any& object ) const 00359 { 00360 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::Type" ) >= 0 ) 00361 return m_Value == ( ( Type* ) &object )->m_Value; 00362 else 00363 return false; 00364 } 00365 00366 bool Type::operator==( const Type& object ) const 00367 { 00368 return Equals( object ); 00369 } 00370 00371 bool Type::operator!=( const Type& object ) const 00372 { 00373 return ! ( *this == object ); 00374 } 00375 00376 std::string Type::Print() const 00377 { 00378 return "ocl::Type { \"" + m_Value + "\" }"; 00379 } 00380 00381 //############################################################################################################################################## 00382 // 00383 // C L A S S : OclBasic::ObjectIterator <<< + OclImplementation::ObjectIterator 00384 // 00385 //============================================================================================================================================== 00386 // 00387 // D E S C R I P T I O N : 00388 // 00389 //############################################################################################################################################## 00390 00391 class ObjectIterator 00392 : public OclImplementation::ObjectIterator 00393 { 00394 private : 00395 OclMeta::ObjectVector::iterator m_iteratorPos; 00396 OclMeta::ObjectVector::iterator m_iteratorEnd; 00397 00398 public : 00399 ObjectIterator( OclMeta::ObjectVector::iterator iteratorBegin, OclMeta::ObjectVector::iterator iteratorEnd ) 00400 : OclImplementation::ObjectIterator(), m_iteratorPos( iteratorBegin ), m_iteratorEnd( iteratorEnd ) 00401 { 00402 } 00403 00404 virtual ~ObjectIterator() 00405 { 00406 } 00407 00408 virtual bool HasNext() 00409 { 00410 return m_iteratorPos != m_iteratorEnd; 00411 } 00412 00413 virtual OclMeta::Object GetNext() 00414 { 00415 return *( m_iteratorPos++ ); 00416 } 00417 }; 00418 00419 //############################################################################################################################################## 00420 // 00421 // C L A S S : OclBasic::Set <<< + OclBasic::Collection 00422 // 00423 //############################################################################################################################################## 00424 00425 Set::Set( OclMeta::TypeManager* pManager, const std::string& strTypeName ) 00426 : Collection( pManager, strTypeName ) 00427 { 00428 } 00429 00430 Set::Set( OclMeta::TypeManager* pManager, const std::string& strTypeName, const OclMeta::ObjectVector& vecObjects ) 00431 : Collection( pManager, strTypeName ) 00432 { 00433 for ( unsigned int i = 0 ; i < vecObjects.size() ; i++ ) 00434 AddObject( vecObjects[ i ] ); 00435 } 00436 00437 Set::Set( OclMeta::TypeManager* pManager ) 00438 : Collection( pManager, "ocl::Set" ) 00439 { 00440 } 00441 00442 Set::Set( OclMeta::TypeManager* pManager, const OclMeta::ObjectVector& vecObjects ) 00443 : Collection( pManager, "ocl::Set" ) 00444 { 00445 for ( unsigned int i = 0 ; i < vecObjects.size() ; i++ ) 00446 AddObject( vecObjects[ i ] ); 00447 } 00448 00449 Any* Set::Clone() const 00450 { 00451 return new Set( GetTypeManager(), m_vecObjects ); 00452 } 00453 00454 void Set::GetValue( OclMeta::ObjectVector& value ) const 00455 { 00456 value = m_vecObjects; 00457 } 00458 00459 void Set::SetValue( const OclMeta::ObjectVector& value ) 00460 { 00461 for ( unsigned int i = 0 ; i < value.size() ; i++ ) 00462 AddObject( value[ i ] ); 00463 } 00464 00465 bool Set::Equals( const Any& object ) const 00466 { 00467 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::Set" ) >= 0 ) { 00468 OclMeta::ObjectVector vecObjects = ( ( Set* ) &object )->m_vecObjects; 00469 if ( m_vecObjects.size() != vecObjects.size() ) 00470 return false; 00471 for ( unsigned int i = 0 ; i < m_vecObjects.size() ; i++ ) 00472 if ( std::find( vecObjects.begin(), vecObjects.end(), m_vecObjects[ i ] ) == vecObjects.end() ) 00473 return false; 00474 return true; 00475 } 00476 else 00477 return false; 00478 } 00479 00480 bool Set::operator==( const Set& object ) const 00481 { 00482 return Equals( object ); 00483 } 00484 00485 bool Set::operator!=( const Set& object ) const 00486 { 00487 return ! ( *this == object ); 00488 } 00489 00490 void Set::AddObject( const OclMeta::Object& object ) 00491 { 00492 OclMeta::ObjectVector::iterator i = std::find( m_vecObjects.begin(), m_vecObjects.end(), object ); 00493 if ( i == m_vecObjects.end() ) 00494 m_vecObjects.push_back( object ); 00495 } 00496 00497 OclImplementation::ObjectIterator* Set::GetIterator() 00498 { 00499 return new ObjectIterator( m_vecObjects.begin(), m_vecObjects.end() ); 00500 } 00501 00502 std::string Set::Print() const 00503 { 00504 return PrintCollection( GetTypeName(), m_vecObjects ); 00505 } 00506 00507 //############################################################################################################################################## 00508 // 00509 // C L A S S : OclBasic::Bag <<< + OclBasic::Collection 00510 // 00511 //############################################################################################################################################## 00512 00513 Bag::Bag( OclMeta::TypeManager* pManager, const std::string& strTypeName ) 00514 : Collection( pManager, strTypeName ) 00515 { 00516 } 00517 00518 Bag::Bag( OclMeta::TypeManager* pManager, const std::string& strTypeName, const OclMeta::ObjectVector& vecObjects ) 00519 : Collection( pManager, strTypeName ) 00520 { 00521 m_vecObjects = vecObjects; 00522 } 00523 00524 Bag::Bag( OclMeta::TypeManager* pManager ) 00525 : Collection( pManager, "ocl::Bag" ) 00526 { 00527 } 00528 00529 Bag::Bag( OclMeta::TypeManager* pManager, const OclMeta::ObjectVector& vecObjects ) 00530 : Collection( pManager, "ocl::Bag" ) 00531 { 00532 m_vecObjects = vecObjects; 00533 } 00534 00535 Any* Bag::Clone() const 00536 { 00537 return new Bag( GetTypeManager(), m_vecObjects ); 00538 } 00539 00540 void Bag::GetValue( OclMeta::ObjectVector& value ) const 00541 { 00542 value = m_vecObjects; 00543 } 00544 00545 void Bag::SetValue( const OclMeta::ObjectVector& value ) 00546 { 00547 m_vecObjects = value; 00548 } 00549 00550 bool Bag::Equals( const Any& object ) const 00551 { 00552 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::Bag" ) >= 0 ) { 00553 OclMeta::ObjectVector vecObjects2 = ( ( Bag* ) &object )->m_vecObjects; 00554 if ( m_vecObjects.size() != vecObjects2.size() ) 00555 return false; 00556 00557 OclMeta::ObjectVector vecObjects1 = m_vecObjects; 00558 00559 OclMeta::ObjectVector::iterator i = vecObjects1.begin(); 00560 while ( i != vecObjects1.end() ) { 00561 OclMeta::Object o = *i; 00562 vecObjects1.erase( i ); 00563 if ( GetObjectCountInVector( vecObjects1, o ) + 1 != GetObjectCountInVector( vecObjects2, o ) ) 00564 return false; 00565 i = vecObjects1.begin(); 00566 } 00567 return true; 00568 } 00569 else 00570 return false; 00571 } 00572 00573 bool Bag::operator==( const Bag& object ) const 00574 { 00575 return Equals( object ); 00576 } 00577 00578 bool Bag::operator!=( const Bag& object ) const 00579 { 00580 return ! ( *this == object ); 00581 } 00582 00583 void Bag::AddObject( const OclMeta::Object& object ) 00584 { 00585 m_vecObjects.push_back( object ); 00586 } 00587 00588 OclImplementation::ObjectIterator* Bag::GetIterator() 00589 { 00590 return new ObjectIterator( m_vecObjects.begin(), m_vecObjects.end() ); 00591 } 00592 00593 std::string Bag::Print() const 00594 { 00595 return PrintCollection( GetTypeName(), m_vecObjects ); 00596 } 00597 00598 //############################################################################################################################################## 00599 // 00600 // C L A S S : OclBasic::Sequence <<< + OclBasic::Collection 00601 // 00602 //############################################################################################################################################## 00603 00604 Sequence::Sequence( OclMeta::TypeManager* pManager, const std::string& strTypeName ) 00605 : Collection( pManager, strTypeName ) 00606 { 00607 } 00608 00609 Sequence::Sequence( OclMeta::TypeManager* pManager, const std::string& strTypeName, const OclMeta::ObjectVector& vecObjects ) 00610 : Collection( pManager, strTypeName ) 00611 { 00612 m_vecObjects = vecObjects; 00613 } 00614 00615 Sequence::Sequence( OclMeta::TypeManager* pManager ) 00616 : Collection( pManager, "ocl::Sequence" ) 00617 { 00618 } 00619 00620 Sequence::Sequence( OclMeta::TypeManager* pManager, const OclMeta::ObjectVector& vecObjects ) 00621 : Collection( pManager, "ocl::Sequence" ) 00622 { 00623 m_vecObjects = vecObjects; 00624 } 00625 00626 Any* Sequence::Clone() const 00627 { 00628 return new Sequence( GetTypeManager(), m_vecObjects ); 00629 } 00630 00631 void Sequence::GetValue( OclMeta::ObjectVector& value ) const 00632 { 00633 value = m_vecObjects; 00634 } 00635 00636 void Sequence::SetValue( const OclMeta::ObjectVector& value ) 00637 { 00638 m_vecObjects = value; 00639 } 00640 00641 bool Sequence::Equals( const Any& object ) const 00642 { 00643 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::Sequence" ) >= 0 ) 00644 return m_vecObjects == ( ( Sequence* ) &object )->m_vecObjects; 00645 else 00646 return false; 00647 } 00648 00649 bool Sequence::operator==( const Sequence& object ) const 00650 { 00651 return Equals( object ); 00652 } 00653 00654 bool Sequence::operator!=( const Sequence& object ) const 00655 { 00656 return ! ( *this == object ); 00657 } 00658 00659 void Sequence::AddObject( const OclMeta::Object& object ) 00660 { 00661 m_vecObjects.push_back( object ); 00662 } 00663 00664 OclImplementation::ObjectIterator* Sequence::GetIterator() 00665 { 00666 return new ObjectIterator( m_vecObjects.begin(), m_vecObjects.end() ); 00667 } 00668 00669 std::string Sequence::Print() const 00670 { 00671 return PrintCollection( GetTypeName(), m_vecObjects ); 00672 } 00673 00674 //############################################################################################################################################## 00675 // 00676 // C L A S S : OclBasic::OrderedSet <<< + OclBasic::Collection 00677 // 00678 //############################################################################################################################################## 00679 00680 OrderedSet::OrderedSet( OclMeta::TypeManager* pManager, const std::string& strTypeName ) 00681 : Set( pManager, strTypeName ) 00682 { 00683 m_pArgNode = NULL; 00684 } 00685 00686 OrderedSet::OrderedSet( OclMeta::TypeManager* pManager, const std::string& strTypeName, const OclMeta::ObjectVector& vecObjects ) 00687 : Set( pManager, strTypeName ) 00688 { 00689 for ( unsigned int i = 0 ; i < vecObjects.size() ; i++ ) 00690 AddObject( vecObjects[ i ] ); 00691 m_pArgNode = NULL; 00692 } 00693 00694 OrderedSet::OrderedSet( OclMeta::TypeManager* pManager ) 00695 : Set( pManager, "ocl::OrderedSet" ) 00696 { 00697 m_pArgNode = NULL; 00698 } 00699 00700 OrderedSet::OrderedSet( OclMeta::TypeManager* pManager, const OclMeta::ObjectVector& vecObjects ) 00701 : Set( pManager, "ocl::OrderedSet" ) 00702 { 00703 for ( unsigned int i = 0 ; i < vecObjects.size() ; i++ ) 00704 AddObject( vecObjects[ i ] ); 00705 m_pArgNode = NULL; 00706 } 00707 00708 Any* OrderedSet::Clone() const 00709 { 00710 return new OrderedSet( GetTypeManager(), m_vecObjects ); 00711 } 00712 00713 void OrderedSet::GetValue( OclMeta::ObjectVector& value ) const 00714 { 00715 value = m_vecObjects; 00716 } 00717 00718 void OrderedSet::SetValue( const OclMeta::ObjectVector& value ) 00719 { 00720 for ( unsigned int i = 0 ; i < value.size() ; i++ ) 00721 AddObject( value[ i ] ); 00722 } 00723 00724 bool OrderedSet::Equals( const Any& object ) const 00725 { 00726 if ( GetTypeManager()->IsTypeA( object.GetTypeName(), "ocl::OrderedSet" ) >= 0 ) { 00727 OclMeta::ObjectVector vecObjects = ( ( OrderedSet* ) &object )->m_vecObjects; 00728 if ( m_vecObjects.size() != vecObjects.size() ) 00729 return false; 00730 for ( unsigned int i = 0 ; i < m_vecObjects.size() ; i++ ) 00731 { 00732 if ( m_vecObjects[ i ] != vecObjects[ i ] ) 00733 return false; 00734 } 00735 return true; 00736 } 00737 else 00738 return false; 00739 } 00740 00741 bool OrderedSet::operator==( const OrderedSet& object ) const 00742 { 00743 return Equals( object ); 00744 } 00745 00746 bool OrderedSet::operator!=( const OrderedSet& object ) const 00747 { 00748 return ! ( *this == object ); 00749 } 00750 00751 void OrderedSet::AddObject( const OclMeta::Object& object ) 00752 { 00753 OclMeta::ObjectVector::iterator i = std::find( m_vecObjects.begin(), m_vecObjects.end(), object ); 00754 if ( i == m_vecObjects.end() ) 00755 m_vecObjects.push_back( object ); 00756 } 00757 00758 OclImplementation::ObjectIterator* OrderedSet::GetIterator() 00759 { 00760 return new ObjectIterator( m_vecObjects.begin(), m_vecObjects.end() ); 00761 } 00762 00763 std::string OrderedSet::Print() const 00764 { 00765 return PrintCollection( GetTypeName(), m_vecObjects ); 00766 } 00767 00768 }; // namespace OclBasic
1.7.6.1