Can't understand multi_index

class ObjectStorage
{
    private:
        std::string objName;
        int zIndex;

        // Reference for the Object interface
        boost::shared_ptr<Object> mCppObject;

        // Reference for the Python interface
        boost::python::object mPythonObject;

    public:
        ObjectStorage(const std::string &name, int zIndex_, boost::shared_ptr<Object> cpp, boost::python::object python)
            : objName(name), zIndex(zIndex_),
              mCppObject(cpp), mPythonObject(python) {}

        std::string getName() const { return objName; };
        int getZIndex() const { return zIndex; }

        boost::shared_ptr<Object> getCppObject() const { return mCppObject; }
        boost::python::object getPythonObject() const { return mPythonObject; }
};

// Tagging for multi_index container
struct tag_zindex {};
struct tag_name {};
struct tag_cpp {};
struct tag_py {};

typedef boost::multi_index_container<ObjectStorage,
            bmi::ind开发者_开发百科exed_by<
                // ZIndex
                bmi::ordered_non_unique<
                    bmi::tag<tag_zindex>,
                    bmi::const_mem_fun<ObjectStorage, int, &ObjectStorage::getZIndex>
                >,

                // Name
                bmi::ordered_unique<
                    bmi::tag<tag_name>,
                    bmi::const_mem_fun<ObjectStorage, std::string, &ObjectStorage::getName>
                >,

                // CPP reference
                bmi::ordered_non_unique<
                    bmi::tag<tag_cpp>,
                    bmi::const_mem_fun<ObjectStorage, boost::shared_ptr<Object>, &ObjectStorage::getCppObject>
                >,

                // Python reference
                bmi::ordered_unique<
                    bmi::tag<tag_py>,
                    bmi::const_mem_fun<ObjectStorage, boost::python::object, &ObjectStorage::getPythonObject>
                >
            >
        > ObjectWrapperSet;

If first index in multi_index is right: sorting objects inside container refer to ZIndex value, I'm not sure about another. I need such functionality: Order by ZIndex but return getCppObject when iterating. Is it possible not only to set ordering, but result when accessing?

Also, for example tag_py I want to iterate through all getPythonObject, not ObjectStorage. Is this really possible with multi_index?

---

In your case multi_index_container contains instances of ObjectStorage objects. So you can iterate in any order through it and call any function of ObjectStorage class.

For instance to iterate using tag_py tag:

ObjectWrapperSet ow_set;

ObjectWrapperSet::index_const_iterator<tag_py>::type it = ow_set.get<tag_py>().begin();
for ( ; it != ow_set.get<tag_py>().end(); ++it ) {
  const ObjectStorage& os = *it; // note `it` is the iterator for ObjectStorage
  // now you can do
  boost::python::object po = os.getPythonObject();
  // or
  boost::python::object po = it->getPythonObject();
}

Using tag_zindex tag:

ObjectWrapperSet::index_const_iterator<tag_zindex>::type it = ow_set.get<tag_zindex>().begin();
for ( ; it != ow_set.get<tag_zindex>().end(); ++it ) {
  boost::shared_ptr<Object> cpp_obj = it->getCppObject();
  // do something
}