question

The problem is that FlexScript currently doesn't use reference types as return values. Instead, you have to create a non-reference type that wraps a pointer or iterator, and return that object. Here's an implementation of an ordered map in a module. Note that for unordered maps, I would just use version 21.0+, which has a Map type natively in FlexScript; it supports Variant keys and Variant values.

WARNING: as with the previous example, this code lets you create values that are no longer safe to use if you modify the map.

typedef std::map<std::string, Variant> StrMap;

class StrMapIter
{
private:
  StrMap::iterator endIter;
  StrMap::iterator iter;

public:
  StrMapIter() {}
  StrMapIter(const StrMap::iterator& iter, const StrMap::iterator& endIter) : iter(iter), endIter(endIter) {}
  StrMapIter(const StrMapIter& other) : iter(other.iter), endIter(other.endIter) {}

  void construct() { new (this) StrMapIter(); }
  void construct(const StrMapIter& other) { new (this) StrMapIter(other); }
  void destruct() { this->~StrMapIter(); }

  const char* _getKey() { return iter->first.c_str(); }
  __declspec(property(get = _getKey)) const char* key;

  Variant _getValue() { return iter->second; }
  void _setValue(const Variant& value) { iter->second = value; }
  __declspec(property(get = _getValue, put = _setValue)) Variant value;

  operator Variant() { return iter->second; }
  operator int() { return iter != endIter ? 1 : 0; }

  StrMapIter operator =(const Variant& other) {
    iter->second = other;
    return StrMapIter(*this);
  }

  StrMapIter& operator=(const StrMapIter& other) {
    iter = other.iter;
    endIter = other.endIter;
    return *this;
  }

  StrMapIter operator++(int) {
    StrMapIter temp(*this);
    ++iter;
    return temp;
  }

  void bindInterface() {
    SimpleDataType::bindConstructor(&StrMapIter::construct, "void StrMapIter()");
    SimpleDataType::bindCopyConstructor<StrMapIter>(&StrMapIter::construct);
    SimpleDataType::bindCopyAssigner<StrMapIter>(&StrMapIter::operator =);
    SimpleDataType::bindDestructor<StrMapIter>(&StrMapIter::destruct);

    auto assignOp = (StrMapIter(StrMapIter::*)(const Variant&))&StrMapIter::operator=;
    SimpleDataType::bindOperatorByName<decltype(assignOp)>("=", assignOp, "StrMapIter assign(Variant&)");

    bindCastOperator(Variant, &StrMapIter::operator Variant);
    bindCastOperator(int, &StrMapIter::operator int);

    // A bug switches ++/-- in version 20.0
    auto incOp = &StrMapIter::operator++;
    SimpleDataType::bindOperatorByName<decltype(incOp)>("--", incOp, "StrMapIter inc()");

    SimpleDataType::bindTypedPropertyByName<std::string>("key", "char*", force_cast<void*>(&StrMapIter::_getKey), nullptr);
    bindProperty(value, &StrMapIter::_getValue, &StrMapIter::_setValue);
  }
};

class TestMap : public SimpleDataType
{
private:
  StrMap map;

public:
  static TestMap* init(TreeNode* target) {
    TestMap* test = new TestMap();
    target->addSimpleData(test, 1);
    return test;
  }

  StrMapIter operator[](const char* key) {
    auto result = map.insert({ key, Variant() });
    return StrMapIter(result.first, map.end());
  }

  StrMapIter begin() {
    return StrMapIter(map.begin(), map.end());
  }

  StrMapIter find(const char* key) {
    return StrMapIter(map.find(key), map.end());
  }

  Array _getKeys() {
    Array k;
    for (const auto& pair : map) {
      k.push(pair.first);
    }
    return k;
  }
  __declspec(property(get = keys)) Array keys;
  
  const char* getClassFactory() override { return "Demo::TestMap"; }

  void bind() override
  {
    SimpleDataType::bind();
    
    // The rest of this code essentially does the same thing
    // as bindStlMap(), but using that directly introduced linker errors
    // When you save, you have to convert your structure to a tree,
    // and reverse the process when you load.
    TreeNode* mapNode;
    bindSubNodeByName("map", mapNode, 0);
    auto subnodes = mapNode->subnodes;

    int bindMode = getBindMode();
    
    if (bindMode == SDT_BIND_ON_LOAD) {
      for (int i = 1; i <= subnodes.length; i++) {
        map.insert({ subnodes[i]->name, subnodes[i]->value });
      }
    }

    if (bindMode == SDT_BIND_ON_SAVE) {
      for (const auto& pair : map) {
        subnodes._assert(pair.first.c_str())->value = pair.second;
      }
    } else {
      mapNode->destroy();
    }
  }

  void bindInterface() override {
    bindClass(StrMapIter);

    bindMethod(init, TestMap, "TestMap init(treenode target)", BIND_METHOD_STATIC);
    bindBracketOperator(StrMapIter, TestMap, const char*);
    bindMethod(find, TestMap, "StrMapIter find(char*)");
    bindMethod(begin, TestMap, "StrMapIter begin()");
    SimpleDataType::bindTypedPropertyByName<Array>("keys", "Array", force_cast<void*>(&TestMap::_getKeys), nullptr);
  }
};

If you set up your class this way, you can write code like the following:

treenode target = Model.find("Tools").subnodes.assert("map");
TestMap map = TestMap.init(target);
map["hi"] = "there";
string hello = "hello";
map[hello] = "world";

map["c"] = 10;
map["a"] = 20;
map["z"] = 30;

for (var iter = map.begin(); iter; iter++) {
  print(iter.key + ": ", iter.value);
}

This prints the values in the map in alphabetical order.