NVUtil.cpp

Go to the documentation of this file.

// -*- C++ -*-
#ifdef WIN32
#pragma warning( push )
#pragma warning( disable : 4267 )
#pragma warning( disable : 4290 )
#pragma warning( disable : 4311 )
#pragma warning( disable : 4312 )
#endif // WIN32

#include <map>
#include <algorithm>
#include <coil/stringutil.h>
#include <rtm/NVUtil.h>
#include <rtm/CORBA_SeqUtil.h>

#ifdef WIN32
#pragma warning( pop )
#endif // WIN32

namespace NVUtil
{
  SDOPackage::NameValue newNVChar(const char* name, const CORBA::Char value)
  {
    SDOPackage::NameValue nv;
    nv.name = CORBA::string_dup(name);
    nv.value <<= CORBA::Any::from_char(value);
    return nv;
  }
  
  SDOPackage::NameValue newNVBool(const char* name, const CORBA::Boolean value)
  {
    SDOPackage::NameValue nv;
    nv.name = CORBA::string_dup(name);
    nv.value <<= CORBA::Any::from_boolean(value);
    return nv;
  }
  
  SDOPackage::NameValue newNVOctet(const char* name, const CORBA::Octet value)
  {
    SDOPackage::NameValue nv;
    nv.name = CORBA::string_dup(name);
    nv.value <<= CORBA::Any::from_octet(value);
    return nv;
  }
  
  SDOPackage::NameValue newNVAny(const char* name, const CORBA::Any& value)
  {
    SDOPackage::NameValue nv;
    nv.name = CORBA::string_dup(name);
    nv.value = value;
    return nv;
  }
  
#ifndef ORB_IS_RTORB
  void copyFromProperties(SDOPackage::NVList& nv, const coil::Properties& prop)
#else // ORB_IS_RTORB
    void copyFromProperties(SDOPackage_NVList& nv, const coil::Properties& prop)
#endif // ORB_IS_RTORB
  {
    std::vector<std::string> keys;
    keys = prop.propertyNames();
    CORBA::ULong len((CORBA::ULong)keys.size());
    nv.length(len);
    
    for (CORBA::ULong i = 0; i < len; ++i)
      {
// Why RtORB does not copy string to Properties.
#ifndef ORB_IS_RTORB
        nv[i].name = CORBA::string_dup(keys[i].c_str());
#else // ORB_IS_RTORB
        nv[i].name = (char *)keys[i].c_str();
#endif // ORB_IS_RTORB
        nv[i].value <<= prop[keys[i]].c_str();
      }
  }
  
  void copyToProperties(coil::Properties& prop, const SDOPackage::NVList& nv)
  {
    for (CORBA::ULong i(0), len(nv.length()); i < len; ++i)
      {
        const char* value;
        if (nv[i].value >>= value)
          {
            const char* name(nv[i].name);
            prop[name] = value;
          };
      }
  }
  
  struct to_prop
  {
    to_prop()
    {
    };
    void operator()(const SDOPackage::NameValue& nv)
    {
      const char* value;
      if (nv.value >>= value)
        {
          m_prop.setProperty(CORBA::string_dup(nv.name), value);
        };
    }
    coil::Properties m_prop;
  };
  
  coil::Properties toProperties(const SDOPackage::NVList& nv)
  {
    to_prop p;
    p = CORBA_SeqUtil::for_each(nv, p);
    return p.m_prop;
  }
  
  struct nv_find
  {
    nv_find(const char* name) : m_name(name) {};
    bool operator()(const SDOPackage::NameValue& nv)
    {
      std::string name(nv.name);
      return m_name == name;
    }
    std::string m_name;
  };
  
  const CORBA::Any& find(const SDOPackage::NVList& nv, const char* name)
  {
    CORBA::Long index;
    index = CORBA_SeqUtil::find(nv, NVUtil::nv_find(name));
    if (index < 0) throw std::string("Not found");
    return nv[index].value;
  }
  
  const CORBA::Long find_index(const SDOPackage::NVList& nv, const char* name)
  {
    return  CORBA_SeqUtil::find(nv, NVUtil::nv_find(name));
  }
  
  bool isString(const SDOPackage::NVList& nv, const char* name)
  {
    try
      {
        CORBA::Any value;
        value = find(nv, name);
        const char* str_value;
        return value >>= str_value;
      }
    catch (...)
      {
        return false;
      }
  }
  
  bool isStringValue(const SDOPackage::NVList& nv,
                     const char* name, const char* value)
  {
    if (isString(nv, name))
      {
        if (toString(nv, name) == value)
          {
            return true;
          }
      }
    return false;
  }
  
  std::string toString(const SDOPackage::NVList& nv, const char* name)
  {
    const char* str_value;
    try
      {
        if(!(find(nv, name) >>= str_value))
          {
            str_value = "";
          }
      }
    catch (...)
      {
        str_value = "";
      }

    if (str_value == NULL)
      {
        str_value = "";
      }
    
    return str_value;
  }
  
#ifndef ORB_IS_RTORB
  bool appendStringValue(SDOPackage::NVList& nv, const char* name,
                         const char* value)
#else // ORB_IS_RTORB
  bool appendStringValue(SDOPackage_NVList& nv, const char* name,
                         const char* value)
#endif // ORB_IS_RTORB
  {
    //    if (!isString(nv, name)) return false;
    
    CORBA::Long index;
    index = find_index(nv, name);
    
    if (index < 0)
      {
        CORBA_SeqUtil::push_back(nv, newNV(name, value));
      }
    else
      {
        const char* tmp_char;
        nv[index].value >>= tmp_char;
        std::string tmp_str(tmp_char);
        
        std::vector<std::string> values;
        values = coil::split(tmp_str, ",");
        if (values.end() == std::find(values.begin(), values.end(), value))
          {
            tmp_str.append(",");
            tmp_str.append(value);
            nv[index].value <<= tmp_str.c_str();
          }
      }
    return true;
  }
  
  void append(SDOPackage::NVList& dest, const SDOPackage::NVList& src)
  {
    for (CORBA::ULong i = 0, len = src.length(); i < len; ++i)
      {
        CORBA_SeqUtil::push_back(dest, src[i]);
      }
  }
  
  std::ostream& dump_to_stream(std::ostream& out, const SDOPackage::NVList& nv)
  {
    for (CORBA::ULong i(0), n(nv.length()); i < n; ++i)
      {
        const char* str_value;
        if (nv[i].value >>= str_value)
          {
            out << nv[i].name << ": " << str_value << std::endl;
          }
        else
          {
            out << nv[i].name << ": not a string value" << std::endl;
          }
      }
    return out;
  }

  void dump(const SDOPackage::NVList& nv)
  {
    dump_to_stream(std::cout, nv);
  }

  std::string toString(const SDOPackage::NVList& nv)
  {
    std::stringstream s;
    dump_to_stream(s, nv);
    return s.str();
  }
};