FactoryLibrary_ltdl.cc

Go to the documentation of this file.

/*
 * FactoryLibrary_ltdl.cc
 *
 * Copyright (c) 2003, 2004 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 <sstream>

#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(PortableServer::POA_ptr poa,
                                         const char *name,
                                         lt_dlhandle dlh,
                                         factory_method_t fm) :
    fl_POA(PortableServer::POA::_duplicate(poa)),
    fl_Name(name),
    fl_OpenCount(1),
    fl_Library(dlh),
    fl_Method(fm)
{
    require(name != NULL);
    require(dlh != NULL);
    require(fm != NULL);
}

FactoryLibrary_ltdl::~FactoryLibrary_ltdl(void)
{
    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 */
    stringstream out, err;
    string so, se;

    try
    {
        /* Pass the request to the library. */
        retval = flFactoryMethod(this->fl_Method, FLO_HEY,
                                 FMA_ORB, FactoryLibrary_ltdl::orb.in(),
                                 FMA_POA, this->fl_POA.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. */
    so = out.str();
    se = err.str();
    o = so.c_str();
    e = se.c_str();
    return( retval );
}

edu::utah::pces::FactoryLibrary_ptr
FactoryLibrary_ltdl::OpenLibrary(PortableServer::POA_ptr poa,
                                 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 )
            {
                cerr << "lt_dlinit: " << lt_dlerror << endl;
                throw CORBA::NO_MEMORY(); /** @todo Throw something else... */
            }
            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 = edu::utah::pces::FactoryLibrary::
            _narrow(poa->servant_to_reference(fl));
        fl = NULL;
    }
    /* ... or is a valid path to a library. */
    else if( (dlh = lt_dlopenext(name)) != NULL )
    {
        PortableServer::ObjectId_var oid;
        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(poa, name, dlh, fm);
        /* ... add it to the map. */
        FactoryLibrary_ltdl::open_libraries[name] = fl;
        oid = poa->activate_object(fl);
        retval = edu::utah::pces::FactoryLibrary::
            _narrow(poa->id_to_reference(oid.in()));
        fl = NULL;
    }
    else
    {
        throw edu::utah::pces::NoSuchLibrary(name, lt_dlerror());
    }
    return( retval._retn() );
}

void FactoryLibrary_ltdl::Shutdown(void)
{
    lt_dlexit();
}

---