FactoryLibrary_ltdl.cc

Go to the documentation of this file.

/*
 * FactoryLibrary_ltdl.cc
 *
 * Copyright (c) 2003 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file FactoryLibrary_ltdl.cc
 *
 * Implementation file for the FactoryLibrary_ltdl class.
 */

#include "config.h"

#include <assert_pp.h>
#include <factory_library.h>

#include <strstream>

#include "FactoryLibrary_ltdl.hh"

#ifndef __XSTRING
/**
 * Convert a macro argument to a string.
 *
 * @param x The macro to expand to a string.
 */
#define __XSTRING(x) __STRING(x)
#endif

map<string, FactoryLibrary_ltdl *> FactoryLibrary_ltdl::open_libraries;

CORBA::ORB_var FactoryLibrary_ltdl::orb;

FactoryLibrary_ltdl::FactoryLibrary_ltdl(const char *name,
                                         lt_dlhandle dlh,
                                         factory_method_t fm)
{
    require(name != NULL);
    require(dlh != NULL);
    require(fm != NULL);

    this->fl_Name = name;
    this->fl_OpenCount = 1;
    this->fl_Library = dlh;
    this->fl_Method = fm;
}

FactoryLibrary_ltdl::~FactoryLibrary_ltdl(void)
{
    require(this->fl_OpenCount == 0);
    
    lt_dlclose(this->fl_Library);
    this->fl_Library = NULL;
    this->fl_Method = NULL;
}

char *FactoryLibrary_ltdl::Name(void)
    throw (CORBA::SystemException)
{
    CORBA::String_var retval;

    retval = this->fl_Name;
    return( retval._retn() );
}

CORBA::Long FactoryLibrary_ltdl::Hey(const edu::utah::pces::ArgV &args,
                                     CORBA::String_out o,
                                     CORBA::String_out e)
    throw (CORBA::SystemException)
{
    HeyParser hp(args.length(), args.get_buffer());
    CORBA::Long retval = EINVAL;

    /* String streams for stdout and stderr */
    strstream out, err;

    try
    {
        /* Pass the request to the library. */
        retval = flFactoryMethod(this->fl_Method, FLO_HEY,
                                 FMA_ORB, FactoryLibrary_ltdl::orb.in(),
                                 FMA_HeyParser, &hp,
                                 FMA_StandardOut, &out,
                                 FMA_StandardError, &err,
                                 FMA_TAG_DONE);
    }
    catch(const HeyParserException &e)
    {
        err << e << endl;
    }

    /* Terminate the stdio strings. */
    out << ends;
    err << ends;

    /* Pass them back out. */
    o = out.str();
    e = err.str();
    return( retval );
}

edu::utah::pces::FactoryLibrary_ptr
FactoryLibrary_ltdl::OpenLibrary(const char *name)
    throw (edu::utah::pces::NoSuchLibrary,
           CORBA::SystemException)
{
    edu::utah::pces::FactoryLibrary_var retval;
    lt_dlhandle dlh;

    require(name != NULL);

    /* Do some initialization... */
    {
        static bool init_done = false;

        if( !init_done )
        {
            int argc = 0;
            
            if( lt_dlinit() != 0 )
            {
                /* XXX Use a more appropriate exception. */
                throw CORBA::NO_MEMORY();
            }
            orb = CORBA::ORB_init(argc, NULL);
            init_done = true;
        }
    }

    /* Check if it is already open, */
    if( FactoryLibrary_ltdl::open_libraries.count(name) )
    {
        FactoryLibrary_ltdl *fl;

        fl = FactoryLibrary_ltdl::open_libraries[name];
        fl->fl_OpenCount += 1;
        retval = fl->_this();
    }
    /* ... or is a valid path to a library. */
    else if( (dlh = lt_dlopenext(name)) != NULL )
    {
        FactoryLibrary_ltdl *fl;
        factory_method_t fm;

        /* Check if it is a real factory library then */
        if( (fm = (factory_method_t)
             lt_dlsym(dlh, __XSTRING(FACTORY_METHOD_SYMBOL))) == NULL )
        {
            lt_dlclose(dlh);
            throw edu::utah::pces::NoSuchLibrary(name, "No factory_method_t");
        }

        /* ... create the object and */
        fl = new FactoryLibrary_ltdl(name, dlh, fm);
        /* ... add it to the map. */
        FactoryLibrary_ltdl::open_libraries[name] = fl;
        retval = fl->_this();
    }
    else
    {
        throw edu::utah::pces::NoSuchLibrary(name, lt_dlerror());
    }
    return( retval._retn() );
}

---