1 /* 2 * Copyright 2009, Adrien Destugues, pulkomandy@gmail.com. 3 * Distributed under the terms of the MIT License. 4 */ 5 /* 6 * This file declares all the things we need to add to a catalog add-on to be 7 * able to use it in the developper tools (linkcatkeys, dumpcatalog, and the 8 * catalog editor, when we will have one. 9 */ 10 11 12 #ifndef _HASH_MAP_CATALOG_H_ 13 #define _HASH_MAP_CATALOG_H_ 14 15 16 #include <assert.h> 17 18 #include <CatalogData.h> 19 #include <HashMap.h> 20 #include <String.h> 21 22 23 namespace BPrivate { 24 25 /* 26 * The key-type for the hash_map which maps native strings or IDs to 27 * the corresponding translated string. 28 * The key-type should be efficient to use if it is just created by an ID 29 * but it should also support being created from up to three strings, 30 * which as a whole specify the key to the translated string. 31 */ 32 class CatKey { 33 public: 34 BString fString; 35 // The native string 36 BString fContext; 37 // The context of the string's usage 38 BString fComment; 39 // A comment that can be used to separate strings that 40 // are identical otherwise in the native language, but different in 41 // the translation (useful for the translator) 42 uint32 fHashVal; 43 // the hash-value of the key, computed from the three strings 44 uint32 fFlags; 45 // with respect to the catalog-editor, each translation can be 46 // in different states (empty, unchecked, checked, etc.). This 47 // state (and potential other flags) lives in the fFlags member. 48 49 public: 50 CatKey(const char *str, const char *ctx, const char *cmt); 51 CatKey(uint32 id); 52 CatKey(); 53 54 bool operator== (const CatKey& right) const; 55 bool operator!= (const CatKey& right) const; 56 status_t GetStringParts(BString* str, BString* ctx, BString* cmt) const; 57 static uint32 HashFun(const char* s, int startvalue = 0); 58 // The hash function is called 3 times, cumulating the 3 strings to 59 // calculate the key 60 uint32 GetHashCode() const { return fHashVal; } 61 }; 62 63 64 class HashMapCatalog: public BCatalogData { 65 protected: 66 uint32 ComputeFingerprint() const; 67 typedef HashMap<CatKey, BString> CatMap; 68 CatMap fCatMap; 69 70 public: 71 HashMapCatalog(const char* signature, const char* language, 72 uint32 fingerprint); 73 // Constructor for normal use 74 // 75 // overrides of BCatalogData: 76 const char *GetString(const char *string, const char *context = NULL, 77 const char *comment = NULL); 78 const char *GetString(uint32 id); 79 const char *GetString(const CatKey& key); 80 // 81 status_t SetString(const char *string, const char *translated, 82 const char *context = NULL, const char *comment = NULL); 83 status_t SetString(int32 id, const char *translated); 84 status_t SetString(const CatKey& key, const char *translated); 85 86 // implementation for editor-interface 87 virtual status_t ReadFromFile(const char *path = NULL) 88 {return B_NOT_SUPPORTED;} 89 virtual status_t ReadFromAttribute(const entry_ref &appOrAddOnRef) 90 {return B_NOT_SUPPORTED;} 91 virtual status_t ReadFromResource(const entry_ref &appOrAddOnRef) 92 {return B_NOT_SUPPORTED;} 93 virtual status_t WriteToFile(const char *path = NULL) 94 {return B_NOT_SUPPORTED;} 95 virtual status_t WriteToAttribute(const entry_ref &appOrAddOnRef) 96 {return B_NOT_SUPPORTED;} 97 virtual status_t WriteToResource(const entry_ref &appOrAddOnRef) 98 {return B_NOT_SUPPORTED;} 99 100 void UpdateFingerprint(); 101 // 102 void MakeEmpty(); 103 int32 CountItems() const; 104 105 /* 106 * CatWalker allows to walk trough all the strings stored in the 107 * catalog. We need that for dumpcatalog, linkcatkeys (to extract the 108 * data from the plaintext catalog) and in the catalog editor (to 109 * display the list of strings in a given catalog). 110 */ 111 class CatWalker { 112 public: 113 //CatWalker() {}; // if you use this there is no way to set fPos 114 // properly. 115 CatWalker(HashMapCatalog* catalog); 116 bool AtEnd() const; 117 const CatKey& GetKey() const; 118 const char *GetValue() const; 119 void Next(); 120 private: 121 CatMap::Iterator fPos; 122 CatMap::Entry current; 123 bool atEnd; 124 }; 125 friend class CatWalker; 126 status_t GetWalker(CatWalker *walker); 127 128 129 }; 130 131 132 inline HashMapCatalog::HashMapCatalog(const char* signature, 133 const char* language, uint32 fingerprint) 134 : 135 BCatalogData(signature, language, fingerprint) 136 { 137 } 138 139 140 inline 141 HashMapCatalog::CatWalker::CatWalker(HashMapCatalog* catalog) 142 : 143 fPos(catalog->fCatMap.GetIterator()) 144 { 145 if (fPos.HasNext()) { 146 current = fPos.Next(); 147 atEnd = false; 148 } else 149 atEnd = true; 150 } 151 152 153 inline bool 154 HashMapCatalog::CatWalker::AtEnd() const 155 { 156 return atEnd; 157 } 158 159 160 inline const CatKey & 161 HashMapCatalog::CatWalker::GetKey() const 162 { 163 assert(!atEnd); 164 return current.key; 165 } 166 167 168 inline const char * 169 HashMapCatalog::CatWalker::GetValue() const 170 { 171 assert(!atEnd); 172 return current.value.String(); 173 } 174 175 176 inline void 177 HashMapCatalog::CatWalker::Next() 178 { 179 if (fPos.HasNext()) { 180 current = fPos.Next(); 181 atEnd = false; 182 } else 183 atEnd = true; 184 } 185 186 187 inline status_t 188 HashMapCatalog::GetWalker(CatWalker *walker) 189 { 190 if (!walker) 191 return B_BAD_VALUE; 192 *walker = CatWalker(this); 193 return B_OK; 194 } 195 196 197 } // namespace BPrivate 198 199 #endif // _HASH_MAP_CATALOG_H_ 200