[Corelinux-clcvs] CVS: clfw/src/libs/LibLoad Library.cpp,1.2,1.3

[Frank V. C. <fr...@us...>]

Update of /cvsroot/corelinux/clfw/src/libs/LibLoad
In directory slayer.i.sourceforge.net:/tmp/cvs-serv9356/src/libs/LibLoad

Modified Files:
	Library.cpp 
Log Message:
122619 Fatten MetaClass interface

Index: Library.cpp
===================================================================
RCS file: /cvsroot/corelinux/clfw/src/libs/LibLoad/Library.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -r1.2 -r1.3
*** Library.cpp	2000/08/31 02:18:51	1.2
--- Library.cpp	2000/11/17 13:07:09	1.3
***************
*** 22,34 ****
  
  #if   !defined(__CLFWCOMMON_HPP)
! #include <ClfwCommon.hpp>
  #endif
  
  #if   !defined(__LIBRARY_HPP)
  #include INCL_Library
  #endif
  
  namespace corelinux
  {
     //
     // Default constructor
--- 22,118 ----
  
  #if   !defined(__CLFWCOMMON_HPP)
! #include <clfw/ClfwCommon.hpp>
  #endif
  
+ #if   !defined(__METASPACE_HPP)
+ #include <clfw/MetaSpace.hpp>
+ #endif
+ 
+ #if   !defined(__METACLASS_HPP)
+ #include <clfw/MetaClass.hpp>
+ #endif
+ 
  #if   !defined(__LIBRARY_HPP)
  #include INCL_Library
  #endif
  
+ #include <cstring>
+ 
  namespace corelinux
  {
+    static   CharPtr  gTestMethod( "handlesType" );
+    static   CharPtr  gGetLoaderMethod( "getLoaderType" );
+ 
+    static   MetaClassPtr   findHandler( CharPtr aName, MetaClassPtr aClass )
+    {
+       MetaClassPtr                     aPtr( NULLPTR );
+       Iterator<DispatchDescriptorPtr>  *aMethodIterator
+          ( 
+             aClass->createMethodIterator() 
+          );
+ 
+       //
+       // If we find the method we need, we check to
+       // see if the type handles it
+       //
+ 
+       while( aMethodIterator->isValid() == true )
+       {
+          if( strcmp
+                (
+                   gTestMethod,
+                   aMethodIterator->getElement()->theClassMethodName
+                ) == 0 )
+          {
+             bool  results(false);
+ 
+             aClass->dispatch
+                ( 
+                   gTestMethod,
+                   (void **)&aName, 
+                   (void *) &results
+                );
+ 
+             if( results == true )
+             {
+                aPtr = aClass;
+                break;
+             }
+             else
+             {
+                ;  // do nothing
+             }
+          }
+          else
+          {
+             ;  // search next method
+          }
+          aMethodIterator->setNext();
+       }
+ 
+       aClass->destroyIterator( aMethodIterator );
+ 
+       //
+       // If we have no luck, we dig deeper
+       //
+ 
+       if( aPtr == NULLPTR )
+       {
+          Iterator<MetaClassPtr> *aChildIterator( aClass->createIterator() );
+          while( aPtr == NULLPTR && aChildIterator->isValid() == true )
+          {
+             aPtr = findHandler( aName, aChildIterator->getElement() );
+             aChildIterator->setNext();
+          }
+          aClass->destroyIterator( aChildIterator );
+ 
+       }
+       else
+       {
+          ;  // do nothing
+       }
+ 
+       return aPtr;
+    }
     //
     // Default constructor
***************
*** 134,137 ****
--- 218,261 ----
  
     //
+    // Work the magic of ontologies!
+    //
+ 
+    LibraryInstancePtr   Library::load( CharPtr aName )
+       throw ( NullPointerException, LoaderNotFoundException )
+    {
+       LibraryInstancePtr   aInstance( NULLPTR );
+ 
+       if( aName == NULLPTR )
+       {
+          throw NullPointerException( LOCATION );
+       }
+       else
+       {
+          MetaClassPtr   aClass( this->findLibraryHandler( aName ) );
+          if( aClass == NULLPTR )
+          {
+             throw LoaderNotFoundException( LOCATION );
+          }
+          else
+          {
+ 
+          }
+       }
+ 
+       return aInstance;
+    }
+ 
+    //
+    // Go direct to the type handler
+    //
+ 
+    LibraryInstancePtr   Library::load( CharPtr, MetaClassPtr )
+                throw (NullPointerException, LoaderNotFoundException)
+    {
+       LibraryInstancePtr   aInstance( NULLPTR );
+       return aInstance;
+    }
+ 
+    //
     // Request the loader actually load a library instance
     //
***************
*** 160,163 ****
--- 284,300 ----
        }
        return aInstance;
+    }
+ 
+    //
+    // Setup the traversal looking for an appropriate handler
+    //
+ 
+    MetaClassPtr   Library::findLibraryHandler( CharPtr aName )
+    {
+       return findHandler
+          ( 
+             aName,
+             MetaSpace::getClassForType( LibraryType::getTypeDescriptor() )
+          );
     }
  }