namespace boost {
    template<typename T> class optional {
        T* operator->()
        {
            
        }
    };
}

#include <set>
#include <boost/optional.hpp>

#define VA_BOOST_OPTIONAL(x) boost::optional< x >

void test(void) {
	boost::optional<std::set<long> > maybeSet1 = std::set<long>();
	VA_BOOST_OPTIONAL(std::set<long>) maybeSet2 = std::set<long>();

	maybeSet1->insert(0);	// underlined
	maybeSet2->insert(0);	// no underlining, and listbox works
};

quote:

---

Originally posted by feline

Apologies for the slow progress on this. This is still down as a high priority bug, but some of the boost libraries are very complex and difficult for VA to parse.

I have found a pair of possible work arounds that might help you. The first work around is to add this to VA's StdAfx.h file:

namespace boost {
    template<typename T> class optional {
        T* operator->()
        {
            
        }
    };
}

this is working for me, using a simple test case. Hopefully this will work for you, without requiring you to make any edits to your code.

---

/* boost::optional */
namespace boost
{
   namespace optional_detail
   {
      /* boost::optional default types */
      template<class T>
      struct types_when_isnt_ref
      {
         typedef T const &reference_const_type;
         typedef T       &reference_type;
         typedef T const *pointer_const_type;
         typedef T       *pointer_type;
         typedef T const &argument_type;
      };

      template <class T>
      class __optional_types : public types_when_isnt_ref<T>
      {
      };

      /* boost::optional types for references */
      template<class T>
      struct types_when_is_ref
      {
         typedef T raw_type;

         typedef raw_type& reference_const_type;
         typedef raw_type& reference_type;
         typedef raw_type* pointer_const_type;
         typedef raw_type* pointer_type;
         typedef raw_type& argument_type;
      };

      template <class T>
      class __optional_types<T &> : public types_when_is_ref<T>
      {
      };

      struct optional_tag
      {
      };

      template<class T>
      class optional_base : public optional_tag
      {
         protected:
          typedef T value_type;

          typedef __optional_types<T> types;

          typedef typename types::reference_type       reference_type;
          typedef typename types::reference_const_type reference_const_type;
          typedef typename types::pointer_type         pointer_type;
          typedef typename types::pointer_const_type   pointer_const_type;
          typedef typename types::argument_type        argument_type;
      };
   }

   template <class T>
   class optional : public optional_detail::optional_base<T>
   {
      typedef optional_detail::optional_base<T> base;

   public:
      typedef optional<T> this_type;

      typedef typename base::value_type           value_type;
      typedef typename base::reference_type       reference_type;
      typedef typename base::reference_const_type reference_const_type;
      typedef typename base::pointer_type         pointer_type;
      typedef typename base::pointer_const_type   pointer_const_type;
      typedef typename base::argument_type        argument_type;

      reference_const_type get() const;
      reference_type       get();

      reference_const_type get_value_or(reference_const_type v) const;
      reference_type       get_value_or(reference_type       v);

      pointer_const_type operator->() const;
      pointer_type       operator->();

      reference_const_type operator *() const;
      reference_type       operator *();
   };
}