static void BenchDir(TCHAR *dir)
{
StrVec files;
ScopedMem<TCHAR> pattern(str::Format(_T("%s\\*.pdf"), dir));
CollectPathsFromDirectory(pattern, files, false);
for (size_t i = 0; i < files.Count(); i++) {
BenchFile(files.At(i), NULL);
}
}
bool operator==(const StrVec &lhs, const StrVec &rhs)
{
if (lhs.size() != rhs.size())
return false;
for (auto pl = lhs.begin(), pr = rhs.begin(); pl != lhs.end(); )
if (*pl != *pr)
return false;
return true;
}
bool match(const PackInfo &other) const
{
if(other.dirs.size() != dirs.size()) return false;
assert(dirs.size() == paths.size());
assert(dirs.size() == other.paths.size());
for(int i=0; i<dirs.size(); i++)
if(dirs[i] != other.dirs[i] || paths[i] != other.paths[i])
return false;
return true;
}
int main()
{
StrVec str;
str.push_back("adf");
str.push_back("sdfd");
for (auto i = str.begin(); i != str.end(); ++i)
cout << *i << ends;
cout << endl;
return 0;
}
StrVec getVec(std::istream &is)
{
StrVec svec;
std::string s;
while (is >> s)
svec.push_back(s);
// this is where move is necessary
return svec;
}
int ImageDirEngineImpl::GetPageByLabel(const TCHAR *label)
{
for (size_t i = 0; i < pageFileNames.Count(); i++) {
const TCHAR *fileName = path::GetBaseName(pageFileNames.At(i));
const TCHAR *fileExt = path::GetExt(fileName);
if (str::StartsWithI(fileName, label) &&
(fileName + str::Len(label) == fileExt || fileName[str::Len(label)] == '\0'))
return (int)i + 1;
}
return BaseEngine::GetPageByLabel(label);
}
StrVec read_lists (const StrVec& fnames)
{
StrVec rv;
StrVec::const_iterator itr = fnames.begin ();
while (itr != fnames.end ())
{
StrVec vals = read_list (*itr);
std::copy (vals.begin (), vals.end (), std::back_inserter (rv));
itr ++;
}
return rv;
}
std::string make_temp_fname (const char* tmpdir, const char* prefix)
{
// if directory not passed in, guess one
std::string tn = temp_dir (tmpdir);;
// if prefix not passed in, use default
if (!prefix) prefix = DEFAULT_TEMP_FILE_PREFIX;
// get temp directory listing
StrVec dircontent = listdir (tn);
// find all entries matching prefix and having numeric postfix, get list of numbers
UintSet postfixes;
unsigned prefix_len = prefix ? strlen (prefix) : 0;
for (StrVec::iterator ii = dircontent.begin (); ii != dircontent.end (); ii ++)
{
// check if prefix matches
if (prefix_len && (ii->substr (0, prefix_len) != prefix))
continue;
// check if postfix is numeric and get the number
unsigned number = 0;
std::string::iterator sitr;
for (sitr = ii->begin () + prefix_len; sitr != ii->end (); sitr ++)
{
number *= 10;
if (!isdigit (*sitr))
break;
else
number += *sitr - '0';
}
if (sitr != ii->end ())
continue;
// store number to postfixes set
postfixes.insert (number);
}
// now retrieve the numbers using first gap
// make a set for quick presence check
unsigned prev = 0;
for (UintSet::iterator nitr = postfixes.begin (); nitr != postfixes.end (); nitr ++)
if (prev + 1 < *nitr)
break; // found the gap in sequence
else
prev = *nitr;
if (prev == std::numeric_limits<unsigned>::max ()) // just for sanity :)
ers << "No more temp file names available for prefix " << (prefix ? prefix : "") << " in directory " << tn << Throw;
// prev + 1 is the right number
std::ostringstream name (tn, std::ios::out | std::ios::app);
name << PATH_SEPARATOR;
if (prefix) name << prefix;
name << prev + 1;
return name.str ();
}
bool StressTest::OpenDir(const TCHAR *dirPath)
{
assert(filesToOpen.Count() == 0);
bool hasFiles = CollectStressTestSupportedFilesFromDirectory(dirPath, fileFilter, filesToOpen);
filesToOpen.SortNatural();
ScopedMem<TCHAR> pattern(str::Format(_T("%s\\*"), dirPath));
bool hasSubDirs = CollectPathsFromDirectory(pattern, dirsToVisit, true);
return hasFiles || hasSubDirs;
}
//! copy constructor
StrVec::StrVec(const StrVec &s)
{
/**
* @brief newData is a pair of pointers pointing to newly allocated and copied
* range : [b, e)
*/
std::pair<std::string*, std::string*>
newData = alloc_n_copy(s.begin(), s.end());
element = newData.first;
first_free = cap = newData.second;
}
// Find a record corresponding to the given source file, line number and optionally column number.
// (at the moment the column parameter is ignored)
//
// If there are several *consecutively declared* records for the same line then they are all returned.
// The list of records is added to the vector 'records'
//
// If there is no record for that line, the record corresponding to the nearest line is selected
// (within a range of EPSILON_LINE)
//
// The function returns PDFSYNCERR_SUCCESS if a matching record was found.
UINT Pdfsync::SourceToRecord(const TCHAR* srcfilename, UINT line, UINT col, Vec<size_t> &records)
{
if (!srcfilename)
return PDFSYNCERR_INVALID_ARGUMENT;
ScopedMem<TCHAR> srcfilepath;
// convert the source file to an absolute path
if (PathIsRelative(srcfilename))
srcfilepath.Set(PrependDir(srcfilename));
else
srcfilepath.Set(str::Dup(srcfilename));
if (!srcfilepath)
return PDFSYNCERR_OUTOFMEMORY;
// find the source file entry
size_t isrc;
for (isrc = 0; isrc < srcfiles.Count(); isrc++)
if (path::IsSame(srcfilepath, srcfiles.At(isrc)))
break;
if (isrc == srcfiles.Count())
return PDFSYNCERR_UNKNOWN_SOURCEFILE;
if (fileIndex.At(isrc).start == fileIndex.At(isrc).end)
return PDFSYNCERR_NORECORD_IN_SOURCEFILE; // there is not any record declaration for that particular source file
// look for sections belonging to the specified file
// starting with the first section that is declared within the scope of the file.
UINT min_distance = EPSILON_LINE; // distance to the closest record
size_t lineIx = (size_t)-1; // closest record-line index
for (size_t isec = fileIndex.At(isrc).start; isec < fileIndex.At(isrc).end; isec++) {
// does this section belong to the desired file?
if (lines.At(isec).file != isrc)
continue;
UINT d = abs((int)lines.At(isec).line - (int)line);
if (d < min_distance) {
min_distance = d;
lineIx = isec;
if (0 == d)
break; // We have found a record for the requested line!
}
}
if (lineIx == (size_t)-1)
return PDFSYNCERR_NORECORD_FOR_THATLINE;
// we read all the consecutive records until we reach a record belonging to another line
for (size_t i = lineIx; i < lines.Count() && lines.At(i).line == lines.At(lineIx).line; i++)
records.Push(lines.At(i).record);
return PDFSYNCERR_SUCCESS;
}
bool operator< (const StrVec & s1,const StrVec &s2)
{
for(size_t i =0 ; i< s1.size() && i < s2.size(); i++)
{
if(*(s1.elements+i ) < *(s2.elements+i) )
return true ;
else if(*(s1.elements+i ) < *(s2.elements+i) )
return false;
}
if(s1.size() < s2.size())
return true ;
return false;
}
bool operator==(const StrVec &s1 ,const StrVec &s2)
{
if(s1.size() == s2.size())
{
for(size_t i =0 ; i< s1.size() ; i++)
{
if(*(s1.elements+i ) != *(s2.elements+i) )
return false ;
}
return true;
}
return false ;
}
void CopySelectionToClipboard(WindowInfo *win)
{
if (!win->selectionOnPage) return;
CrashIf(win->selectionOnPage->Count() == 0);
if (win->selectionOnPage->Count() == 0) return;
CrashIf(!win->dm || !win->dm->engine);
if (!win->dm || !win->dm->engine) return;
if (!OpenClipboard(NULL)) return;
EmptyClipboard();
if (!win->dm->engine->IsCopyingTextAllowed())
ShowNotification(win, _TR("Copying text was denied (copying as image only)"));
else if (!win->dm->engine->IsImageCollection()) {
ScopedMem<TCHAR> selText;
bool isTextSelection = win->dm->textSelection->result.len > 0;
if (isTextSelection) {
selText.Set(win->dm->textSelection->ExtractText(_T("\r\n")));
}
else {
StrVec selections;
for (size_t i = 0; i < win->selectionOnPage->Count(); i++) {
SelectionOnPage *selOnPage = &win->selectionOnPage->At(i);
TCHAR *text = win->dm->GetTextInRegion(selOnPage->pageNo, selOnPage->rect);
if (text)
selections.Push(text);
}
selText.Set(selections.Join());
}
// don't copy empty text
if (!str::IsEmpty(selText.Get()))
CopyTextToClipboard(selText, true);
if (isTextSelection) {
// don't also copy the first line of a text selection as an image
CloseClipboard();
return;
}
}
/* also copy a screenshot of the current selection to the clipboard */
SelectionOnPage *selOnPage = &win->selectionOnPage->At(0);
RenderedBitmap * bmp = win->dm->engine->RenderBitmap(selOnPage->pageNo,
win->dm->ZoomReal(), win->dm->Rotation(), &selOnPage->rect, Target_Export);
if (bmp)
CopyImageToClipboard(bmp->GetBitmap(), true);
delete bmp;
CloseClipboard();
}
string trimmedName(string& s)
{
//printf("splitting %s\n",s.c_str());
StrVec vec;
int n=strsplit_slash(s, vec);
//for(int i=0;i<n;i++) printf(" '%s'\n",vec[i].c_str());
unsigned int i=0;
while(i<vec.size())
{
if(i>0)
{
if(vec[i]==".." && vec[i-1]!="..")
{
i--;
vec.erase(vec.begin()+i,vec.begin()+i+2);
continue;
}
}
i++;
}
if(!vec.size()) return "";
string ret="";
for(unsigned int i=0; i<vec.size(); i++)
{
ret+=vec[i];
if(i+1!=vec.size()) ret+="/";
}
return ret;
}
void append(const std::string& word)
{
std::string lower;
cybozu::ToLower(lower, word);
std::pair<Str2Int::iterator, bool> ret = word2id_.insert(Str2Int::value_type(lower, (int)id2word_.size()));
//printf("word=%s, id=%d, ret=%d\n", ret.first->first.c_str(), ret.first->second, ret.second);
if (ret.second) {
id2word_.push_back(lower);
df_.resize(id2word_.size());
}
if (set_.insert(word).second) {
df_[ret.first->second]++;
}
}
static bool SetupPluginMode(CommandLineInfo& i)
{
if (!IsWindow(i.hwndPluginParent) || i.fileNames.Count() == 0)
return false;
gPluginURL = i.pluginURL;
if (!gPluginURL)
gPluginURL = i.fileNames.At(0);
assert(i.fileNames.Count() == 1);
while (i.fileNames.Count() > 1) {
free(i.fileNames.Pop());
}
i.reuseInstance = i.exitOnPrint = false;
// always display the toolbar when embedded (as there's no menubar in that case)
gGlobalPrefs.toolbarVisible = true;
// never allow esc as a shortcut to quit
gGlobalPrefs.escToExit = false;
// never show the sidebar by default
gGlobalPrefs.tocVisible = false;
if (DM_AUTOMATIC == gGlobalPrefs.defaultDisplayMode) {
// if the user hasn't changed the default display mode,
// display documents as single page/continuous/fit width
// (similar to Adobe Reader, Google Chrome and how browsers display HTML)
gGlobalPrefs.defaultDisplayMode = DM_CONTINUOUS;
gGlobalPrefs.defaultZoom = ZOOM_FIT_WIDTH;
}
// extract some command line arguments from the URL's hash fragment where available
// see http://www.adobe.com/devnet/acrobat/pdfs/pdf_open_parameters.pdf#nameddest=G4.1501531
if (i.pluginURL && str::FindChar(i.pluginURL, '#')) {
ScopedMem<TCHAR> args(str::Dup(str::FindChar(i.pluginURL, '#') + 1));
str::TransChars(args, _T("#"), _T("&"));
StrVec parts;
parts.Split(args, _T("&"), true);
for (size_t k = 0; k < parts.Count(); k++) {
TCHAR *part = parts.At(k);
int pageNo;
if (str::StartsWithI(part, _T("page=")) && str::Parse(part + 4, _T("=%d%$"), &pageNo))
i.pageNumber = pageNo;
else if (str::StartsWithI(part, _T("nameddest=")) && part[10])
str::ReplacePtr(&i.destName, part + 10);
else if (!str::FindChar(part, '=') && part[0])
str::ReplacePtr(&i.destName, part);
}
}
return true;
}
static StrVec
conn_get_table_list (dbi_conn conn, const std::string& dbname,
const std::string& table)
{
StrVec retval;
const char* tableptr = (table.empty() ? nullptr : table.c_str());
auto tables = dbi_conn_get_table_list (conn, dbname.c_str(), tableptr);
while (dbi_result_next_row (tables) != 0)
{
std::string table_name {dbi_result_get_string_idx (tables, 1)};
retval.push_back(table_name);
}
dbi_result_free (tables);
return retval;
}
int main() {
StrVec words;
words.push_back("ss");
words.push_back("sb");
words.push_back("asf");
words.push_back("safasfd");
words.push_back("asfas");
std::cout<<words.size()<<std::endl;
//words = StrVec();
//words = words;
std::cout<<"cap "<<words.capacity()<<std::endl;
std::cout<<"sz "<<words.size()<<std::endl;
for_each(words.begin(), words.end(), [](const std::string &s){std::cout<<s<<std::endl;});
std::cout<<"exit"<<std::endl;
}
int strsplit_slash(string& st, StrVec& vec)
{
vec.clear();
int last_pos=0;
int pos=0;
int max_pos=st.size();
while(pos<max_pos)
{
last_pos=pos;
while(st[pos]!='/' && pos<max_pos) pos++;
vec.push_back(st.substr(last_pos,pos-last_pos));
while(st[pos]=='/' && pos<max_pos) pos++;
}
return vec.size();
}
Option(int argc, const char *const argv[])
{
cybozu::Option opt;
std::string charSetFile;
std::string dicFile;
bool debug;
opt.appendOpt(&charSetFile, "", "cf", "char set file");
opt.appendOpt(&threadNum, 4, "t", "thread num");
opt.appendOpt(&dicFile, "", "d", "dictionary file");
opt.appendOpt(&passLen, 0, "l", "length of pass");
opt.appendBoolOpt(&debug, "v", "verbose message");
opt.appendHelp("h");
opt.appendParam(&encFile, "encrypted file");
if (!opt.parse(argc, argv)) {
opt.usage();
exit(1);
}
if (debug) ms::setDebug(1);
if (charSetFile.empty()) {
charSet = "abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789-_";
} else {
std::ifstream ifs(charSetFile.c_str(), std::ios::binary);
if (!std::getline(ifs, charSet)) {
fprintf(stderr, "can't read char set file [%s]\n", charSetFile.c_str());
exit(1);
}
trim(charSet);
}
if (!dicFile.empty()) {
std::ifstream ifs(dicFile.c_str(), std::ios::binary);
std::string line;
while (std::getline(ifs, line)) {
trim(line);
toUtf8(line);
passSet.push_back(line);
}
if (passSet.empty()) {
fprintf(stderr, "can't read dicFile [%s]\n", dicFile.c_str());
exit(1);
}
std::sort(passSet.begin(), passSet.end(), &lessByLength);
}
if (ms::isDebug()) {
opt.put();
}
}
StrVec split_path (const char* path)
{
StrVec rv;
std::string pstr = path;
std::string::size_type pos, ppos = 0;
while ((pos = pstr.find (PATH_SEPARATOR, ppos)) != std::string::npos)
{
if (pos != ppos || ppos == 0)
rv.push_back (pstr.substr (ppos, pos - ppos));
ppos = pos + 1;
}
if (ppos < pstr.length ())
rv.push_back (pstr.substr (ppos, pstr.length () - ppos));
return rv;
}
int main(int argc, char const *argv[])
{
StrVec svec1;
std::ifstream ifs("in.txt");
std::istream_iterator<std::string> beg(ifs), end;
std::vector<std::string> src(beg, end);
for (auto& s : src)
{
svec1.push_back(s);
}
svec1.resize(10, "illidan");
StrVec svec = { "a", "b", "c", "d", "e" };
display(svec);
std::cout << svec.size() << std::endl;
return 0;
}
StrMap RedisClient::HMGet(const std::string& key, const StrVec& vec){
StrMap map;
if( key.empty() || vec.empty()) {
return map;
}
std::stringstream sm;
sm << "HMGET " << key;
for(auto & i : vec) {
sm << " " << i;
}
redisReply *redis_reply = RedoCommand(sm.str(),REDIS_REPLY_ARRAY);
if( redis_reply ) {
for (size_t i=0; i<redis_reply->elements; ++i) {
auto reply = redis_reply->element[i];
if (reply->type == REDIS_REPLY_STRING) {
map[vec[i]] = redis_reply->element[i]->str;
}
else if (reply->type == REDIS_REPLY_NIL) {
LOGW("HMGet element" << vec[i] <<" is REDIS_REPLY_NIL! command=");
map[vec[i]] ="";
}
}
}
freeReplyObject_Safe(redis_reply);
return map;
}
int Pdfsync::DocToSource(UINT pageNo, PointI pt, ScopedMem<TCHAR>& filename, UINT *line, UINT *col)
{
if (IsIndexDiscarded())
if (RebuildIndex() != PDFSYNCERR_SUCCESS)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
// find the entry in the index corresponding to this page
if (pageNo <= 0 || pageNo >= sheetIndex.Count() || pageNo > (UINT)engine->PageCount())
return PDFSYNCERR_INVALID_PAGE_NUMBER;
// PdfSync coordinates are y-inversed
RectI mbox = engine->PageMediabox(pageNo).Round();
pt.y = mbox.dy - pt.y;
// distance to the closest pdf location (in the range <PDFSYNC_EPSILON_SQUARE)
UINT closest_xydist = UINT_MAX;
UINT selected_record = UINT_MAX;
// If no record is found within a distance^2 of PDFSYNC_EPSILON_SQUARE
// (selected_record == -1) then we pick up the record that is closest
// vertically to the hit-point.
UINT closest_ydist = UINT_MAX; // vertical distance between the hit point and the vertically-closest record
UINT closest_xdist = UINT_MAX; // horizontal distance between the hit point and the vertically-closest record
UINT closest_ydist_record = UINT_MAX; // vertically-closest record
// read all the sections of 'p' declarations for this pdf sheet
for (size_t i = sheetIndex.At(pageNo); i < points.Count() && points.At(i).page == pageNo; i++) {
// check whether it is closer than the closest point found so far
UINT dx = abs(pt.x - (int)SYNC_TO_PDF_COORDINATE(points.At(i).x));
UINT dy = abs(pt.y - (int)SYNC_TO_PDF_COORDINATE(points.At(i).y));
UINT dist = dx * dx + dy * dy;
if (dist < PDFSYNC_EPSILON_SQUARE && dist < closest_xydist) {
selected_record = points.At(i).record;
closest_xydist = dist;
}
else if ((closest_xydist == UINT_MAX) && dy < PDFSYNC_EPSILON_Y &&
(dy < closest_ydist || (dy == closest_ydist && dx < closest_xdist))) {
closest_ydist_record = points.At(i).record;
closest_ydist = dy;
closest_xdist = dx;
}
}
if (selected_record == UINT_MAX)
selected_record = closest_ydist_record;
if (selected_record == UINT_MAX)
return PDFSYNCERR_NO_SYNC_AT_LOCATION; // no record was found close enough to the hit point
// We have a record number, we need to find its declaration ('l ...') in the syncfile
PdfsyncLine cmp; cmp.record = selected_record;
PdfsyncLine *found = (PdfsyncLine *)bsearch(&cmp, lines.LendData(), lines.Count(), sizeof(PdfsyncLine), cmpLineRecords);
assert(found);
if (!found)
return PDFSYNCERR_NO_SYNC_AT_LOCATION;
filename.Set(str::Dup(srcfiles.At(found->file)));
*line = found->line;
*col = found->column;
return PDFSYNCERR_SUCCESS;
}
void BenchFileOrDir(StrVec& pathsToBench)
{
gLog = new slog::StderrLogger();
size_t n = pathsToBench.Count() / 2;
for (size_t i = 0; i < n; i++) {
TCHAR *path = pathsToBench.At(2 * i);
if (file::Exists(path))
BenchFile(path, pathsToBench.At(2 * i + 1));
else if (dir::Exists(path))
BenchDir(path);
else
logbench("Error: file or dir %s doesn't exist", path);
}
delete gLog;
}
TCHAR *ImageDirEngineImpl::GetPageLabel(int pageNo)
{
if (pageNo < 1 || PageCount() < pageNo)
return BaseEngine::GetPageLabel(pageNo);
const TCHAR *fileName = path::GetBaseName(pageFileNames.At(pageNo - 1));
return str::DupN(fileName, path::GetExt(fileName) - fileName);
}
bool StressTest::GoToNextFile()
{
for (;;) {
while (filesToOpen.Count() > 0) {
// test next file
ScopedMem<TCHAR> path(filesToOpen.At(0));
filesToOpen.RemoveAt(0);
if (!IsInRange(fileRanges, ++fileIndex))
continue;
if (OpenFile(path))
return true;
}
if (dirsToVisit.Count() > 0) {
// test next directory
ScopedMem<TCHAR> path(dirsToVisit.At(0));
dirsToVisit.RemoveAt(0);
OpenDir(path);
continue;
}
if (--cycles <= 0)
return false;
// start next cycle
if (file::Exists(basePath))
filesToOpen.Append(str::Dup(basePath));
else
OpenDir(basePath);
}
}
StrVec read_list (const char* fname)
{
StrVec rv;
LineReader rd (fname);
char *l, *lc;
while ((l = rd.nextLine ()))
{
// find first token and add to rv
while (*l && isspace (*l)) l ++;
if (!*l) continue;
lc = l + 1;
while (*lc && !isspace (*lc)) lc ++;
*lc = 0;
rv.push_back (l);
}
rd.close ();
return rv;
}
size_t Data::newEntry(const std::string& key, const SLStore& dv)
{
KeyIdx ki(key, m_keyIdx.size());
KeyIdxVec::iterator it = std::upper_bound(m_keyIdx.begin(), m_keyIdx.end(), ki, key_less);
m_keys.push_back(key);
m_varData.push_back(dv);
m_keyIdx.insert(it, ki);
return ki.second;
}
