header_policy.h revision c18510049a3422c88ed3ab3bbc64944c94a611fd 
1/*
2 * Copyright (C) 2013, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef LATINIME_HEADER_POLICY_H
18#define LATINIME_HEADER_POLICY_H
19
20#include <ctime>
21#include <stdint.h>
22
23#include "defines.h"
24#include "suggest/core/policy/dictionary_header_structure_policy.h"
25#include "suggest/policyimpl/dictionary/header/header_read_write_utils.h"
26#include "suggest/policyimpl/dictionary/utils/format_utils.h"
27
28namespace latinime {
29
30class HeaderPolicy : public DictionaryHeaderStructurePolicy {
31 public:
32    // Reads information from existing dictionary buffer.
33    HeaderPolicy(const uint8_t *const dictBuf, const int dictSize)
34            : mDictFormatVersion(FormatUtils::detectFormatVersion(dictBuf, dictSize)),
35              mDictionaryFlags(HeaderReadWriteUtils::getFlags(dictBuf)),
36              mSize(HeaderReadWriteUtils::getHeaderSize(dictBuf)),
37              mAttributeMap(createAttributeMapAndReadAllAttributes(dictBuf)),
38              mMultiWordCostMultiplier(readMultipleWordCostMultiplier()),
39              mIsDecayingDict(HeaderReadWriteUtils::readBoolAttributeValue(&mAttributeMap,
40                      IS_DECAYING_DICT_KEY, false /* defaultValue */)),
41              mLastUpdatedTime(HeaderReadWriteUtils::readIntAttributeValue(&mAttributeMap,
42                      LAST_UPDATED_TIME_KEY, time(0) /* defaultValue */)),
43              mUnigramCount(HeaderReadWriteUtils::readIntAttributeValue(&mAttributeMap,
44                      UNIGRAM_COUNT_KEY, 0 /* defaultValue */)),
45              mBigramCount(HeaderReadWriteUtils::readIntAttributeValue(&mAttributeMap,
46                      BIGRAM_COUNT_KEY, 0 /* defaultValue */)),
47              mExtendedRegionSize(HeaderReadWriteUtils::readIntAttributeValue(&mAttributeMap,
48                      EXTENDED_REGION_SIZE_KEY, 0 /* defaultValue */)) {}
49
50    // Constructs header information using an attribute map.
51    HeaderPolicy(const FormatUtils::FORMAT_VERSION dictFormatVersion,
52            const HeaderReadWriteUtils::AttributeMap *const attributeMap)
53            : mDictFormatVersion(dictFormatVersion),
54              mDictionaryFlags(HeaderReadWriteUtils::createAndGetDictionaryFlagsUsingAttributeMap(
55                      attributeMap)), mSize(0), mAttributeMap(*attributeMap),
56              mMultiWordCostMultiplier(readMultipleWordCostMultiplier()),
57              mIsDecayingDict(HeaderReadWriteUtils::readBoolAttributeValue(&mAttributeMap,
58                      IS_DECAYING_DICT_KEY, false /* defaultValue */)),
59              mLastUpdatedTime(HeaderReadWriteUtils::readIntAttributeValue(&mAttributeMap,
60                      LAST_UPDATED_TIME_KEY, time(0) /* defaultValue */)),
61              mUnigramCount(0), mBigramCount(0), mExtendedRegionSize(0) {}
62
63    ~HeaderPolicy() {}
64
65    AK_FORCE_INLINE int getSize() const {
66        return mSize;
67    }
68
69    AK_FORCE_INLINE bool supportsDynamicUpdate() const {
70        return HeaderReadWriteUtils::supportsDynamicUpdate(mDictionaryFlags);
71    }
72
73    AK_FORCE_INLINE bool requiresGermanUmlautProcessing() const {
74        return HeaderReadWriteUtils::requiresGermanUmlautProcessing(mDictionaryFlags);
75    }
76
77    AK_FORCE_INLINE bool requiresFrenchLigatureProcessing() const {
78        return HeaderReadWriteUtils::requiresFrenchLigatureProcessing(mDictionaryFlags);
79    }
80
81    AK_FORCE_INLINE float getMultiWordCostMultiplier() const {
82        return mMultiWordCostMultiplier;
83    }
84
85    AK_FORCE_INLINE bool isDecayingDict() const {
86        return mIsDecayingDict;
87    }
88
89    AK_FORCE_INLINE int getLastUpdatedTime() const {
90        return mLastUpdatedTime;
91    }
92
93    AK_FORCE_INLINE int getUnigramCount() const {
94        return mUnigramCount;
95    }
96
97    AK_FORCE_INLINE int getBigramCount() const {
98        return mBigramCount;
99    }
100
101    AK_FORCE_INLINE int getExtendedRegionSize() const {
102        return mExtendedRegionSize;
103    }
104
105    void readHeaderValueOrQuestionMark(const char *const key,
106            int *outValue, int outValueSize) const;
107
108    bool writeHeaderToBuffer(BufferWithExtendableBuffer *const bufferToWrite,
109            const bool updatesLastUpdatedTime, const int unigramCount,
110            const int bigramCount, const int extendedRegionSize) const;
111
112 private:
113    DISALLOW_IMPLICIT_CONSTRUCTORS(HeaderPolicy);
114
115    static const char *const MULTIPLE_WORDS_DEMOTION_RATE_KEY;
116    static const char *const IS_DECAYING_DICT_KEY;
117    static const char *const LAST_UPDATED_TIME_KEY;
118    static const char *const UNIGRAM_COUNT_KEY;
119    static const char *const BIGRAM_COUNT_KEY;
120    static const char *const EXTENDED_REGION_SIZE_KEY;
121    static const int DEFAULT_MULTIPLE_WORDS_DEMOTION_RATE;
122    static const float MULTIPLE_WORD_COST_MULTIPLIER_SCALE;
123
124    const FormatUtils::FORMAT_VERSION mDictFormatVersion;
125    const HeaderReadWriteUtils::DictionaryFlags mDictionaryFlags;
126    const int mSize;
127    HeaderReadWriteUtils::AttributeMap mAttributeMap;
128    const float mMultiWordCostMultiplier;
129    const bool mIsDecayingDict;
130    const int mLastUpdatedTime;
131    const int mUnigramCount;
132    const int mBigramCount;
133    const int mExtendedRegionSize;
134
135    float readMultipleWordCostMultiplier() const;
136
137    static HeaderReadWriteUtils::AttributeMap createAttributeMapAndReadAllAttributes(
138            const uint8_t *const dictBuf);
139};
140} // namespace latinime
141#endif /* LATINIME_HEADER_POLICY_H */
142