CorbaUtil.H

Go to the documentation of this file.

/*!@file Corba/CorbaUtil.H */

// //////////////////////////////////////////////////////////////////// //
// The iLab Neuromorphic Vision C++ Toolkit - Copyright (C) 2001 by the //
// University of Southern California (USC) and the iLab at USC.         //
// See http://iLab.usc.edu for information about this project.          //
// //////////////////////////////////////////////////////////////////// //
// Major portions of the iLab Neuromorphic Vision Toolkit are protected //
// under the U.S. patent ``Computation of Intrinsic Perceptual Saliency //
// in Visual Environments, and Applications'' by Christof Koch and      //
// Laurent Itti, California Institute of Technology, 2001 (patent       //
// pending; application number 09/912,225 filed July 23, 2001; see      //
// http://pair.uspto.gov/cgi-bin/final/home.pl for current status).     //
// //////////////////////////////////////////////////////////////////// //
// This file is part of the iLab Neuromorphic Vision C++ Toolkit.       //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit is free software; you can   //
// redistribute it and/or modify it under the terms of the GNU General  //
// Public License as published by the Free Software Foundation; either  //
// version 2 of the License, or (at your option) any later version.     //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit is distributed in the hope  //
// that it will be useful, but WITHOUT ANY WARRANTY; without even the   //
// implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      //
// PURPOSE.  See the GNU General Public License for more details.       //
//                                                                      //
// You should have received a copy of the GNU General Public License    //
// along with the iLab Neuromorphic Vision C++ Toolkit; if not, write   //
// to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,   //
// Boston, MA 02111-1307 USA.                                           //
// //////////////////////////////////////////////////////////////////// //
//
// Primary maintainer for this file: Lior Elazary <lelazary@yahoo.com>
// $HeadURL: svn://isvn.usc.edu/software/invt/trunk/saliency/src/Corba/CorbaUtil.H $
// $Id: CorbaUtil.H 14125 2010-10-12 06:29:08Z itti $
//

#ifndef CORBAUTIL_H
#define CORBAUTIL_H

#include <omniORB4/Naming.hh>
#include <omniORB4/omniURI.h>
#include <cstdio> // for sprintf

OMNI_USING_NAMESPACE(omni);


//! Build an object reference for many object within a context
inline bool getMultiObjectRef(CORBA::ORB_ptr orb, const char *contextName, CORBA::Object_ptr *dst, int &nObj){
        LINFO("Looking for objects");
        CosNaming::NamingContext_var rootContext;

        try {
                // Obtain a reference to the root context of the Name service:
                CORBA::Object_var obj;
                obj = orb->resolve_initial_references("NameService");
                // Narrow the reference returned.
                rootContext = CosNaming::NamingContext::_narrow(obj);
                if( CORBA::is_nil(rootContext) ) {
                        LFATAL("Failed to narrow the root naming context.");
                        return false;
                }
        }
        catch(CORBA::ORB::InvalidName& ex) {
                // This should not happen!
                LFATAL("Service required is invalid [does not exist].");
                return false;
        }

        //find out how many objects we have to work with

        CosNaming::Name_var name = omniURI::stringToName(contextName);

        CORBA::Object_var obj = rootContext->resolve(name);

        CosNaming::NamingContext_var context;
        context = CosNaming::NamingContext::_narrow(obj);

        if (CORBA::is_nil(context)) {
                LINFO("No objects found\n");
                return false;
        }

        //get all the objects in the context

        CosNaming::BindingIterator_var bi;
        CosNaming::BindingList_var bl;
        CosNaming::Binding_var b;

        context->list(0, bl, bi);

        if (CORBA::is_nil(bi)){
                LINFO("No objects found\n");
                return false;
        }

        nObj=0;
        while (bi->next_one(b)){

                CosNaming::Name name_comp = b->binding_name;

                char* name = omniURI::nameToString(name_comp);
                LINFO("Binding to %s ... ", name);
                delete name;

                CORBA::Object_ptr ref = context->resolve(name_comp);
                dst[nObj] = ref;

                if (!CORBA::is_nil(dst[nObj])){
                        nObj++;
                        LINFO("Done\n");
                } else {
                        LINFO("Fail\n");
                }

        }
        bi->destroy();

        return true;
}

//////////////////////////////////////////////////////////////////////

inline static CORBA::Boolean
bindObjectToName(CORBA::ORB_ptr orb, CORBA::Object_ptr objref,
                 const char* contextId, const char* contextKind,
                 const char* objectPrefix, CosNaming::Name& objectName)
{
        CosNaming::NamingContext_var rootContext;

        try {
                // Obtain a reference to the root context of the Name service:
                CORBA::Object_var obj;
                obj = orb->resolve_initial_references("NameService");

                if( CORBA::is_nil(obj) ) {
                        LFATAL("Obj is null.");
                        return 0;
                }

                // Narrow the reference returned.
                rootContext = CosNaming::NamingContext::_narrow(obj);
                if( CORBA::is_nil(rootContext) ) {
                        LFATAL("Failed to narrow the root naming context.");
                        return 0;
                }
        }
        catch(CORBA::ORB::InvalidName& ex) {
                // This should not happen!
                LFATAL("Service required is invalid [does not exist].");
                return 0;
        }

        try {
                // Bind a context called "test" to the root context:

                CosNaming::Name contextName;
                contextName.length(1);
                contextName[0].id   = (const char*)contextId;   // string copied
                contextName[0].kind = (const char*)contextKind; // string copied
                // Note on kind: The kind field is used to indicate the type
                // of the object. This is to avoid conventions such as that used
                // by files (name.type -- e.g. test.ps = postscript etc.)
                CosNaming::NamingContext_var testContext;
                try {
                        // Bind the context to root.
                        testContext = rootContext->bind_new_context(contextName);
                }
                catch(CosNaming::NamingContext::AlreadyBound& ex) {
                        // If the context already exists, this exception will be raised.
                        // In this case, just resolve the name and assign testContext
                        // to the object returned:
                        CORBA::Object_var obj;
                        obj = rootContext->resolve(contextName);
                        testContext = CosNaming::NamingContext::_narrow(obj);
                        if( CORBA::is_nil(testContext) ) {
                                LFATAL("Failed to narrow naming context.");
                                return 0;
                        }
                }

                // Bind objref with name Echo to the testContext:
                objectName.length(1);


                bool bound = false;
                char CmapID[100];
                for (int i=0; i<100 && !bound; i++) {
                        sprintf(CmapID, "%s_%i", objectPrefix, i);
                        LINFO("Binding object %s", CmapID);
                        objectName[0].id   = (const char*) CmapID;   // string copied
                        objectName[0].kind = (const char*) "Object"; // string copied

                        bound = true;
                        try {
                                testContext->bind(objectName, objref);
                        }
                        catch(CosNaming::NamingContext::AlreadyBound& ex) {
                                //testContext->rebind(objectName, objref);
                                bound = false;
                        }

                }

                if (!bound){
                        LFATAL("Can not bind object");
                        return 0;
                } else {
                }


                // Amendment: When using OrbixNames, it is necessary to first try bind
                // and then rebind, as rebind on it's own will throw a NotFoundexception if
                // the Name has not already been bound. [This is incorrect behaviour -
                // it should just bind].
        }
        catch(CORBA::COMM_FAILURE& ex) {
                LFATAL("Caught system exception COMM_FAILURE -- unable to contact the naming service.");
                return 0;
        }
        catch(CORBA::SystemException&) {
                LFATAL("Caught a CORBA::SystemException while using the naming service.");
                return 0;
        }

        return 1;
}

// unbind the object from the name server
inline void unbindObject (CORBA::ORB_ptr orb, const char* contextId,
                          const char* contextKind,
                          CosNaming::Name &objectName){
        CosNaming::NamingContext_var rootContext;

        try {
                // Obtain a reference to the root context of the Name service:
                CORBA::Object_var obj;
                obj = orb->resolve_initial_references("NameService");

                if( CORBA::is_nil(obj) ) {
                        LFATAL("Obj is null.");
                        return;
                }

                // Narrow the reference returned.
                rootContext = CosNaming::NamingContext::_narrow(obj);
                if( CORBA::is_nil(rootContext) ) {
                        LFATAL("Failed to narrow the root naming context.");
                        return;
                }
        }
        catch(CORBA::ORB::InvalidName& ex) {
                // This should not happen!
                LFATAL("Service required is invalid [does not exist].");
                return;
        }

        CosNaming::Name contextName;
        contextName.length(2);
        contextName[0].id   = (const char*)contextId;
        contextName[0].kind = (const char*)contextKind;
        contextName[1] = objectName[0];

        rootContext->unbind(contextName);
}

/****************************** Convertion Util ***************************/
inline Point2DOrb toOrb(const Point2D<int> &p){
        Point2DOrb_var pOrb;
        pOrb->i = p.i;
        pOrb->j = p.j;
        return pOrb._retn();
}

#endif