예제 #1
0
  void PlugIn::load_library( const std::string &library_file_name )
  {
    try
    {
      this->release_library();
      m_libraryHandle = this->do_load_library( library_file_name );
      if ( m_libraryHandle == NULL )
      {
        THROW_YAT_ERROR("SHAREDLIBRARY_ERROR",
                        "Unable to load the specified shared library",
                        "PlugIn::load_library");
      }

      Symbol sym = this->find_symbol(kOnLoadSymbol);

      OnLoadFunc_t load_func = (OnLoadFunc_t)(sym);
      load_func();

    }
    catch(yat::Exception& ex)
    {
      RETHROW_YAT_ERROR(ex,
                        "SHAREDLIBRARY_ERROR",
                        "Error while loading library",
                        "PlugIn::load_library");
    }
    catch (...)
    {
      THROW_YAT_ERROR("SHAREDLIBRARY_ERROR",
                      "Unknown error while loading library",
                      "PlugIn::load_library");
    }

  }
예제 #2
0
  IPlugInInfo* PlugIn::info()
  {
    Symbol symbol;
    try
    {
      symbol = this->find_symbol(kGetInfoSymbol);
    }
    catch(yat::Exception& ex)
    {
      RETHROW_YAT_ERROR(ex,
                        "SHAREDLIBRARY_ERROR",
                        "Unable to find the 'GetInfo' symbol",
                        "PlugIn::info");
    }

    GetInfoFunc_t get_info_func = (GetInfoFunc_t)(symbol);

    IPlugInInfo* info = 0;
    try
    {
      info = (*get_info_func)();
    }
    catch(...)
    {
      THROW_YAT_ERROR("UNKNOWN_ERROR",
                      "Unknown error during IPlugInInfo instantiation",
                      "PlugIn::info");
    }
    return info;
  }
예제 #3
0
  void PlugIn::release_library()
  {
    try
    {
      if ( m_libraryHandle != NULL )
      {
        Symbol sym = this->find_symbol(kOnUnLoadSymbol);

        OnUnLoadFunc_t unload_func = (OnUnLoadFunc_t)(sym);
        unload_func();

        this->do_release_library();
        m_libraryHandle = NULL;
      }
    }
    catch(yat::Exception& ex)
    {
      RETHROW_YAT_ERROR(ex,
                        "SHAREDLIBRARY_ERROR",
                        "Error while releasing library",
                        "PlugIn::release_library");
    }
    catch (...)
    {
      THROW_YAT_ERROR("SHAREDLIBRARY_ERROR",
                      "Unknown error while releasing library",
                      "PlugIn::release_library");
    }
  }
예제 #4
0
  IPlugInFactory* PlugIn::factory()
  {
    Symbol symbol;
    try
    {
      symbol = this->find_symbol(kGetFactorySymbol);
    }
    catch(yat::Exception& ex)
    {
      RETHROW_YAT_ERROR(ex,
                        "SHAREDLIBRARY_ERROR",
                        "Unable to find the 'GetFactory' symbol",
                        "PlugIn::factory");
    }

    GetFactoryFunc_t get_factory_func = (GetFactoryFunc_t)(symbol);

    IPlugInFactory* factory = 0;
    try
    {
      factory = (*get_factory_func)();
    }
    catch(...)
    {
      THROW_YAT_ERROR("UNKNOWN_ERROR",
                      "Unknown error during factory instantiation",
                      "PlugIn::factory");
    }
    return factory;
  }
예제 #5
0
/*virtual*/
void IBASourceBypass::get_image(ImageAndInfo & imginf) throw (yat::Exception)
{ 
  if (!this->image_grabber_->is_Image_allowed(Tango::READ_REQ))
    THROW_YAT_ERROR("ATTR_NOT_ALLOWED",
                    "Image attribute cannot be read in this state.",
                    "IBASourceBypass::get_image");

  GrabAPI::SharedImage* si = 0;
  // From now on: act as if it was a Tango request:
  {
    Tango::AutoTangoMonitor guard(this->image_grabber_);

    // Ask for the attributes to be updated...
    std::vector<long> attr_list; /// @todo fill attr_list...
    this->image_grabber_->read_attr_hardware(attr_list);

    // Get the last image
    si = this->image_grabber_->get_last_image();
  }

  const GrabAPI::Image* gimage = si->get_image();
  if (gimage == NULL) {
    SAFE_RELEASE(si);
    THROW_YAT_ERROR("EMPTY_IMAGE",
                    "The image is empty.",
                    "IBASourceBypass::get_image");
  }

  // So we got the shared image. Now copy it to an image
  // in the format expected by ImageBeamAnalyzer
  try {
    imginf.bit_depth = gimage->bit_depth;
    imginf.image = this->convert_image_grabber_to_isl(gimage);
  } catch (yat::Exception &) {
    SAFE_RELEASE(si);
    throw;
  } catch (...) {
    SAFE_RELEASE(si);
    THROW_YAT_ERROR(  "UNKNOWN_ERROR",
                      "Unknown problem when converting ImgGrabber image to isl::Image",
                      "IBASourceBypass::get_image" );
  }

  SAFE_RELEASE(si);
}
예제 #6
0
/*static*/ IBASource* IBASourceFactory::create(const std::string & name)
{
  if (!IBASourceFactory::s_first_)
    THROW_YAT_ERROR(
        "NO_FACTORY",
        "No IBASource factory has been defined, so it is not possible to create"
        " IBASource objects -> Can't connect to a source of images.",
        "IBASourceFactory::create");
  return IBASourceFactory::s_first_->create_object(name);
}
예제 #7
0
IBASource* IBASourceFactory::create_next(const std::string & name)
{
  if (!this->next_)
    THROW_YAT_ERROR(
        "NO_NEXT_FACTORY",
        "No IBASource factory has been been able to create"
        " a IBASource object -> Can't connect to a source of images.",
        "IBASourceFactory::create_next");

  return this->next_->create_object(name);
}
예제 #8
0
파일: PlugInUnix.cpp 프로젝트: srgblnch/yat
//-----------------------------------------------------------------------------
// PlugIn::do_load_library
//-----------------------------------------------------------------------------
PlugIn::LibraryHandle PlugIn::do_load_library( const std::string &library_file_name )
{
  PlugIn::LibraryHandle handle = ::dlopen( library_file_name.c_str(), RTLD_NOW | RTLD_GLOBAL );
  if( NULL == handle )
  {
    THROW_YAT_ERROR( std::string("SHAREDLIBRARY_ERROR"),
                     std::string(::dlerror()),
                     std::string("PlugIn::do_load_library") );
  }
  return handle;
}
예제 #9
0
/*static*/
isl::Image* IBASourceBypass::convert_image_grabber_to_isl(const GrabAPI::Image* gimage) throw (yat::Exception)
{
  try {
    isl::Image* image = new isl::Image(gimage->width(), gimage->height(), isl::ISL_STORAGE_USHORT);
    image->unserialize(gimage->base());
    return image;
  } catch(isl::Exception & ex) {
    GrabAPI::ISL2YATException yat_exc(ex);
    isl::ErrorHandler::reset();
    RETHROW_YAT_ERROR(yat_exc,
                      "SOFTWARE_FAILURE",
                      "Unable to convert from GrabAPI::Image to isl::Image.",
                      "IBASourceBypass::convert_image_grabber_to_isl.");
  } catch(std::bad_alloc &) {
    THROW_YAT_ERROR("OUT_OF_MEMORY",
                    "Allocation of isl::Image failed [std::bad_alloc]",
                    "IBASourceBypass::convert_image_grabber_to_isl");
  } catch(...) {
     THROW_YAT_ERROR("UNKNOWN_ERROR",
                    "Unable to convert from GrabAPI::Image to isl::Image. [Unknown exception caught]",
                    "IBASourceBypass::convert_image_grabber_to_isl");
  }
}
예제 #10
0
 PlugIn::Symbol PlugIn::find_symbol( const std::string &symbol )
 {
   try
   {
     Symbol symbol_pointer = this->do_find_symbol( symbol );
     if ( symbol_pointer != NULL )
       return symbol_pointer;
   }
   catch ( ... )
   {
   }
   
   THROW_YAT_ERROR("SHAREDLIBRARY_ERROR",
                   "Unable to find the requested symbol",
                   "PlugIn::find_symbol");
   return NULL;    // keep compiler happy
 }
예제 #11
0
// ----------------------------------------------------------------------------
// Socket::init
// ----------------------------------------------------------------------------
void Socket::init ()
  throw (SocketException)
{
  if (Socket::init_done)
    return;

#ifdef WIN32
  //- windows hell: magic initialization call 
  WSADATA wsdata;
  if (::WSAStartup(MAKEWORD(2,2), &wsdata))
  {
    THROW_YAT_ERROR("YAT_INTERNAL_ERROR", 
                    "win32::socket2 library initialization failed", 
                    "Address::ns_lookup");
  }
#endif

  Socket::init_done = true;
}
예제 #12
0
// ----------------------------------------------------------------------------
// Address::ns_lookup
// ----------------------------------------------------------------------------
void Address::ns_lookup (const std::string& _host_ipaddr_or_name)
  throw (Exception)
{
  YAT_TRACE("Address::ns_lookup");

  //- is _host_ipaddr_or_name an IP address or a host name?
  unsigned int ip_addr = ::inet_addr(_host_ipaddr_or_name.c_str());

  //- in case it's an IP address
  if (ip_addr != INADDR_NONE)
  {
    //- store it into the local member
    this->m_ip_addr = _host_ipaddr_or_name;
    //- get associated host name
    struct hostent * host = 
        ::gethostbyaddr((char*)&ip_addr, sizeof(ip_addr), AF_INET);
    //- if host as a valid hostname then store it localy
    if (host) 
      this->m_host_name = host->h_name;
    else
      this->m_host_name = _host_ipaddr_or_name;
  } 
  //- in case it's a host name
  else 
  {
    //- store it into the local member
    this->m_host_name = _host_ipaddr_or_name;
    //- get associated ip address
    struct hostent * host = ::gethostbyname(_host_ipaddr_or_name.c_str());
    //- got a valid ip addr?
    if (! host) 
    {
      yat::OSStream oss;
      oss << "could not resolve IP address for host "
          << _host_ipaddr_or_name 
          << std::endl;
      THROW_YAT_ERROR("INVALID_HOST", oss.str().c_str(), "Address::ns_lookup");
    }
    //- store it into the local member
    this->m_ip_addr = ::inet_ntoa(*((struct in_addr*)host->h_addr));
  }
}
예제 #13
0
// ============================================================================
// Task::go
// ============================================================================
void Task::go (Message * _msg, size_t _tmo_ms) 
   throw (Exception)
{
  YAT_TRACE("Task::go");

  this->start_undetached();

  if ( 
         (_msg == 0)
      || 
         (_msg->type() != TASK_INIT)
      ||
         (_msg->waitable() == false)
     )
     THROW_YAT_ERROR("PROGRAMMING_ERROR",
                     "invalid INIT message [null, wrong type or not waitable]",
                     "Task::go");

  this->wait_msg_handled (_msg, _tmo_ms);
}
예제 #14
0
// ======================================================================
// Task::wait_msg_handled
// ======================================================================
void Task::wait_msg_handled (Message * _msg, size_t _tmo_ms) 
  throw (Exception)
{
  YAT_TRACE("Task::wait_msg_handled");

  //- check input
  if (! _msg || ! _msg->waitable())  
  {
    if (_msg) 
      _msg->release();
    THROW_YAT_ERROR("INVALID_ARGUMENT", 
                    "invalid message [either null or not waitable]", 
                    "Task::wait_msg_handled");
  }

  try
  {
    //- post a shallow copy of the msg 
    this->msg_q_.post(_msg->duplicate());
  }
  catch (...)
  {
    _msg->release();
    THROW_YAT_ERROR("INTERNAL_ERROR", 
                    "message could not be posted", 
                    "Task::wait_msg_handled"); 
  }
  
  YAT_LOG("Task::wait_msg_handled::waiting for msg [" 
          << std::hex 
          << (void*)_msg 
          << std::dec 
          << "] to be handled");
  
  //- wait for the msg to be handled or tmo expiration
  if (_msg->wait_processed(_tmo_ms))
  {
    YAT_LOG("Task::wait_msg_handled::msg [" 
            << std::hex 
            << (void*)_msg 
            << std::dec 
            << "] handled [gave error::" 
            << (_msg->has_error() ? "yes" : "no")
            << "]" );
    Exception msg_exception;
    bool msg_gave_error = _msg->has_error();
    //- to store error localy before releasing msg
    if (msg_gave_error)
      msg_exception = _msg->get_error();
    //- release msg
    _msg->release();
    //- throw an exception if msg gave error
    if (msg_gave_error)
      throw msg_exception;
    //- msg did not gave error, just return
    return;
  }

  //- too bad, timeout expired...
  YAT_LOG("Task::wait_msg_handled::timeout expired while waiting for msg [" 
          << std::hex 
          << (void*)_msg 
          << std::dec 
          << "] to be handled");
            
  //- release msg
  _msg->release();

  //- throw timeout exception
  THROW_YAT_ERROR("TIMEOUT_EXPIRED",
                  "timeout expired while waiting for message to be handled",
                  "Task::wait_msg_handled");
}
예제 #15
0
// ======================================================================
// Task::exit
// ======================================================================
void Task::exit () 
  throw (Exception)
{
  YAT_TRACE("Task::exit");

  //- we may have to implicitly delete the thread
  bool delete_self = false;

  //- enter critical section
  this->m_lock.lock();

  //- get underlying thread state
  Thread::State ts = this->state_i();

  //- if the thread is running, then ask it to exit
  if (ts == yat::Thread::STATE_RUNNING)
  {
    yat::Message * msg = 0;
    try
    {
      msg = Message::allocate (yat::TASK_EXIT, EXIT_MSG_PRIORITY, true);
    }
    catch (Exception &ex)
    {
      this->m_lock.unlock();
      RETHROW_YAT_ERROR(ex, 
                        "SOFTWARE_ERROR", 
                        "Could not stop task [yat::Message allocation failed]", 
                        "Task::exit");
    }
    catch (...)
    {
      this->m_lock.unlock();
      THROW_YAT_ERROR("UNKNOWN_ERROR", 
                      "Could not stop task [yat::Message allocation failed]", 
                      "Task::exit");
    }
    //- unlock the thread lock (avoid deadlock during message handling)
    this->m_lock.unlock();
    try
    {
      //- ... then wait for TASK_EXIT msg to be handled
      //- TODO: change kINFINITE_WAIT to a more flexible TIMEOUT
      YAT_LOG("Task::exit - waiting for the TASK_EXIT msg to be handled");
      this->wait_msg_handled (msg, kINFINITE_WAIT);
    }
    catch (...)
    {
      //- ignore any error
    }
    //- wait for the thread to actually quit
    try
    {
      Thread::IOArg dummy = 0;
      YAT_LOG("Task::exit - about to join with the underlying thread");
      this->join (&dummy);
    }
    catch (...)
    {
     //- ignore any error
    }
  }
  else if (ts == yat::Thread::STATE_NEW) 
  {
    //- delete the thread (instanciated but never been started)
    YAT_LOG("Task::exit - about to delete the thread [has never been started]");
    delete_self = true;
    //- leave critical section
    this->m_lock.unlock();
  }
  else
  {
    //- nothing to do...
    YAT_LOG("Task::exit - do nothing");
    //- leave critical section
    this->m_lock.unlock();
  }

  //- delete (if required)
  if (delete_self)
  {
    YAT_LOG("Task::exit - deleting <this> Task instance");
    delete this;
  }
}