void Sentence::complete(const Dict& book){
int a =0;
int b=0;
int max;
max = book.getlength(3);
cout<<"Sentence completion for: "<<input<<"\n";
cout<<"--------------------------------"<<"\n";
while(a < max){
int counter = 1;
input2 = book.lookup(3, a);
for(int i=0; i < input.length()-1; i++){ //for loop that flags counter as zero if beginning is not the same
if(input[i] != input2[i]){
counter = 0;
break;
}
}
if(counter == 1){
cout<<input2<<"\n";
b++;
}
a++;
}
if(b == 0){
cout<<"no completion found \n";
}
}
void ff::Dict::Merge(const Dict &rhs)
{
for (StringRef name: rhs.GetAllNames())
{
Value *value = rhs.GetValue(name);
ff::ValuePtr newValue;
if (value->IsType(ff::Value::Type::Dict) ||
value->IsType(ff::Value::Type::SavedDict))
{
Value *myValue = GetValue(name);
if (myValue && (myValue->IsType(ff::Value::Type::Dict) ||
myValue->IsType(ff::Value::Type::SavedDict)))
{
ff::ValuePtr dictValue, myDictValue;
if (value->Convert(ff::Value::Type::Dict, &dictValue) &&
myValue->Convert(ff::Value::Type::Dict, &myDictValue))
{
Dict myDict = myDictValue->AsDict();
myDict.Merge(dictValue->AsDict());
if (ff::Value::CreateDict(std::move(myDict), &newValue))
{
value = newValue;
}
}
}
}
SetValue(name, value);
}
}
//Conta o numero de palavras no arquivo
void count_words() {
totalPalavras=0;
int dictShortQtd=0;
int dictCompoundQtd=0;
char *pch = strtok (text, "\n");
int length;
for(int i=0; i<6; i++)
qtd_palavra[i] = 0;
while(pch != NULL){
length = strlen(pch);
if(length <= 5) {
qtd_palavra[length]++;
dictShortQtd++;
} else
dictCompoundQtd++;
totalPalavras++;
pch = strtok (NULL, "\n");
}
shortDict.init(dictShortQtd, MAX_SHORT_SIZE);
compoundDict.init(dictCompoundQtd, MAX_COMPOUND_SIZE);
}
ImportInfo::ImportInfo( Dict & attrs ) :
attrs( attrs )
{
Dict::iterator it = attrs.find( FROM );
if ( it == attrs.end() ) {
throw Mishap( "Missing attribute in import" ).culprit( "Attribute", FROM );
}
this->from = it->second;
set< string > matches;
set< string > intos;
for (
Dict::iterator it = attrs.begin();
it != attrs.end();
++it
) {
if ( it->first.compare( 0, MATCH_SIZE, MATCH ) == 0 ) {
matches.insert( it->second );
} else if ( it->first.compare( 0, INTO_SIZE, INTO ) == 0 ) {
intos.insert( it->second );
}
}
this->match_tags = fetchFacetSet( matches );
this->into_tags = fetchFacetSet( intos );
}
Dict* Track::player(Dict *d, bool fallback) const{
Dict *p = d->AddIncludeDictionary("PLAYER");
p->SetFilename("html/player.tpl");
fill(p);
p->SetIntValue("LIST", id);
if(fallback) p->ShowSection("FALLBACK");
return p;
}
Dict Options::sanitize(const Dict& opts) {
// Drop nulls
if (has_null(opts)) {
// Create a new dictionary without the null entries
Dict ret;
for (auto&& op : opts) {
if (!op.second.is_null()) ret[op.first] = op.second;
}
return ret;
}
// Treat the case where any of the options have a dot (dictionary shorthand)
if (has_dot(opts)) {
// New options dictionary being constructed
Dict ret;
// Sub-dictionary and corresponding name being constructed
Dict sopts;
std::string sname;
// Process options
for (auto&& op : opts) {
// Find the dot if any
string::size_type dotpos = op.first.find('.'), dotpos_end;
if (dotpos==string::npos) {
dotpos = op.first.find("__");
if (dotpos!=string::npos) dotpos_end = dotpos+2;
} else {
dotpos_end = dotpos+1;
}
// Flush last sub-dictionary
if (!sname.empty() && (dotpos==string::npos
|| op.first.compare(0, dotpos, sname)!=0)) {
ret[sname] = sopts;
sname.clear();
sopts.clear();
}
// Add to dictionary
if (dotpos != string::npos) {
sname = op.first.substr(0, dotpos);
sopts[op.first.substr(dotpos_end)] = op.second;
} else {
ret[op.first] = op.second;
}
}
// Flush trailing sub-dictionary
if (!sname.empty()) ret[sname] = sopts;
return ret;
}
// Nothing to do
return opts;
}
LLBC_Variant::LLBC_Variant(const Dict &dictVal)
{
_holder.type = LLBC_VariantType::VT_DICT_DFT;
if (!dictVal.empty())
{
_holder.dict= new Dict();
_holder.dict->insert(dictVal.begin(), dictVal.end());
}
}
int main (){
cout << boolalpha;
// constructor
Dict<string,long> d;
// add
d.add("bill", 10);
d.add("rich", 20);
// output
cout << d << endl << endl;
//copy
Dict<string,long> d2(d);
cout << d2 << endl << endl;
// add to existing key
d2.add("bill", 100);
// copy working?
cout << d << endl << endl;
cout << d2 << endl << endl;
cout << "CHECK THIS ^^" << endl;
// exists
cout << "Exists bill:"<<d.exists("bill")<<endl;
cout << "Exists john:"<<d.exists("john")<<endl;
// get_value
cout << "Value of bill:"<<d.get_value("bill")<<endl;
// get_value throws on bad key
try{
d.get_value("john");
}
catch (range_error &e){
cout << "bad get_value "<<e.what()<<endl;
}
// make the array grow
d.add("fred", 30);
d.add("bob", 40);
d.add("irving", 50);
d.add("john",60);
cout << endl;
cout << d << endl<<endl;
// assignment
Dict<string,long> d3;
d3 = d;
// erase
d.erase("bob");
// assignment working?
cout << d << endl<<endl;
cout << d3 << endl<<endl;
cout << "D2: " << endl;
cout << d2 << endl;
}
void ff::Dict::Add(const Dict &rhs)
{
Vector<String> names = rhs.GetAllNames();
for (StringRef name: names)
{
Value *value = rhs.GetValue(name);
SetValue(name, value);
}
}
// ---- Split ----
int getWord(const char* begin, const char* findAfter, const Dict& dict) {
while (*findAfter != '\0') {
string s(begin, findAfter + 1);
if (dict.find(s) != dict.end())
return findAfter - begin + 1;
++findAfter;
}
return -1;
}
std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryPoppler::GetValues()
{
int i = 0;
int nLength = m_poDict->getLength();
for(i=0;i<nLength;i++)
{
Get((const char*)m_poDict->getKey(i));
}
return m_map;
}
void testStringVals(){
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << "Testing String Pickle Roundtrips." << std::endl;
{
Dict d;
std::string sv;
sv="1";
d.setVal("foo",sv);
int iv;
d.getVal("foo",iv);
TEST_ASSERT(iv==1);
}
{
Dict d;
d.setVal("foo","1");
int iv;
d.getVal("foo",iv);
TEST_ASSERT(iv==1);
}
{
Dict d;
std::string sv;
sv="1.3";
d.setVal("foo",sv);
double dv;
d.getVal("foo",dv);
TEST_ASSERT(feq(dv,1.3));
}
BOOST_LOG(rdErrorLog) << "\tdone" << std::endl;
}
bool build(Dict &_front, Dict &_back, Dict &dict, Tree &tree, bool flag)
{
if (_front.empty()) return false;
if (_front.size() > _back.size())
return build(_back, _front, dict, tree, !flag);
for (auto &word : _front) dict.erase(word);
for (auto &word : _back) dict.erase(word);
Dict hoge;
bool piyo = false;
for (auto &i : _front)
{
string word = i;
for (auto &c : word)
{
char fuga = c;
for (c = 'a'; c <= 'z'; c++)
{
if (c == fuga) continue;
if (_back.count(word))
{
piyo = true;
!flag ? tree[i].push_back(word): tree[word].push_back(i);
}
else if (!piyo && dict.count(word))
{
hoge.insert(word);
!flag ? tree[i].push_back(word): tree[word].push_back(i);
}
}
c = fuga;
}
}
return piyo || build(hoge, _back, dict, tree, flag);
}
bool OCGs::optContentIsVisible( Object *dictRef )
{
Object dictObj;
Dict *dict;
Object dictType;
Object ocg;
Object policy;
bool result = true;
dictRef->fetch( m_xref, &dictObj );
if ( ! dictObj.isDict() ) {
error(-1, "Unexpected oc reference target: %i", dictObj.getType() );
dictObj.free();
return result;
}
dict = dictObj.getDict();
// printf("checking if optContent is visible\n");
dict->lookup("Type", &dictType);
if (dictType.isName("OCMD")) {
// If we supported Visibility Expressions, we'd check
// for a VE entry, and then call out to the parser here...
// printf("found OCMD dict\n");
dict->lookup("P", &policy);
dict->lookupNF("OCGs", &ocg);
if (ocg.isArray()) {
if (policy.isName("AllOn")) {
result = allOn( ocg.getArray() );
} else if (policy.isName("AllOff")) {
result = allOff( ocg.getArray() );
} else if (policy.isName("AnyOff")) {
result = anyOff( ocg.getArray() );
} else if ( (!policy.isName()) || (policy.isName("AnyOn") ) ) {
// this is the default
result = anyOn( ocg.getArray() );
}
} else if (ocg.isRef()) {
OptionalContentGroup* oc = findOcgByRef( ocg.getRef() );
if ( !oc || oc->getState() == OptionalContentGroup::Off ) {
result = false;
} else {
result = true ;
}
}
ocg.free();
policy.free();
} else if ( dictType.isName("OCG") ) {
OptionalContentGroup* oc = findOcgByRef( dictRef->getRef() );
if ( !oc || oc->getState() == OptionalContentGroup::Off ) {
result=false;
}
}
dictType.free();
dictObj.free();
// printf("visibility: %s\n", result? "on" : "off");
return result;
}
Dict* Ast::CreateDict(const location& loc, AstNode* seq, AstNode* key,
AstNode* value)
{
Dict *dict = dynamic_cast<Dict*>(seq);
if (dict != NULL) {
dict->AddKeyValue(key, value);
return dict;
}
return new Dict(this, loc, key, value);
}
int main(char** argv, int argc) {
dict.insert("liu");
dict.insert("kai");
dict.insert("liuk");
dict.insert("ai");
split("liukai", dict, printVector);
split("kaiai", dict, printVector);
split("", dict, printVector);
return 0;
}
void Sentence::check(const Dict& book){
int a =0;
int b=0;
int max;
max = book.getlength(3);
int n[max];
string m[max];
cout<<"Sentence correction for: "<<input<<"\n";
cout<<"--------------------------------"<<"\n";
while( a < max){
int counter = 0;
int num=0;
input2 = book.lookup(3, a);
if(input2.length() > input.length()-1){
num=input2.length();
}
else {
num=input.length()-1;
}
//Hamming distance calculator
for(int i=0; i < num; i++){
if(input[i] != input2[i]){
counter++;
}
}
if(a<10){
m[a] = input2;
n[a] = counter;
}
else{
for(int L=0; L<10;L++){
if(counter < n[L]){
for(int x=11; x>L; x--){
n[x] = n[x-1];
m[x]= m[x-1];
}
m[L] = input2;
n[L] = counter;
break;
}
}
}
a++;
}
for(int w=0; w<10; w++){
cout<<m[w]<<"\n";
}
}
// Parsea as palavras lidas
void parser() {
char *pch = strtok (text, "\n");
int countShort=0;
int countCompound=0;
while(pch != NULL){
if(strlen(pch) <= 5)
shortDict.insert(countShort++, pch);
else
compoundDict.insert(countCompound++, pch);
pch = strtok (NULL, "\n");
}
}
/*
================
DeclParser::Parse
================
*/
void DeclParser::Parse( Lexer &lexer ) {
Dict *resultDict = OG_NULL;
bool getKeyValue = false;
int index;
const Token *token;
String key, value;
const char *p;
while ( (token = lexer.ReadToken()) != OG_NULL ) {
p = token->GetString();
if ( p ) {
if ( *p == '\0' )
lexer.Error("Unexpected Empty Token");
if ( !getKeyValue ) {
index = declTypes.Find(p);
if ( index != -1 ) {
value = lexer.ReadString();
if ( value.IsEmpty() )
lexer.Error("Empty name!");
DictEx<Dict> &result = declTypes[index]->declList;
index = result.Find(p);
if ( index == -1 )
resultDict = &result[p];
else {
resultDict = &result[index];
resultDict->Clear();
}
} else {
resultDict = OG_NULL;
lexer.Warning( Format("Unknown decl Type '$*'") << p );
}
lexer.ExpectToken("{");
getKeyValue = true;
} else {
if ( *p == '}' )
getKeyValue = false;
else if ( resultDict ) {
key = p;
(*resultDict).Set( key.c_str(), lexer.ReadString() );
}
}
}
}
if ( getKeyValue )
throw LexerError( LexerError::END_OF_FILE );
}
int main() {
string a, b, c;
cin >> a >> b;
Dict d;
d["pixel"] = a;
d["set"] = b;
cout << d["pixel"] << endl;
cout << d["SET"] << endl;
cout << d["java"] << endl;
d.remove("pixel");
d["java"] = "computer element";
cout << d["pixel"] << endl;
cout << d.size() << endl;
cout << d;
}
void ff::DumpDict(ff::StringRef name, const Dict &dict, Log *log, bool chain, bool debugOnly)
{
if (debugOnly && !GetThisModule().IsDebugBuild())
{
return;
}
Log extraLog;
Log &realLog = log ? *log : extraLog;
realLog.TraceF(L"+- Options for: %s --\r\n", name.c_str());
Vector<String> names = dict.GetAllNames(chain, true, false);
for (const String &key: names)
{
Value *value = dict.GetValue(key, chain);
assert(value);
String valueString;
ValuePtr convertedValue;
if (value->Convert(ff::Value::Type::String, &convertedValue))
{
valueString = convertedValue->AsString();
}
else if (value->Convert(ff::Value::Type::StringVector, &convertedValue))
{
Vector<String> &strs = convertedValue->AsStringVector();
for (size_t i = 0; i < strs.Size(); i++)
{
valueString += String::format_new(L"\r\n| [%lu]: %s", i, strs[i].c_str());
}
}
else if (value->Convert(ff::Value::Type::Data, &convertedValue))
{
valueString.format(L"<data[%lu]>", convertedValue->AsData()->GetSize());
}
else
{
valueString = L"<data>";
}
realLog.TraceF(L"| %s: %s\r\n", key.c_str(), valueString.c_str());
}
realLog.Trace(L"+- Done --\r\n");
}
void Pages::user(Document *doc){
std::string sub;
int uid = route("user", path, sub);
if(!uid || (sub != "" && sub != "json")) return;
Account u(uid);
if(!u) return;
if(sub == "json"){
doc->setJson("json/account.tpl");
u.fill(doc->dict());
doc->dict()->ShowSection("LONG");
Tracks::byUser(u.id, 0).fillJson(doc->dict(), false);
std::vector<Playlist> playlists = Playlist::forUser(u);
for(std::vector<Playlist>::const_iterator i=playlists.begin(); i!=playlists.end(); i++){
Dict *playlistDict = doc->dict()->AddSectionDictionary("PLAYLIST");
Dict *item = playlistDict->AddIncludeDictionary("PLAYLIST");
item->SetFilename("json/playlist.tpl");
i->fill(item);
}
} else { // plain HTML
doc->setHtml("html/user.tpl", u.name);
u.fill(doc->dict());
Tracks::byUser(u.id, u.self()).fill(doc->dict(), "TRACK_LIST");
#ifdef HAVE_LIBHIREDIS
Stat::push("userView", uid);
#endif
std::vector<Playlist> playlists = Playlist::forUser(u);
doc->dict()->ShowSection(playlists.empty() ? "NO_PLAYLIST" : "HAS_PLAYLISTS");
for(std::vector<Playlist>::const_iterator i=playlists.begin(); i!=playlists.end(); i++){
Dict *playlistDict = doc->dict()->AddSectionDictionary("PLAYLIST");
i->fill(playlistDict);
}
EventList::user(u, 12).fill(doc->dict(), "EVENTS");
Follower(u.id).followed().fill(doc->dict(), "FOLLOWED_USERS");
Feature(u.id).fill(doc->dict());
}
}
std::string
demo::__toString(const Dict& arg)
{
std::string result = "{";
for(Dict::const_iterator it = arg.begin(); it != arg.end(); ++it)
{
result += "<";
result += __toString(it->first);
result += ",";
result += __toString(it->second);
result += ">";
result += " ";
}
trimEnd(result);
result += "}";
return result;
}
FusionOperator IFusionOperator::fromString(const std::string& type)
{
typedef map<string, FusionOperator, pfs::utils::StringUnsensitiveComp> Dict;
static Dict v =
map_list_of
("debevec", DEBEVEC)
("robertson", ROBERTSON)
("robertson-auto", ROBERTSON_AUTO)
;
Dict::const_iterator it = v.find(type);
if (it != v.end())
{
return it->second;
}
return DEBEVEC;
}
TransactionType
transaction_type_from_verb(wxString const& p_phrase)
{
typedef map<wxString, TransactionType> Dict;
static Dict dict;
static bool calculated_already = false;
if (!calculated_already)
{
JEWEL_ASSERT (dict.empty());
dict[expenditure_verb()] = TransactionType::expenditure;
dict[revenue_verb()] = TransactionType::revenue;
dict[balance_sheet_verb()] = TransactionType::balance_sheet;
dict[envelope_verb()] = TransactionType::envelope;
dict[generic_verb()] = TransactionType::generic;
calculated_already = true;
}
JEWEL_ASSERT (!dict.empty());
JEWEL_ASSERT
( dict.size() ==
static_cast<Dict::size_type>(TransactionType::num_transaction_types)
);
Dict::const_iterator const it = dict.find(p_phrase);
if (it == dict.end())
{
JEWEL_THROW
( InvalidTransactionTypeException,
"wxString passed to transaction_type_from_verb does not "
"correspond to any TransactionType."
);
}
JEWEL_ASSERT (it != dict.end());
return it->second;
}
Production *ProductionState::getProduction(const char *result) {
Production *p = (Production *)_production[result];
if( p == NULL ) {
p = new Production(result, _constraint, knownInvalid);
_production.Insert(result, p);
}
return p;
}
// Calcula a proporcao de palavras com ateh 5 letras
void calc_proporcao() {
for(int i=0; i<6; i++)
qtd_palavra[i] = 0;
Dict::iterator it;
for(it=mydict.begin(); it!=mydict.end(); ++it) {
if(strlen(*it) <=5 ) {
qtd_palavra[strlen(*it)]++;
qtd_palavra[0]++;
}
}
for(int i=0; i<6; i++)
cout << i << ":" << qtd_palavra[i] << endl;
cout << "total prop: " << qtd_palavra[0] << endl;
total_palavras = qtd_palavra[0];
}
bool test_dict_non_const_square_brackets_operator()
{
cout << "Testing non const operator[] to ensure it is inserting values as expected" << endl << endl;
map<string, EMObject> objects = get_test_dict_keys();
Dict dict;
// Here is where the insertion occurs
map<string, EMObject>::const_iterator mapIt = objects.begin();
for( ; mapIt != objects.end(); ++mapIt )
{
dict[mapIt->first] = mapIt->second;
}
bool success = true;
for( mapIt = objects.begin(); mapIt != objects.end(); ++mapIt )
{
bool found = false;
cout << "Testing the insertion of map key/value pair with key " << mapIt->first << " (inserted into Dict with operator[]) ..... ";
for( Dict::const_iterator it = dict.begin(); it != dict.end(); ++it )
{
if ( it->first == mapIt-> first && it->second == mapIt->second )
{
found = true;
break;
}
}
if ( found )
cout << "passed";
else
{
cout << "FAILED";
success = false;
}
cout << endl;
}
print_success_message(success);
return success;
}
std::unordered_map<uint, QString> RefactoringClient::convertFilePaths(
const ClangBackEnd::FilePathDict &filePaths)
{
using Dict = std::unordered_map<uint, QString>;
Dict qstringFilePaths;
qstringFilePaths.reserve(filePaths.size());
auto convertFilePath = [] (const ClangBackEnd::FilePathDict::value_type &dictonaryEntry) {
return std::make_pair(dictonaryEntry.first,
concatenateFilePath(dictonaryEntry.second).toQString());
};
std::transform(filePaths.begin(),
filePaths.end(),
std::inserter(qstringFilePaths, qstringFilePaths.begin()),
convertFilePath);
return qstringFilePaths;
}
void EMUtil::dump_dict(const Dict & dict)
{
vector < string > keys = dict.keys();
vector < EMObject > values = dict.values();
for (unsigned int i = 0; i < keys.size(); i++) {
EMObject obj = values[i];
if (! obj.is_null()) {
string val = obj.to_str();
if (keys[i] == "datatype") {
val = get_datatype_string((EMDataType) (int) obj);
}
fprintf(stdout, "%25s\t%s\n", keys[i].c_str(), val.c_str());
}
}
}