rime Namespace Reference

Namespaces
namespace	algo
namespace	corrector
namespace	dictionary
namespace	filesystem
namespace	prism
namespace	reverse
namespace	strings
namespace	table

Classes
class	Abbreviation
class	AbcSegmentor
class	AffixSegmentor
struct	Array
class	AsciiComposer
struct	AsciiModeSwitchStyleDefinition
class	AsciiSegmentor
class	AutoPatchConfigPlugin
class	BackupConfigFiles
struct	BeamSearch
class	BuildInfoPlugin
class	CacheTranslation
class	Calculation
class	Calculus
class	Candidate
class	CharsetFilter
class	CharsetFilterTranslation
class	ChecksumComputer
class	ChordComposer
struct	ChordingState
struct	Class
class	CleanOldLogFiles
class	CleanupTrash
class	Code
struct	CodeCoords
struct	CommitEntry
class	CommitHistory
struct	CommitRecord
struct	Component
class	ComponentBase
class	Composition
class	ConcreteEngine
class	Config
class	ConfigBuilder
class	ConfigCompiler
class	ConfigCompilerPlugin
class	ConfigComponent
class	ConfigComponentBase
class	ConfigCowRef
class	ConfigData
class	ConfigDataRootRef
struct	ConfigDependencyGraph
class	ConfigFileUpdate
class	ConfigItem
class	ConfigItemRef
class	ConfigList
class	ConfigListEntryRef
class	ConfigLoader
class	ConfigMap
class	ConfigMapEntryRef
struct	ConfigResource
struct	ConfigResourceProvider
class	ConfigValue
class	Context
class	ContextualTranslation
class	Correction
class	Corrector
class	CorrectorComponent
class	Customizer
class	CustomSettings
class	Db
class	DbAccessor
class	DbComponent
class	DbComponentBase
class	DbPool
class	DbSink
class	DbSource
class	DefaultConfigPlugin
struct	Dependency
struct	DeployedConfigResourceProvider
class	Deployer
class	DeploymentTask
class	deque
	STL class. More...
class	Derivation
class	DetectModifications
struct	DfsState
class	DictCompiler
struct	DictEntry
class	DictEntryFilterBinder
class	DictEntryIterator
class	DictEntryList
class	Dictionary
class	DictionaryComponent
class	DictSettings
class	DistinctTranslation
struct	DynamicProgramming
class	EchoTranslation
class	EchoTranslator
struct	EdgeProperties
class	EditDistanceCorrector
class	Editor
struct	EditorCharHandlerDef
class	Encoder
class	Engine
class	EntryCollector
class	Erasion
class	ExpressEditor
class	FallbackResourceResolver
class	FallbackSegmentor
class	FifoTranslation
class	Filter
class	FluidEditor
class	FoldedOptions
class	Formatter
class	Fuzzing
class	Grammar
class	HistoryTranslator
struct	IncludeReference
class	InstallationUpdate
class	KeyBinder
struct	KeyBinding
struct	KeyBindingConditionDef
class	KeyBindingConditions
class	KeyBindingProcessor
class	KeyBindings
class	KeyEvent
class	KeySequence
class	Language
class	LazyTableTranslation
class	LegacyDictionaryConfigPlugin
class	LegacyPresetConfigPlugin
class	LevelDb
class	LevelDbAccessor
struct	LevelDbCursor
struct	LevelDbWrapper
struct	Line
struct	List
class	list
	STL class. More...
class	map
	STL class. More...
class	MappedFile
class	MappedFileImpl
class	Matcher
class	Memory
class	Menu
class	MergedTranslation
class	Messenger
class	ModuleManager
struct	MultiplePlugins
class	Navigator
class	NearSearchCorrector
class	OffsetPtr
class	Opencc
struct	Page
class	pair
	STL class. More...
struct	PatchLiteral
struct	PatchReference
class	path
class	Patterns
struct	PendingChild
class	Phrase
class	PhraseCollector
class	PhraseSyllabifier
class	Poet
class	PrebuildAllSchemas
struct	Preedit
class	PrefetchTranslation
class	PresetVocabulary
class	Prism
class	Processor
class	Projection
class	PunctConfig
class	PunctSegmentor
class	PunctTranslator
class	Punctuator
class	RadioGroup
class	RadioOption
class	RawCode
struct	RawDictEntry
class	Recognizer
struct	RecognizerMatch
class	RecognizerPatterns
class	Recoverable
struct	Reference
class	Registry
class	ResourceResolver
struct	ResourceType
class	ReverseDb
class	ReverseLookupDictionary
class	ReverseLookupDictionaryComponent
class	ReverseLookupFilter
class	ReverseLookupFilterTranslation
class	ReverseLookupTranslation
class	ReverseLookupTranslator
class	SaveOutputPlugin
class	Schema
class	SchemaAction
class	SchemaComponent
struct	SchemaInfo
class	SchemaListTranslation
class	SchemaListTranslator
class	SchemaSelection
class	SchemaUpdate
class	Script
class	ScriptEncoder
class	ScriptSyllabifier
class	ScriptTranslation
class	ScriptTranslator
struct	Segment
class	Segmentation
class	Segmentor
class	Selector
class	Sentence
class	SentenceSyllabifier
class	SentenceTranslation
class	Service
class	Session
class	set
	STL class. More...
class	ShadowCandidate
class	ShapeFormatter
class	ShapeProcessor
struct	ShortDictEntry
class	ShortDictEntryList
class	Signature
class	SimpleCandidate
class	SimplifiedTranslation
class	Simplifier
class	SimplifierComponent
class	SingleCharFilter
class	SingleCharFirstTranslation
class	Sink
class	Source
class	Spans
class	Speller
struct	Spelling
class	SpellingAccessor
struct	SpellingProperties
class	StableDb
struct	String
class	string
	STL class. More...
struct	StringSlice
class	StringTable
class	StringTableBuilder
class	Switch
class	Switcher
class	SwitcherCommand
class	SwitcherSettings
class	Switches
class	SwitchTranslation
class	SwitchTranslator
class	Syllabifier
struct	SyllableGraph
class	SymDeleteCollector
class	SymlinkingPrebuiltDictionaries
class	Table
class	TableAccessor
class	TableDb
class	TableEncoder
struct	TableEncodingRule
class	TableQuery
class	TableTranslation
class	TableTranslator
class	TagMatching
class	TextDb
class	TextDbAccessor
struct	TextFormat
struct	Ticket
class	Transactional
class	Transformation
class	Translation
class	Translator
class	TranslatorOptions
class	Transliteration
class	TsvReader
class	TsvWriter
class	UnionTranslation
class	UniqueTranslation
class	UniquifiedCandidate
class	UniquifiedTranslation
class	Uniquifier
class	UnityTableEncoder
struct	UserConfigResourceProvider
class	UserDb
class	UserDbComponent
	Implements a component that serves as a factory for a user db class. More...
class	UserDbHelper
	A helper class to provide extra functionalities related to user db. More...
class	UserDbImporter
class	UserDbMerger
class	UserDbRecoveryTask
class	UserDbRecoveryTaskComponent
struct	UserDbValue
	Properties of a user db entry value. More...
class	UserDbWrapper
	A template to define a user db class based on an implementation of rime::Db. More...
class	UserDictEntryIterator
class	UserDictionary
class	UserDictionaryComponent
class	UserDictManager
class	UserDictSync
class	UserDictUpgrade
class	vector
	STL class. More...
class	Vocabulary
struct	VocabularyDb
struct	VocabularyPage
class	Voidify
class	VoidLogger
class	WorkspaceUpdate

Typedefs
using	Vertex = pair<size_t, SpellingType>
using	VertexQueue
using	SyllableId = int32_t
using	SpellingMap = map<SyllableId, EdgeProperties>
using	VertexMap = map<size_t, SpellingType>
using	EndVertexMap = map<size_t, SpellingMap>
using	EdgeMap = map<size_t, EndVertexMap>
using	SpellingPropertiesList = vector<const EdgeProperties*>
using	SpellingIndex = map<SyllableId, SpellingPropertiesList>
using	SpellingIndices = map<size_t, SpellingIndex>
using	CandidateQueue = list<of<Candidate>>
using	CandidateList = vector<of<Candidate>>
template<class Key, class T>
using	hash_map = boost::unordered_map<Key, T>
template<class T>
using	hash_set = boost::unordered_set<T>
template<class T>
using	the = std::unique_ptr<T>
template<class T>
using	an = std::shared_ptr<T>
template<class T>
using	of = an<T>
template<class T>
using	weak = std::weak_ptr<T>
using	TaskInitializer = std::any
using	DictEntryCollector = map<size_t, DictEntryIterator>
using	WeightMap = map<string, double>
using	WordMap = hash_map<string, vector<pair<string, double>>>
using	EncodeQueue = std::queue<pair<string, string>>
using	StringId = std::uint32_t
using	TableQueryResult = map<int, vector<TableAccessor>>
using	TextDbData = map<string, string>
using	Tsv = vector<string>
using	TsvParser = function<bool(const Tsv& row, string* key, string* value)>
using	TsvFormatter
using	TickCount = uint64_t
using	UserDictEntryCollector = map<size_t, UserDictEntryIterator>
using	Syllabary = set<string>
using	DictEntryFilter = function<bool(an<DictEntry> entry)>
using	ReverseLookupTable = hash_map<string, set<string>>
using	AsciiModeSwitchKeyBindings = map<int , AsciiModeSwitchStyle>
using	Chord = set<int>
using	LineCandidates = hash_map<string, Line>
using	UpdateLineCandidate = function<void(const Line& candidate)>
using	WordGraph = map<int, map<int, DictEntryList>>
using	SwitchOption = Switches::SwitchOption
using	UserDictList = vector<string>
using	SessionId = uintptr_t
using	NotificationHandler

Enumerations
enum	SpellingType {   kNormalSpelling , kFuzzySpelling , kAbbreviation , kCompletion ,   kAmbiguousSpelling , kInvalidSpelling }
enum	DependencyPriority { kPendingChild = 0 , kInclude = 1 , kPatch = 2 }
enum	AsciiModeSwitchStyle {   kAsciiModeSwitchNoop , kAsciiModeSwitchInline , kAsciiModeSwitchCommitText , kAsciiModeSwitchCommitCode ,   kAsciiModeSwitchClear , kAsciiModeSet , kAsciiModeUnset }
enum	KeyBindingCondition {   kNever , kWhenPredicting , kWhenPaging , kWhenHasMenu ,   kWhenComposing , kAlways }
enum	ProcessResult { kRejected , kAccepted , kNoop }

Functions
int	CompareVersionString (const string &x, const string &y)
uint32_t	Checksum (const path &file_path)
template<class X, class Y>
an< X >	As (const an< Y > &ptr)
template<class X, class Y>
bool	Is (const an< Y > &ptr)
template<class T, class... Args>
an< T >	New (Args &&... args)
std::ostream &	operator<< (std::ostream &stream, const Reference &reference)
std::ostream &	operator<< (std::ostream &stream, const Dependency &dependency)
an< ConfigItemRef >	TypeCheckedCopyOnWrite (an< ConfigItemRef > parent, const string &key)
an< ConfigItemRef >	TraverseCopyOnWrite (an< ConfigItemRef > head, const string &path)
an< ConfigItemRef >	Cow (an< ConfigItemRef > parent, string key)
an< ConfigItem >	ConvertFromYaml (const YAML::Node &yaml_node, ConfigCompiler *compiler)
void	EmitYaml (an< ConfigItem > node, YAML::Emitter *emitter, int depth)
void	EmitScalar (const string &str_value, YAML::Emitter *emitter)
template<class SinkType>
int	operator<< (SinkType &sink, TsvReader &reader)
template<class SinkType>
int	operator>> (TsvReader &reader, SinkType &sink)
template<class SourceType>
int	operator<< (TsvWriter &writer, SourceType &source)
template<class SourceType>
int	operator>> (SourceType &source, TsvWriter &writer)
template<class T>
bool	dereference_less (const T &a, const T &b)
template<typename C>
void	sort (C &container)
template<typename C>
void	sort_range (C &container, size_t start, size_t count)
template<typename T>
void	CreateComponentsFromList (Engine *engine, Config *config, const string &config_key, const string &component_type, vector< an< T > > &target_collection)
bool	is_extended_cjk (uint32_t ch)
bool	contains_extended_cjk (const string &text)
an< Candidate >	CreatePunctCandidate (const string &punct, const Segment &segment)
std::ostream &	operator<< (std::ostream &out, const KeyEvent &key_event)
std::ostream &	operator<< (std::ostream &out, const KeySequence &key_seq)
std::ostream &	operator<< (std::ostream &out, const Segmentation &segmentation)
RIME_DLL	RIME_MODULE_LIST (kDefaultModules, "default" RIME_EXTRA_MODULES)
RIME_DLL	RIME_MODULE_LIST (kDeployerModules, "deployer")
	RIME_MODULE_LIST (kLegacyModules, "legacy")
RIME_DLL void	LoadModules (const char *module_names[])
RIME_DLL void	SetupDeployer (RimeTraits *traits)
RIME_DLL void	SetupLogging (const char *app_name, int min_log_level, const char *log_dir)
RIME_DLL void	SetupLogging (const char *app_name)
an< UnionTranslation >	operator+ (an< Translation > x, an< Translation > y)
template<class T, class... Args>
an< Translation >	Cached (Args &&... args)

Variables
const double	kAbbreviationPenalty = -0.6931471805599453
const double	kFuzzySpellingPenalty = -0.6931471805599453
const double	kCorrectionPenalty = -4.605170185988091
const double	kCompletionPenalty = -2.995732273553991
const double	kCorrectionCredibility = -4.605170185988091
const string	kSelectedBeforeEditing = "selected_before_editing"
const char	kPrismFormat [] = "Rime::Prism/4.0"
const double	kPrismFormatVersion = 4.0
const char	kPrismFormatPrefix [] = "Rime::Prism/"
const size_t	kPrismFormatPrefixLen = sizeof(kPrismFormatPrefix) - 1
const char	kDefaultAlphabet [] = "abcdefghijklmnopqrstuvwxyz"
const char	kReverseFormat [] = "Rime::Reverse/3.1"
const double	kReverseFormatCompatible = 3.0
const char	kReverseFormatPrefix [] = "Rime::Reverse/"
const size_t	kReverseFormatPrefixLen = sizeof(kReverseFormatPrefix) - 1
const StringId	kInvalidStringId = (StringId)(-1)
const char	kTableFormatLatest [] = "Rime::Table/4.0"
const int	kTableFormatLowestCompatible = 4.0
const char	kTableFormatPrefix [] = "Rime::Table/"
const size_t	kTableFormatPrefixLen = sizeof(kTableFormatPrefix) - 1
const double	kPenaltyForAmbiguousSyllable = -2.995732274
const int	kContextualSearchLimit = 32
template<class T, int N>
const KeyBindingProcessor< T, N >::ActionDef	KeyBindingProcessor< T, N >::kActionNoop = {"noop", nullptr}
RIME_DLL const char *	kDefaultModules []
RIME_DLL const char *	kDeployerModules []
const char *	kLegacyModules []

Typedef Documentation

an

template<class T>

using rime::an = std::shared_ptr<T>

AsciiModeSwitchKeyBindings

using rime::AsciiModeSwitchKeyBindings = map<int , AsciiModeSwitchStyle>

CandidateList

using rime::CandidateList = vector<of<Candidate>>

CandidateQueue

using rime::CandidateQueue = list<of<Candidate>>

Chord

using rime::Chord = set<int>

DictEntryCollector

using rime::DictEntryCollector = map<size_t, DictEntryIterator>

DictEntryFilter

using rime::DictEntryFilter = function<bool(an<DictEntry> entry)>

EdgeMap

using rime::EdgeMap = map<size_t, EndVertexMap>

EncodeQueue

using rime::EncodeQueue = std::queue<pair<string, string>>

EndVertexMap

using rime::EndVertexMap = map<size_t, SpellingMap>

hash_map

template<class Key, class T>

using rime::hash_map = boost::unordered_map<Key, T>

hash_set

template<class T>

using rime::hash_set = boost::unordered_set<T>

LineCandidates

using rime::LineCandidates = hash_map<string, Line>

NotificationHandler

using rime::NotificationHandler

Initial value:

function<void(SessionId session_id,
                                         const char* message_type,
                                         const char* message_value)>

of

template<class T>

using rime::of = an<T>

ReverseLookupTable

using rime::ReverseLookupTable = hash_map<string, set<string>>

SessionId

using rime::SessionId = uintptr_t

SpellingIndex

using rime::SpellingIndex = map<SyllableId, SpellingPropertiesList>

SpellingIndices

using rime::SpellingIndices = map<size_t, SpellingIndex>

SpellingMap

using rime::SpellingMap = map<SyllableId, EdgeProperties>

SpellingPropertiesList

using rime::SpellingPropertiesList = vector<const EdgeProperties*>

StringId

using rime::StringId = std::uint32_t

SwitchOption

using rime::SwitchOption = Switches::SwitchOption

Syllabary

using rime::Syllabary = set<string>

SyllableId

using rime::SyllableId = int32_t

TableQueryResult

using rime::TableQueryResult = map<int, vector<TableAccessor>>

TaskInitializer

using rime::TaskInitializer = std::any

TextDbData

using rime::TextDbData = map<string, string>

the

template<class T>

using rime::the = std::unique_ptr<T>

TickCount

using rime::TickCount = uint64_t

Tsv

using rime::Tsv = vector<string>

TsvFormatter

using rime::TsvFormatter

Initial value:

 
function<bool(const string& key, const string& value, Tsv* row)>

TsvParser

using rime::TsvParser = function<bool(const Tsv& row, string* key, string* value)>

UpdateLineCandidate

using rime::UpdateLineCandidate = function<void(const Line& candidate)>

UserDictEntryCollector

using rime::UserDictEntryCollector = map<size_t, UserDictEntryIterator>

UserDictList

using rime::UserDictList = vector<string>

Vertex

using rime::Vertex = pair<size_t, SpellingType>

VertexMap

using rime::VertexMap = map<size_t, SpellingType>

VertexQueue

using rime::VertexQueue

Initial value:

 
std::priority_queue<Vertex, vector<Vertex>, std::greater<Vertex>>

weak

template<class T>

using rime::weak = std::weak_ptr<T>

WeightMap

using rime::WeightMap = map<string, double>

WordGraph

using rime::WordGraph = map<int, map<int, DictEntryList>>

WordMap

using rime::WordMap = hash_map<string, vector<pair<string, double>>>

Enumeration Type Documentation

AsciiModeSwitchStyle

enum rime::AsciiModeSwitchStyle

Enumerator
kAsciiModeSwitchNoop
kAsciiModeSwitchInline
kAsciiModeSwitchCommitText
kAsciiModeSwitchCommitCode
kAsciiModeSwitchClear
kAsciiModeSet
kAsciiModeUnset

DependencyPriority

enum rime::DependencyPriority

Enumerator
kPendingChild
kInclude
kPatch

KeyBindingCondition

enum rime::KeyBindingCondition

Enumerator
kNever
kWhenPredicting
kWhenPaging
kWhenHasMenu
kWhenComposing
kAlways

ProcessResult

enum rime::ProcessResult

Enumerator
kRejected
kAccepted
kNoop

SpellingType

enum rime::SpellingType

Enumerator
kNormalSpelling
kFuzzySpelling
kAbbreviation
kCompletion
kAmbiguousSpelling
kInvalidSpelling

Function Documentation

As()

template<class X, class Y>

an< X > rime::As ( const an< Y > & ptr )

inline

Cached()

template<class T, class... Args>

an< Translation > rime::Cached ( Args &&... args )

inline

Checksum()

uint32_t rime::Checksum ( const path & file_path )

inline

CompareVersionString()

int rime::CompareVersionString	(	const string &	x,
		const string &	y )

contains_extended_cjk()

bool rime::contains_extended_cjk

(

const string &

text

)

ConvertFromYaml()

an< ConfigItem > rime::ConvertFromYaml	(	const YAML::Node &	yaml_node,
		ConfigCompiler *	compiler )

Cow()

an< ConfigItemRef > rime::Cow ( an< ConfigItemRef > parent, string key )

inline

CreateComponentsFromList()

template<typename T>

void rime::CreateComponentsFromList ( Engine * engine, Config * config, const string & config_key, const string & component_type, vector< an< T > > & target_collection )

inline

CreatePunctCandidate()

an< Candidate > rime::CreatePunctCandidate	(	const string &	punct,
		const Segment &	segment )

dereference_less()

template<class T>

bool rime::dereference_less ( const T & a, const T & b )

inline

EmitScalar()

void rime::EmitScalar	(	const string &	str_value,
		YAML::Emitter *	emitter )

EmitYaml()

void rime::EmitYaml	(	an< ConfigItem >	node,
		YAML::Emitter *	emitter,
		int	depth )

Is()

template<class X, class Y>

bool rime::Is ( const an< Y > & ptr )

inline

is_extended_cjk()

bool rime::is_extended_cjk

(

uint32_t

ch

)

LoadModules()

RIME_DLL void rime::LoadModules

(

const char *

module_names[]

)

New()

template<class T, class... Args>

an< T > rime::New ( Args &&... args )

inline

operator+()

an< UnionTranslation > rime::operator+	(	an< Translation >	x,
		an< Translation >	y )

operator<<() [1/7]

template<class SinkType>

int rime::operator<<	(	SinkType &	sink,
		TsvReader &	reader )

operator<<() [2/7]

std::ostream & rime::operator<< ( std::ostream & out, const KeyEvent & key_event )

inline

operator<<() [3/7]

std::ostream & rime::operator<< ( std::ostream & out, const KeySequence & key_seq )

inline

operator<<() [4/7]

std::ostream & rime::operator<<	(	std::ostream &	out,
		const Segmentation &	segmentation )

operator<<() [5/7]

std::ostream & rime::operator<<	(	std::ostream &	stream,
		const Dependency &	dependency )

operator<<() [6/7]

std::ostream & rime::operator<<	(	std::ostream &	stream,
		const Reference &	reference )

operator<<() [7/7]

template<class SourceType>

int rime::operator<<	(	TsvWriter &	writer,
		SourceType &	source )

operator>>() [1/2]

template<class SourceType>

int rime::operator>>	(	SourceType &	source,
		TsvWriter &	writer )

operator>>() [2/2]

template<class SinkType>

int rime::operator>>	(	TsvReader &	reader,
		SinkType &	sink )

RIME_MODULE_LIST() [1/3]

RIME_DLL rime::RIME_MODULE_LIST	(	kDefaultModules	,
		"default"	RIME_EXTRA_MODULES )

RIME_MODULE_LIST() [2/3]

RIME_DLL rime::RIME_MODULE_LIST	(	kDeployerModules	,
		"deployer"	)

RIME_MODULE_LIST() [3/3]

rime::RIME_MODULE_LIST	(	kLegacyModules	,
		"legacy"	)

SetupDeployer()

RIME_DLL void rime::SetupDeployer

(

RimeTraits *

traits

)

SetupLogging() [1/2]

RIME_DLL void rime::SetupLogging

(

const char *

app_name

)

SetupLogging() [2/2]

RIME_DLL void rime::SetupLogging	(	const char *	app_name,
		int	min_log_level,
		const char *	log_dir )

sort()

template<typename C>

void rime::sort ( C & container )

inline

sort_range()

template<typename C>

void rime::sort_range ( C & container, size_t start, size_t count )

inline

TraverseCopyOnWrite()

an< ConfigItemRef > rime::TraverseCopyOnWrite	(	an< ConfigItemRef >	head,
		const string &	path )

TypeCheckedCopyOnWrite()

an< ConfigItemRef > rime::TypeCheckedCopyOnWrite	(	an< ConfigItemRef >	parent,
		const string &	key )

Variable Documentation

kAbbreviationPenalty

const double rime::kAbbreviationPenalty = -0.6931471805599453

kCompletionPenalty

const double rime::kCompletionPenalty = -2.995732273553991

kContextualSearchLimit

const int rime::kContextualSearchLimit = 32

kCorrectionCredibility

const double rime::kCorrectionCredibility = -4.605170185988091

kCorrectionPenalty

const double rime::kCorrectionPenalty = -4.605170185988091

kDefaultAlphabet

const char rime::kDefaultAlphabet[] = "abcdefghijklmnopqrstuvwxyz"

kDefaultModules

RIME_DLL const char* rime::kDefaultModules[]

extern

kDeployerModules

RIME_DLL const char* rime::kDeployerModules[]

extern

KeyBindingProcessor< T, N >::kActionNoop

template<class T, int N>

const KeyBindingProcessor<T,N>::ActionDef rime::KeyBindingProcessor< T, N >::kActionNoop = {"noop", nullptr}

kFuzzySpellingPenalty

const double rime::kFuzzySpellingPenalty = -0.6931471805599453

kInvalidStringId

const StringId rime::kInvalidStringId = (StringId)(-1)

kLegacyModules

const char* rime::kLegacyModules[]

extern

kPenaltyForAmbiguousSyllable

const double rime::kPenaltyForAmbiguousSyllable = -2.995732274

kPrismFormat

const char rime::kPrismFormat[] = "Rime::Prism/4.0"

kPrismFormatPrefix

const char rime::kPrismFormatPrefix[] = "Rime::Prism/"

kPrismFormatPrefixLen

const size_t rime::kPrismFormatPrefixLen = sizeof(kPrismFormatPrefix) - 1

kPrismFormatVersion

const double rime::kPrismFormatVersion = 4.0

kReverseFormat

const char rime::kReverseFormat[] = "Rime::Reverse/3.1"

kReverseFormatCompatible

const double rime::kReverseFormatCompatible = 3.0

kReverseFormatPrefix

const char rime::kReverseFormatPrefix[] = "Rime::Reverse/"

kReverseFormatPrefixLen

const size_t rime::kReverseFormatPrefixLen = sizeof(kReverseFormatPrefix) - 1

kSelectedBeforeEditing

const string rime::kSelectedBeforeEditing = "selected_before_editing"

kTableFormatLatest

const char rime::kTableFormatLatest[] = "Rime::Table/4.0"

kTableFormatLowestCompatible

const int rime::kTableFormatLowestCompatible = 4.0

kTableFormatPrefix

const char rime::kTableFormatPrefix[] = "Rime::Table/"

kTableFormatPrefixLen

const size_t rime::kTableFormatPrefixLen = sizeof(kTableFormatPrefix) - 1