1 files changed, 1 insertions, 1 deletions

diff --git a/inputmethods/dasher/AlphabetMap.h b/inputmethods/dasher/AlphabetMap.h
index 3aac1f5..62f20d9 100644
--- a/inputmethods/dasher/AlphabetMap.h
+++ b/inputmethods/dasher/AlphabetMap.h
@@ -23,89 +23,89 @@ The result is this:
 ***************************************************
 very much thrown together to get Dasher out ASAP.
 ***************************************************
 It is deliberately not like an STL container.
 However, as it has a tiny interface, it should still be easy to replace.
 Sorry if this seems really unprofressional.
 
 Replacing it might be a good idea. On the other hand it could be customised
 to the needs of the alphabet, so that it works faster. For example,
 currently if I have a string "asdf", it might be that "a" is checked
 then "as" is checked then "asd" is checked. I shouldn't need to keep
 rehashing the leading characters. I plan to fix that here. Doing so with
 a standard hash_map would be hard.
 
 
 Usage:
 alphabet_map MyMap(NumberOfEntriesWeExpect); // Can omit NumberOfEntriesWeExpect
 MyMap.add("asdf", 15);
 symbol i = MyMap.get("asdf") // i=15
 symbol j = MyMap.get("fdsa") // j=0
 
 You can't remove items once they are added as Dasher has no need for that.
 
 IAM 08/2002
 */
 
 #ifndef __AlphabetMap_h__
 #define __AlphabetMap_h__
 
 #include "MSVC_Unannoy.h"
 #include <vector>
 #include <string>
 
 #include "DasherTypes.h"
 
 namespace Dasher {class alphabet_map;}
 class Dasher::alphabet_map
 {
 public:
         alphabet_map(uint InitialTableSize=255);
         void Add(const std::string& Key, symbol Value);
         symbol Get(const std::string& Key, bool* KeyIsPrefix=0) const;
         
 private:
         class Entry
         {
         public:
                 Entry(std::string Key, symbol Symbol, Entry* Next)
-                        : Key(Key), Symbol(Symbol), Next(Next), KeyIsPrefix(false) {}
+                        : Key(Key), KeyIsPrefix(false), Symbol(Symbol), Next(Next) {}
                 
                 std::string Key;
                 bool KeyIsPrefix;
                 symbol Symbol;
                 Entry* Next;
         };
         
         void RecursiveAdd(const std::string& Key, symbol Value, bool PrefixFlag);
         
         // A standard hash -- could try and research something specific.
         inline uint Hash(const std::string& Input) const {
                 uint Result = 0;
         
                 typedef std::string::const_iterator CI;
                 CI Cur = Input.begin();
                 CI end = Input.end();
                 
                 while (Cur!=end) Result = (Result<<1)^*Cur++;
                 Result %= HashTable.size();
                 
                 return Result;
                 /*
                 if (Input.size()==1) // Speedup for ASCII text
                         return Input[0];
                 
                 for (int i=0; i<Input.size(); i++)
                         Result = (Result<<1)^Input[i];
 
                 
                 return Result%HashTable.size();
                 */
         }
         
         std::vector<Entry> Entries;
         std::vector<Entry*> HashTable;
         const symbol Undefined;
 };
 
 
 #endif /* #ifndef __AlphabetMap_h__ */