I have a function that does some weird stuff, and can't really change it to make life easier(due to how windows work, COM, etc..).

The function normally takes a string, a name, and does its think(which is the complex part that I can't change).

But I also want to overload it so the function takes an int. I can't simply overload the function and call the string version or vice versa as one would normally do because this would require initializing twice, which can't happen because the way the code works.

The int value is a lookup into an array, and the name version searches the array for a name match. I can't overload the int version and search the name first because the data doesn't exist yet

void Do(string name)
{
    // get index of name in array
// can't find x corresponding to name because data is not initialized. // Can't init data more than once. Can't add init flag(could but want to find a better solution)
    Do(x);
}

void Do(int index)
{
    Init_Data();
    ...
}



Now, I could simply make Do a template method but then this prevents it being a virtual function.

void Do(T)(T name) if (is(T == string) || is(T == int))
{
    Init_Data();

    static if (is(T == string))
    {
        ...Get index from name
    }

    ....
}



What I really want is a sort of mix between the first overloaded method and the second case.


The string version is really just finding the index of the string and should insert itself inside the int version similar to the static if.

I know there are many ways and many are going to fuss over doing it with a bool or duplicate the function or whatever. I'm looking for an elegant solution for what I want, I know there are other ways... not interested in them. Given that D has so many meta capabilities, I'm hoping there is some elegant solution.

To make it clear.

void Do(int index)
{
   // Does stuff

// If index was a string instead of a name, we would do a lookup to find the index for name. Everything else is exactly the same

   // does stuff with index
}

void Do(string name)
{
    // somehow
    Do(name_index);
}


Another way is to use a lambda:

void Do(int index, int delegate(data) toName)
{
    // Does stuff
    if (toName) index = toName(data);
    // Do stuff with index
}

void Do(string name)
{
    Do(0, (data) { find i for name; return i; });
    // which plugs in the lambda
}



The problem with all these ways is that they complicate matters and either duplicate a lot of code or create hard to maintain code or problems in other areas. e.g., if I use the template method any literal string is not automatically converted do("this won't be treated as a wstring").

If a bool is used, I have to have the initialization code in both functions. Doesn't seam like much until you scale the problem up.

What would be nice is something akin to yield:

void Do(int index)
{
    // Does stuff
?yield // If Do is called in a special way, we break out of the code here
    // Do stuff with index
}

void Do(string name)
{

    yield Do(0);
    find i for name;
    continue Do(i);
}


This keeps everything internal and from the outside everything looks as it should, avoids duplicate code, extra arguments, flags, etc.

Is it possible?






Reply via email to