In need of suggestions for a good way to structure priorities

[krainert]

Yeah, hi, and I don't even know if the title of this thread makes any sense of how to properly describe the issue... Anyway, here goes:

I have built a system enabling the issuing of forced orders which have priority over regular orders and are internally prioritized based on user-defined priority values.
Now I need to prescribe some guidelines for the use of these priority values. The thing is, I'm not sure which way is the best to structure them. Immediately I'm thinking recursive dichotomies with leaf trichotomies such as the following taxonomy of forced orders based on the nature of their motivation:

• [-6,-1] internal/psychological
  • [-6,-4] Controllable/conscious
    • -6 Weak
    • -5 Common
    • -4 Strong
  • [-3,-1] Uncontrollable/subconscious
    • -3 Weak
    • -2 Common
    • -1 Strong
• [1,6] external/physical
  • [1,3] Natural
    • 1 Weak
    • 2 Common
    • 3 Strong
  • [4,6] Magical
    • 4 Weak
    • 5 Common
    • 6 Strong

The actual content of such a structure might need to be different entirely, and I'm not even sure this way of structuring it will do... but... what do you think? Is there a clever way of doing it?

 

[Tyrulan]

I'm uncertain of what the JASS question is here. I might invert your tree though, such that your surface trait is always 'Weak,' 'Common,' or 'Strong.' I suppose it depends more on which you'd like to see more often, or obtain more easily.

 

[krainert]

Yeah, it's more of a structural question (or whichever category it falls under), but I figured JASS guys might have some experience from similar issues.
Never mind, though, I think I'll just throw it out there and see what happens. Most likely nobody will ever use my libraries anyway

 

[Tyrulan]

How would you use your taxonomy? Do you generate a random number? Or two, maybe three random numbers? More information would help in my helping you.

 

[krainert]

I'll get back to this as soon as I can. Thanks for the interest

 

[krainert]

Alright, that takes care of my exam.

To be exact, I'm making a system allowing one to enforce orders. Any forced order then has priority over regular orders.
However, to determine which forced order should be active, each forced order has a priority set at the time of enforcing. The currently forced order with the highest priority then applies.
Thus, anybody using the library will have to supply a priority value, and I need some way to make sense of them.
During the last weeks of writing, I came up with the following scheme, highest to lowest order bits:
categorization by significance from highest to lowest -- date of publishing of the specific dependent system -- hash of the specific dependent system's name -- manual clash prevention value (default 0, can be changed in the event of two larger systems randomly having otherwise exactly identical priorities).
Obviously, this is overkill, but I'd rather do it right since I can't really change the scheme later.
Makes sense?

 

[Tyrulan]

What happens when two priority orders are issued where the first has a higher priority than the second? (Assuming they are issued a few seconds apart.)

 

[krainert]

The second is ignored until the potential event of the first being cancelled while the second still applies.

 

[krainert]

So, basically, forced orders can be seen as a priority queue where the topmost element is always enforced.

 

[Tyrulan]

So - assigning a priority value as an integer provides an easy mechanism for deciding more urgent orders. What's wrong with maintaining a sorted data structure? It should be fairly easy to always obey the first order in the structure. Why all the extra elements which tend to complicate the question? What is their purpose and what are they trying to accomplish?

 

[krainert]

Since different people might theoretically use the system, different people will specify priorities for forced orders without knowing which priority values have already been taken... so I probably can't rely on a single data structure to make sense of priorities.
If you mean the implementation of the system, I've got priority value based library running already. To be exact, it uses a sorted linked hash map (which is probably not the most efficient structure, but it'll do) and then knows that the head is always the forced order with the highest priority.
My scheme doesn't really seem to make sense, though. The following should do:
User-defined priority values following some delicate system -- UNIX timestamp for some point of the release day of a dependent library, supplied by its coder
Makes sense? I hope it'll prevent clashes, but I'm still not sure exactly how to structure the user-defined priority settings... perhaps: non-magical internal/psychological -> magical internal/psychological -> non-magical external/physical -> magic external/physical. Then provide some room within each category for the user to supply indications of significance on a scale of, say, 1-3 or 1-9 or something. It's really hard to predict what would work best if people actually make use of the system Is this sensible?