int SortListByTitle(const anime::Item& item1, const anime::Item& item2) {
if (Settings.GetBool(taiga::kApp_List_DisplayEnglishTitles)) {
return CompareStrings(item1.GetEnglishTitle(true),
item2.GetEnglishTitle(true));
} else {
return CompareStrings(item1.GetTitle(), item2.GetTitle());
}
}
bool CatalogItemsComparator::operator()(int i, int j) const
{
const CatalogItem& a = Item(i);
const CatalogItem& b = Item(j);
if ( m_order.untransFirst )
{
if ( a.GetValidity() == CatalogItem::Val_Invalid && b.GetValidity() != CatalogItem::Val_Invalid )
return true;
if ( a.GetValidity() != CatalogItem::Val_Invalid && b.GetValidity() == CatalogItem::Val_Invalid )
return false;
if ( !a.IsTranslated() && b.IsTranslated() )
return true;
if ( a.IsTranslated() && !b.IsTranslated() )
return false;
if ( a.IsFuzzy() && !b.IsFuzzy() )
return true;
if ( !a.IsFuzzy() && b.IsFuzzy() )
return false;
}
switch ( m_order.by )
{
case SortOrder::By_FileOrder:
{
return i < j;
}
case SortOrder::By_Source:
{
int r = CompareStrings(a.GetString(), b.GetString());
if ( r != 0 )
return r < 0;
break;
}
case SortOrder::By_Translation:
{
int r = CompareStrings(a.GetTranslation(), b.GetTranslation());
if ( r != 0 )
return r < 0;
break;
}
}
// As last resort, sort by position in file. Note that this means that
// no two items are considered equal w.r.t. sort order; this ensures stable
// ordering.
return i < j;
}
void XGPopMenuView::MoveTo(short len, char *ptr)
{
char buffer[256];
char cptr[256];
short i,num;
short cur = -1;
if (len == 0) return; // Huh?
/*
* Find the smallest bigger than this ptr
*/
num = fList->GetNumStrings();
for (i = 0; i < num; i++) {
fList->GetString(i,buffer);
if (-1 < CompareStrings(len,ptr,buffer)) {
if (cur == -1) {
cur = i;
strcpy(cptr,buffer);
} else if (-1 < CompareStrings(strlen(buffer),buffer,cptr)) {
cur = i;
strcpy(cptr,buffer);
}
}
}
if (cur == -1) {
/*
* None were bigger, so find the last in alphabetical order
*/
for (i = 0; i < num; i++) {
fList->GetString(i,buffer);
if (cur == -1) {
cur = i;
strcpy(cptr,buffer);
} else if (-1 < CompareStrings(strlen(cptr),cptr,buffer)) {
cur = i;
strcpy(ptr,buffer);
}
}
}
/*
* Now set this as the selection
*/
fDefault = cur;
fScrollFlag = false;
SetSelect(fDefault);
}
/* Text suchen und selektieten Punkt übergeben */
BOOL SearchText (char* pszKeyStr, POINT* pPoint) {
register int i;
int iEnd;
char szLine [iMaxLineLength];
char *pszAktPos;
int iStart = HIWORD (Edit_GetSel (hEditWnd));
int iLineNr = Edit_LineFromChar (hEditWnd, iStart);
int iMaxLineNr = Edit_GetLineCount (hEditWnd);
int iLineLength = Edit_LineLength (hEditWnd, iStart);
/* 1. (akt.) Zeile untersuchen */
if (iLineLength) {
for (i = 0; i < sizeof (szLine); i++)
szLine [i] = '\0';
GetFirstLine (szLine);
if (pszAktPos = CompareStrings (szLine, pszKeyStr)) {
iStart += pszAktPos - szLine;
iEnd = iStart + strlen (pszKeyStr);
pPoint->x = iStart; pPoint->y = iEnd;
return (TRUE);
}
else
iStart += strlen (szLine) + 2; // einschl. 0D0A
}
else
iStart += 2;
/* alle restlichen Zeilen untersuchen */
for (++iLineNr; iLineNr < iMaxLineNr; iLineNr++) {
if (iLineLength = Edit_LineLength (hEditWnd, iStart)) {
for (i = 0; i < sizeof (szLine); i++)
szLine [i] = '\0';
Edit_GetLine (hEditWnd, iLineNr, szLine, sizeof (szLine) -1);
if (pszAktPos = CompareStrings (szLine, pszKeyStr)) {
iStart += pszAktPos - szLine;
iEnd = iStart + strlen (pszKeyStr);
pPoint->x = iStart; pPoint->y = iEnd;
return (TRUE);
}
else
iStart += iLineLength + 2;
}
else
iStart += 2;
}
/* Punkt auf ungültigen Wert setzen */
pPoint->x = -1; pPoint->y = -1;
return (FALSE);
}
bool TStringList::Find(const UnicodeString & S, intptr_t & Index) const
{
bool Result = false;
intptr_t L = 0;
intptr_t H = GetCount() - 1;
while ((H != NPOS) && (L <= H))
{
intptr_t I = (L + H) >> 1;
intptr_t C = CompareStrings(FStrings[I], S);
if (C < 0)
{
L = I + 1;
}
else
{
H = I - 1;
if (C == 0)
{
Result = true;
if (FDuplicates != dupAccept)
{
L = I;
}
}
}
}
Index = L;
return Result;
}
//return given sections index in array
int CIniEx::LookupSection(CString *Section)
{
int nRet;
for (int i=0;i<m_Sections.GetSize();i++)
{
nRet=CompareStrings(&m_Sections.GetAt(i),Section);
if (nRet==0) return i;
}
return -1;
}
intptr_t TStrings::IndexOf(const UnicodeString & S) const
{
for (intptr_t Result = 0; Result < GetCount(); Result++)
{
if (CompareStrings(GetString(Result), S) == 0)
{
return Result;
}
}
return NPOS;
}
//returns index of key for given section
//if no result returns -1
int CIniEx::LookupKey(int nSectionIndex,CString *Key)
{
ASSERT(nSectionIndex<=m_SectionNo);
int nRet;
for (INT_PTR i=m_Keys[nSectionIndex]->GetUpperBound();i>=0;i--)
{
nRet=CompareStrings(&m_Keys[nSectionIndex]->GetAt(i),Key);
if (nRet==0)
return (int)i;
}
return -1;
}
TEST(ParserTest, ShouldReadString)
{
Parser parser;
TList<char>* inputString = UnitTestsHelper::CreateInputString("defhkljahkgnfasdjnckagruibvdnmcvaslkdkwabgjsavbaslkjfnsadlkfvhadbvhnzbcalskufgjasbdjlncsxn", 90);
char* fileName = "Tests/in.txt";
WriteDataToFile(fileName, inputString);
FILE* inputFile = fopen(fileName, "r");
TList<char>* readedString = parser.ReadString(inputFile);
fclose(inputFile);
CompareStrings(inputString, readedString);
}
intptr_t TStrings::IndexOfName(const UnicodeString & Name) const
{
for (intptr_t Index = 0; Index < GetCount(); ++Index)
{
UnicodeString S = GetString(Index);
intptr_t P = ::AnsiPos(S, L'=');
if ((P > 0) && (CompareStrings(S.SubStr(1, P - 1), Name) == 0))
{
return Index;
}
}
return NPOS;
}
bool MSufSort::VerifySort()
{
//printf("\n\nVerifying sort\n\n");
bool error = false;
int progressMax = m_sourceLength;
int progressValue = 0;
int progressUpdateStep = progressMax / 100;
int nextProgressUpdate = 1;
unsigned int * suffixArray = new unsigned int[m_sourceLength];
for (unsigned int i = 0; ((!error) && (i < m_sourceLength)); i++)
{
if (!(m_ISA[i] & 0x80000000))
error = true;
unsigned int n = (m_ISA[i] & 0x3fffffff) - 1;
suffixArray[n] = i;
}
// all ok so far.
// now compare the suffixes in lexicographically sorted order to confirm the sort was good.
for (unsigned int suffixIndex = 0; ((!error) && (suffixIndex < (m_sourceLength - 1))); suffixIndex++)
{
if (++progressValue == nextProgressUpdate)
{
nextProgressUpdate += progressUpdateStep;
//printf("Verify sort: %.2f%% complete%c", ((double)progressValue / progressMax) * 100, 13);
}
SYMBOL_TYPE * ptrA = &m_source[suffixArray[suffixIndex]];
SYMBOL_TYPE * ptrB = &m_source[suffixArray[suffixIndex + 1]];
int maxLen = (ptrA < ptrB) ? m_sourceLength - (ptrB - m_source) : m_sourceLength - (ptrA - m_source);
int c = CompareStrings(ptrA, ptrB, maxLen);
if (c > 0)
error = true;
else
if ((c == 0) && (ptrB > ptrA))
error = true;
}
//printf(" %c", 13);
delete [] suffixArray;
return !error;
}
dword ELF::Private::GetSymbolAddr(dword filebase, char* symname)
{
ELF::Private::Elf32_Ehdr* header = (ELF::Private::Elf32_Ehdr*)filebase;
ELF::Private::Elf32_Shdr* shdrs = (ELF::Private::Elf32_Shdr*)(filebase + header->e_shoff);
//look for symbol and string table
ELF::Private::Elf32_Shdr* symtab_sh = 0;
ELF::Private::Elf32_Sym* symtab = 0;
char* strtab = 0;
for (dword i = 0; i < header->e_shnum; i++)
{
if (shdrs[i].sh_type == 2)
{
symtab_sh = (ELF::Private::Elf32_Shdr*)&shdrs[i];
symtab = (ELF::Private::Elf32_Sym*)(filebase + symtab_sh->sh_offset);
strtab = (char*)(filebase + shdrs[symtab_sh->sh_link].sh_offset);
break;
}
}
if (!symtab_sh || !symtab || !strtab)
{
Video::Print("\nOne of symbol table section header, symbol table or string table can not be found\n");
Keyboard::WaitForKeyDown();
return 0;
}
//go through symbol table to find symbol
for (dword i = 0; i < (symtab_sh->sh_size / sizeof(ELF::Private::Elf32_Sym)); i++)
{
if (symtab[i].st_name == 0) //bad name
continue;
//grab name
char* ext_symname = (char*)(strtab + symtab[i].st_name);
if (CompareStrings(symname, ext_symname) && symtab[i].st_value!= 0)
{
//Video::Print(ext_symname);Keyboard::WaitForKeyDown();
return symtab[i].st_value;
}
}
return 0;
}
//if Section Name="" -> looking up key for witout section
CString CIniEx::GetValue(CString Section,CString Key,CString DefaultValue/*=""*/)
{
int nIndex=LookupSection(&Section);
if (nIndex==-1) return DefaultValue;
int nRet;
CString retStr;
for (INT_PTR i=m_Keys[nIndex]->GetUpperBound();i>=0;i--)
{
nRet=CompareStrings(&(m_Keys[nIndex]->GetAt(i)),&Key);
if (nRet==0)
{
retStr=m_Values[nIndex]->GetAt(i);
/*int nPlace=retStr.ReverseFind(';');
if (nPlace!=-1)
retStr.Delete(nPlace,retStr.GetLength()-nPlace);*/
return retStr;
}
}
return DefaultValue;
}
stPosicion PAT_Informacion(char *c)
{
char cVelocidad[10]={0};
static int iElementos=0;
stPosicion p = MistPosicion;
//obtiene el indice de la velocidad
iElementos = ListNumItems(miLista);
for (int i=0;i<iElementos;i++)
{
ListGetItem(miLista, &p, i+1);
if (CompareStrings(p.cDescripcion, 0, c, 0, 0)==0)
{
i=iElementos;
}
}
return p;
}
CompareResult SemanticVersion::Compare(const SemanticVersion& version) const {
if (major != version.major)
return major < version.major ? kLessThan : kGreaterThan;
if (minor != version.minor)
return minor < version.minor ? kLessThan : kGreaterThan;
if (patch != version.patch)
return patch < version.patch ? kLessThan : kGreaterThan;
if (prerelease_identifiers != version.prerelease_identifiers) {
if (prerelease_identifiers.empty() &&
!version.prerelease_identifiers.empty())
return kGreaterThan;
if (!prerelease_identifiers.empty() &&
version.prerelease_identifiers.empty())
return kLessThan;
std::vector<string_t> identifiers_, identifiers;
Split(prerelease_identifiers, L".", identifiers_);
Split(version.prerelease_identifiers, L".", identifiers);
size_t min_size = min(identifiers_.size(), identifiers.size());
for (size_t i = 0; i < min_size; ++i) {
if (IsNumeric(identifiers_.at(i)) && IsNumeric(identifiers.at(i))) {
int lhs = ToInt(identifiers_.at(i));
int rhs = ToInt(identifiers.at(i));
if (lhs != rhs)
return lhs < rhs ? kLessThan : kGreaterThan;
} else {
int result = CompareStrings(identifiers_.at(i), identifiers.at(i));
if (result != 0)
return result < 0 ? kLessThan : kGreaterThan;
}
}
if (identifiers_.size() != identifiers.size())
return identifiers_.size() < identifiers.size() ?
kLessThan : kGreaterThan;
}
return kEqualTo;
}
//writes Key=value given section
void CIniEx::SetValue(CString Section,CString Key,CString Value)
{
//file opened?
ASSERT(!m_FileName.IsEmpty());
//if given key already existing, overwrite it
int nIndex=LookupSection(&Section);
int nKeyIndex;
if (nIndex==-1)
{
//if key not exist grow arrays (if necessary)
m_Changed=TRUE;
m_SectionNo++;
GrowIfNecessary();
m_Keys[m_SectionNo-1]=new CStringArray;
m_Values[m_SectionNo-1]=new CStringArray;
nIndex=m_SectionNo-1;
m_Sections.SetAtGrow(m_SectionNo-1,Section);
}
//looking up keys for section
nKeyIndex=LookupKey(nIndex,&Key);
//if key exist -> overwrite it
//if not add to end of array
if (nKeyIndex!=-1)
{
if (CompareStrings(&m_Values[nIndex]->GetAt(nKeyIndex),&Value)!=0)
m_Changed=TRUE;
m_Values[nIndex]->SetAt(nKeyIndex,Value);
}
else //if not exist
{
m_Changed=TRUE;
m_Keys[nIndex]->Add(Key);
m_Values[nIndex]->Add(Value);
}
}
void FeedConditionDialog::ChooseElement(int element_index) {
// Operator
LPARAM op_data = operator_combo_.GetItemData(operator_combo_.GetCurSel());
operator_combo_.ResetContent();
#define ADD_OPERATOR(op) \
operator_combo_.AddItem(Aggregator.filter_manager.TranslateOperator(op).c_str(), op);
switch (element_index) {
case FEED_FILTER_ELEMENT_META_ID:
case FEED_FILTER_ELEMENT_EPISODE_NUMBER:
case FEED_FILTER_ELEMENT_META_DATE_START:
case FEED_FILTER_ELEMENT_META_DATE_END:
case FEED_FILTER_ELEMENT_META_EPISODES:
ADD_OPERATOR(FEED_FILTER_OPERATOR_EQUALS);
ADD_OPERATOR(FEED_FILTER_OPERATOR_NOTEQUALS);
ADD_OPERATOR(FEED_FILTER_OPERATOR_ISGREATERTHAN);
ADD_OPERATOR(FEED_FILTER_OPERATOR_ISGREATERTHANOREQUALTO);
ADD_OPERATOR(FEED_FILTER_OPERATOR_ISLESSTHAN);
ADD_OPERATOR(FEED_FILTER_OPERATOR_ISLESSTHANOREQUALTO);
break;
case FEED_FILTER_ELEMENT_LOCAL_EPISODE_AVAILABLE:
case FEED_FILTER_ELEMENT_META_STATUS:
case FEED_FILTER_ELEMENT_META_TYPE:
case FEED_FILTER_ELEMENT_USER_STATUS:
ADD_OPERATOR(FEED_FILTER_OPERATOR_EQUALS);
ADD_OPERATOR(FEED_FILTER_OPERATOR_NOTEQUALS);
break;
case FEED_FILTER_ELEMENT_EPISODE_TITLE:
case FEED_FILTER_ELEMENT_EPISODE_GROUP:
case FEED_FILTER_ELEMENT_EPISODE_VIDEO_TYPE:
case FEED_FILTER_ELEMENT_FILE_TITLE:
case FEED_FILTER_ELEMENT_FILE_CATEGORY:
case FEED_FILTER_ELEMENT_FILE_DESCRIPTION:
case FEED_FILTER_ELEMENT_FILE_LINK:
ADD_OPERATOR(FEED_FILTER_OPERATOR_EQUALS);
ADD_OPERATOR(FEED_FILTER_OPERATOR_NOTEQUALS);
ADD_OPERATOR(FEED_FILTER_OPERATOR_BEGINSWITH);
ADD_OPERATOR(FEED_FILTER_OPERATOR_ENDSWITH);
ADD_OPERATOR(FEED_FILTER_OPERATOR_CONTAINS);
ADD_OPERATOR(FEED_FILTER_OPERATOR_NOTCONTAINS);
break;
default:
for (int i = 0; i < FEED_FILTER_OPERATOR_COUNT; i++) {
ADD_OPERATOR(i);
}
}
#undef ADD_OPERATOR
int op_index = operator_combo_.FindItemData(op_data);
if (op_index == CB_ERR)
op_index = 0;
operator_combo_.SetCurSel(op_index);
// ===========================================================================
// Value
value_combo_.ResetContent();
RECT rect;
value_combo_.GetWindowRect(&rect);
int width = rect.right - rect.left;
int height = rect.bottom - rect.top;
::ScreenToClient(m_hWindow, reinterpret_cast<LPPOINT>(&rect));
#define RECREATE_COMBO(style) \
value_combo_.Create(0, WC_COMBOBOX, nullptr, \
style | CBS_AUTOHSCROLL | WS_CHILD | WS_TABSTOP | WS_VISIBLE | WS_VSCROLL, \
rect.left, rect.top, width, height * 2, \
m_hWindow, nullptr, nullptr);
switch (element_index) {
case FEED_FILTER_ELEMENT_FILE_CATEGORY:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"Anime");
value_combo_.AddString(L"Batch");
value_combo_.AddString(L"Hentai");
value_combo_.AddString(L"Non-English");
value_combo_.AddString(L"Other");
value_combo_.AddString(L"Raws");
break;
case FEED_FILTER_ELEMENT_META_ID:
case FEED_FILTER_ELEMENT_EPISODE_TITLE: {
RECREATE_COMBO((element_index == FEED_FILTER_ELEMENT_META_ID ? CBS_DROPDOWNLIST : CBS_DROPDOWN));
typedef std::pair<int, wstring> anime_pair;
vector<anime_pair> title_list;
for (auto it = AnimeDatabase.items.begin(); it != AnimeDatabase.items.end(); ++it) {
switch (it->second.GetMyStatus()) {
case mal::MYSTATUS_NOTINLIST:
case mal::MYSTATUS_COMPLETED:
case mal::MYSTATUS_DROPPED:
continue;
default:
title_list.push_back(std::make_pair(it->second.GetId(),
AnimeDatabase.FindItem(it->second.GetId())->GetTitle()));
}
}
std::sort(title_list.begin(), title_list.end(),
[](const anime_pair& a1, const anime_pair& a2) {
return CompareStrings(a1.second, a2.second) < 0;
});
if (element_index == FEED_FILTER_ELEMENT_META_ID) {
value_combo_.AddString(L"(Unknown)");
}
for (auto it = title_list.begin(); it != title_list.end(); ++it) {
value_combo_.AddItem(it->second.c_str(), it->first);
}
break;
}
case FEED_FILTER_ELEMENT_META_DATE_START:
case FEED_FILTER_ELEMENT_META_DATE_END:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(static_cast<wstring>(GetDate()).c_str());
value_combo_.SetCueBannerText(L"YYYY-MM-DD");
break;
case FEED_FILTER_ELEMENT_META_STATUS:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddItem(mal::TranslateStatus(mal::STATUS_AIRING).c_str(), mal::STATUS_AIRING);
value_combo_.AddItem(mal::TranslateStatus(mal::STATUS_FINISHED).c_str(), mal::STATUS_FINISHED);
value_combo_.AddItem(mal::TranslateStatus(mal::STATUS_NOTYETAIRED).c_str(), mal::STATUS_NOTYETAIRED);
break;
case FEED_FILTER_ELEMENT_META_TYPE:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddItem(mal::TranslateType(mal::TYPE_TV).c_str(), mal::TYPE_TV);
value_combo_.AddItem(mal::TranslateType(mal::TYPE_OVA).c_str(), mal::TYPE_OVA);
value_combo_.AddItem(mal::TranslateType(mal::TYPE_MOVIE).c_str(), mal::TYPE_MOVIE);
value_combo_.AddItem(mal::TranslateType(mal::TYPE_SPECIAL).c_str(), mal::TYPE_SPECIAL);
value_combo_.AddItem(mal::TranslateType(mal::TYPE_ONA).c_str(), mal::TYPE_ONA);
value_combo_.AddItem(mal::TranslateType(mal::TYPE_MUSIC).c_str(), mal::TYPE_MUSIC);
break;
case FEED_FILTER_ELEMENT_USER_STATUS:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddItem(mal::TranslateMyStatus(mal::MYSTATUS_NOTINLIST, false).c_str(), mal::MYSTATUS_NOTINLIST);
value_combo_.AddItem(mal::TranslateMyStatus(mal::MYSTATUS_WATCHING, false).c_str(), mal::MYSTATUS_WATCHING);
value_combo_.AddItem(mal::TranslateMyStatus(mal::MYSTATUS_COMPLETED, false).c_str(), mal::MYSTATUS_COMPLETED);
value_combo_.AddItem(mal::TranslateMyStatus(mal::MYSTATUS_ONHOLD, false).c_str(), mal::MYSTATUS_ONHOLD);
value_combo_.AddItem(mal::TranslateMyStatus(mal::MYSTATUS_DROPPED, false).c_str(), mal::MYSTATUS_DROPPED);
value_combo_.AddItem(mal::TranslateMyStatus(mal::MYSTATUS_PLANTOWATCH, false).c_str(), mal::MYSTATUS_PLANTOWATCH);
break;
case FEED_FILTER_ELEMENT_EPISODE_NUMBER:
case FEED_FILTER_ELEMENT_META_EPISODES:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"%watched%");
value_combo_.AddString(L"%total%");
break;
case FEED_FILTER_ELEMENT_EPISODE_VERSION:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"2");
value_combo_.AddString(L"3");
value_combo_.AddString(L"4");
value_combo_.AddString(L"0");
break;
case FEED_FILTER_ELEMENT_LOCAL_EPISODE_AVAILABLE:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddString(L"False");
value_combo_.AddString(L"True");
break;
case FEED_FILTER_ELEMENT_EPISODE_VIDEO_RESOLUTION:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"1080p");
value_combo_.AddString(L"720p");
value_combo_.AddString(L"480p");
value_combo_.AddString(L"400p");
break;
case FEED_FILTER_ELEMENT_EPISODE_VIDEO_TYPE:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"h264");
value_combo_.AddString(L"x264");
value_combo_.AddString(L"XviD");
break;
default:
RECREATE_COMBO(CBS_DROPDOWN);
break;
}
#undef RECREATE_COMBO
value_combo_.SetCurSel(0);
}
void FeedConditionDialog::ChooseElement(int element_index) {
// Operator
LPARAM op_data = operator_combo_.GetItemData(operator_combo_.GetCurSel());
operator_combo_.ResetContent();
#define ADD_OPERATOR(op) \
operator_combo_.AddItem(Aggregator.filter_manager.TranslateOperator(op).c_str(), op);
switch (element_index) {
case kFeedFilterElement_Meta_Id:
case kFeedFilterElement_Episode_Number:
case kFeedFilterElement_Meta_DateStart:
case kFeedFilterElement_Meta_DateEnd:
case kFeedFilterElement_Meta_Episodes:
ADD_OPERATOR(kFeedFilterOperator_Equals);
ADD_OPERATOR(kFeedFilterOperator_NotEquals);
ADD_OPERATOR(kFeedFilterOperator_IsGreaterThan);
ADD_OPERATOR(kFeedFilterOperator_IsGreaterThanOrEqualTo);
ADD_OPERATOR(kFeedFilterOperator_IsLessThan);
ADD_OPERATOR(kFeedFilterOperator_IsLessThanOrEqualTo);
break;
case kFeedFilterElement_Local_EpisodeAvailable:
case kFeedFilterElement_Meta_Status:
case kFeedFilterElement_Meta_Type:
case kFeedFilterElement_User_Status:
ADD_OPERATOR(kFeedFilterOperator_Equals);
ADD_OPERATOR(kFeedFilterOperator_NotEquals);
break;
case kFeedFilterElement_Episode_Title:
case kFeedFilterElement_Episode_Group:
case kFeedFilterElement_Episode_VideoType:
case kFeedFilterElement_File_Title:
case kFeedFilterElement_File_Category:
case kFeedFilterElement_File_Description:
case kFeedFilterElement_File_Link:
ADD_OPERATOR(kFeedFilterOperator_Equals);
ADD_OPERATOR(kFeedFilterOperator_NotEquals);
ADD_OPERATOR(kFeedFilterOperator_BeginsWith);
ADD_OPERATOR(kFeedFilterOperator_EndsWith);
ADD_OPERATOR(kFeedFilterOperator_Contains);
ADD_OPERATOR(kFeedFilterOperator_NotContains);
break;
default:
for (int i = 0; i < kFeedFilterOperator_Count; i++) {
ADD_OPERATOR(i);
}
}
#undef ADD_OPERATOR
int op_index = operator_combo_.FindItemData(op_data);
if (op_index == CB_ERR)
op_index = 0;
operator_combo_.SetCurSel(op_index);
//////////////////////////////////////////////////////////////////////////////
// Value
value_combo_.ResetContent();
RECT rect;
value_combo_.GetWindowRect(&rect);
int width = rect.right - rect.left;
int height = rect.bottom - rect.top;
::ScreenToClient(GetWindowHandle(), reinterpret_cast<LPPOINT>(&rect));
#define RECREATE_COMBO(style) \
value_combo_.Create(0, WC_COMBOBOX, nullptr, \
style | CBS_AUTOHSCROLL | WS_CHILD | WS_TABSTOP | WS_VISIBLE | WS_VSCROLL, \
rect.left, rect.top, width, height * 2, \
GetWindowHandle(), nullptr, nullptr);
switch (element_index) {
case kFeedFilterElement_File_Category:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"Anime");
value_combo_.AddString(L"Batch");
value_combo_.AddString(L"Hentai");
value_combo_.AddString(L"Non-English");
value_combo_.AddString(L"Other");
value_combo_.AddString(L"Raws");
break;
case kFeedFilterElement_Meta_Id:
case kFeedFilterElement_Episode_Title: {
RECREATE_COMBO((element_index == kFeedFilterElement_Meta_Id ? CBS_DROPDOWNLIST : CBS_DROPDOWN));
typedef std::pair<int, std::wstring> anime_pair;
std::vector<anime_pair> title_list;
for (auto it = AnimeDatabase.items.begin(); it != AnimeDatabase.items.end(); ++it) {
switch (it->second.GetMyStatus()) {
case anime::kNotInList:
case anime::kCompleted:
case anime::kDropped:
continue;
default:
title_list.push_back(std::make_pair(
it->second.GetId(),
AnimeDatabase.FindItem(it->second.GetId())->GetTitle()));
}
}
std::sort(title_list.begin(), title_list.end(),
[](const anime_pair& a1, const anime_pair& a2) {
return CompareStrings(a1.second, a2.second) < 0;
});
if (element_index == kFeedFilterElement_Meta_Id)
value_combo_.AddString(L"(Unknown)");
foreach_(it, title_list)
value_combo_.AddItem(it->second.c_str(), it->first);
break;
}
case kFeedFilterElement_Meta_DateStart:
case kFeedFilterElement_Meta_DateEnd:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(static_cast<std::wstring>(GetDate()).c_str());
value_combo_.SetCueBannerText(L"YYYY-MM-DD");
break;
case kFeedFilterElement_Meta_Status:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddItem(anime::TranslateStatus(anime::kAiring).c_str(), anime::kAiring);
value_combo_.AddItem(anime::TranslateStatus(anime::kFinishedAiring).c_str(), anime::kFinishedAiring);
value_combo_.AddItem(anime::TranslateStatus(anime::kNotYetAired).c_str(), anime::kNotYetAired);
break;
case kFeedFilterElement_Meta_Type:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddItem(anime::TranslateType(anime::kTv).c_str(), anime::kTv);
value_combo_.AddItem(anime::TranslateType(anime::kOva).c_str(), anime::kOva);
value_combo_.AddItem(anime::TranslateType(anime::kMovie).c_str(), anime::kMovie);
value_combo_.AddItem(anime::TranslateType(anime::kSpecial).c_str(), anime::kSpecial);
value_combo_.AddItem(anime::TranslateType(anime::kOna).c_str(), anime::kOna);
value_combo_.AddItem(anime::TranslateType(anime::kMusic).c_str(), anime::kMusic);
break;
case kFeedFilterElement_User_Status:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddItem(anime::TranslateMyStatus(anime::kNotInList, false).c_str(), anime::kNotInList);
value_combo_.AddItem(anime::TranslateMyStatus(anime::kWatching, false).c_str(), anime::kWatching);
value_combo_.AddItem(anime::TranslateMyStatus(anime::kCompleted, false).c_str(), anime::kCompleted);
value_combo_.AddItem(anime::TranslateMyStatus(anime::kOnHold, false).c_str(), anime::kOnHold);
value_combo_.AddItem(anime::TranslateMyStatus(anime::kDropped, false).c_str(), anime::kDropped);
value_combo_.AddItem(anime::TranslateMyStatus(anime::kPlanToWatch, false).c_str(), anime::kPlanToWatch);
break;
case kFeedFilterElement_Episode_Number:
case kFeedFilterElement_Meta_Episodes:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"%watched%");
value_combo_.AddString(L"%total%");
break;
case kFeedFilterElement_Episode_Version:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"2");
value_combo_.AddString(L"3");
value_combo_.AddString(L"4");
value_combo_.AddString(L"0");
break;
case kFeedFilterElement_Local_EpisodeAvailable:
RECREATE_COMBO(CBS_DROPDOWNLIST);
value_combo_.AddString(L"False");
value_combo_.AddString(L"True");
break;
case kFeedFilterElement_Episode_VideoResolution:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"1080p");
value_combo_.AddString(L"720p");
value_combo_.AddString(L"480p");
value_combo_.AddString(L"400p");
break;
case kFeedFilterElement_Episode_VideoType:
RECREATE_COMBO(CBS_DROPDOWN);
value_combo_.AddString(L"h264");
value_combo_.AddString(L"x264");
value_combo_.AddString(L"XviD");
break;
default:
RECREATE_COMBO(CBS_DROPDOWN);
break;
}
#undef RECREATE_COMBO
value_combo_.SetCurSel(0);
}
bool EvaluateCondition(const FeedFilterCondition& condition,
const FeedItem& item) {
bool is_numeric = false;
std::wstring element;
std::wstring value = ReplaceVariables(condition.value, item.episode_data);
auto anime = AnimeDatabase.FindItem(item.episode_data.anime_id);
switch (condition.element) {
case kFeedFilterElement_File_Title:
element = item.title;
break;
case kFeedFilterElement_File_Category:
element = item.category;
break;
case kFeedFilterElement_File_Description:
element = item.description;
break;
case kFeedFilterElement_File_Link:
element = item.link;
break;
case kFeedFilterElement_Meta_Id:
if (anime)
element = ToWstr(anime->GetId());
is_numeric = true;
break;
case kFeedFilterElement_Episode_Title:
element = item.episode_data.title;
break;
case kFeedFilterElement_Meta_DateStart:
if (anime)
element = anime->GetDateStart();
break;
case kFeedFilterElement_Meta_DateEnd:
if (anime)
element = anime->GetDateEnd();
break;
case kFeedFilterElement_Meta_Episodes:
if (anime)
element = ToWstr(anime->GetEpisodeCount());
is_numeric = true;
break;
case kFeedFilterElement_Meta_Status:
if (anime)
element = ToWstr(anime->GetAiringStatus());
is_numeric = true;
break;
case kFeedFilterElement_Meta_Type:
if (anime)
element = ToWstr(anime->GetType());
is_numeric = true;
break;
case kFeedFilterElement_User_Status:
if (anime)
element = ToWstr(anime->GetMyStatus());
is_numeric = true;
break;
case kFeedFilterElement_Episode_Number:
element = ToWstr(anime::GetEpisodeHigh(item.episode_data.number));
is_numeric = true;
break;
case kFeedFilterElement_Episode_Version:
element = item.episode_data.version;
if (element.empty())
element = L"1";
is_numeric = true;
break;
case kFeedFilterElement_Local_EpisodeAvailable:
if (anime)
element = ToWstr(anime->IsEpisodeAvailable(
anime::GetEpisodeHigh(item.episode_data.number)));
is_numeric = true;
break;
case kFeedFilterElement_Episode_Group:
element = item.episode_data.group;
break;
case kFeedFilterElement_Episode_VideoResolution:
element = item.episode_data.resolution;
break;
case kFeedFilterElement_Episode_VideoType:
element = item.episode_data.video_type;
break;
}
switch (condition.op) {
case kFeedFilterOperator_Equals:
if (is_numeric) {
if (IsEqual(value, L"True"))
return ToInt(element) == TRUE;
return ToInt(element) == ToInt(value);
} else {
if (condition.element == kFeedFilterElement_Episode_VideoResolution) {
return anime::TranslateResolution(element) == anime::TranslateResolution(condition.value);
} else {
return IsEqual(element, value);
}
}
case kFeedFilterOperator_NotEquals:
if (is_numeric) {
if (IsEqual(value, L"True"))
return ToInt(element) == TRUE;
return ToInt(element) != ToInt(value);
} else {
if (condition.element == kFeedFilterElement_Episode_VideoResolution) {
return anime::TranslateResolution(element) != anime::TranslateResolution(condition.value);
} else {
return !IsEqual(element, value);
}
}
case kFeedFilterOperator_IsGreaterThan:
if (is_numeric) {
return ToInt(element) > ToInt(value);
} else {
if (condition.element == kFeedFilterElement_Episode_VideoResolution) {
return anime::TranslateResolution(element) > anime::TranslateResolution(condition.value);
} else {
return CompareStrings(element, condition.value) > 0;
}
}
case kFeedFilterOperator_IsGreaterThanOrEqualTo:
if (is_numeric) {
return ToInt(element) >= ToInt(value);
} else {
if (condition.element == kFeedFilterElement_Episode_VideoResolution) {
return anime::TranslateResolution(element) >= anime::TranslateResolution(condition.value);
} else {
return CompareStrings(element, condition.value) >= 0;
}
}
case kFeedFilterOperator_IsLessThan:
if (is_numeric) {
return ToInt(element) < ToInt(value);
} else {
if (condition.element == kFeedFilterElement_Episode_VideoResolution) {
return anime::TranslateResolution(element) < anime::TranslateResolution(condition.value);
} else {
return CompareStrings(element, condition.value) < 0;
}
}
case kFeedFilterOperator_IsLessThanOrEqualTo:
if (is_numeric) {
return ToInt(element) <= ToInt(value);
} else {
if (condition.element == kFeedFilterElement_Episode_VideoResolution) {
return anime::TranslateResolution(element) <= anime::TranslateResolution(condition.value);
} else {
return CompareStrings(element, condition.value) <= 0;
}
}
case kFeedFilterOperator_BeginsWith:
return StartsWith(element, value);
case kFeedFilterOperator_EndsWith:
return EndsWith(element, value);
case kFeedFilterOperator_Contains:
return InStr(element, value, 0, true) > -1;
case kFeedFilterOperator_NotContains:
return InStr(element, value, 0, true) == -1;
}
return false;
}
int main(int argc, char** argv)
{
bool32 FlagActivated = 0;
for(int i=0;
i < argc;
i++)
{
char Flag[MAX_FLAG_CHAR];
// NOTE: '-' Indicate that a flag name is what comes next
if(argv[i][0] == '-')
{
int IndexArray = 0;
for(argv[i][1];
*argv[i];
argv[i]++)
{
if (IndexArray < (MAX_FLAG_CHAR - 1))
{
Flag[IndexArray] = *argv[i];
IndexArray++;
}
}
if (CompareStrings(Flag, "-h", 2) == 0)
{
FlagActivated = FlagActivated|HELP_FLAG; //0x00
ShowHelpPage();
}
else if (CompareStrings(Flag, "-cc", 3) == 0)
{
FlagActivated = FlagActivated|CHANGE_TARGET_DIRECTORY_FLAG; // 0x01
}
else if (CompareStrings(Flag, "-s", 2) == 0)
{
FlagActivated = FlagActivated|SOURCE_FILE_FLAG; // 0x02
}
else
{
// logging
}
}
// NOTE: '@' represents char that indicates that what comes next is an diretory
else if(argv[i][0] == '@')
{
}
else
{
// logging
}
}
bool Running = true;
bool ProjectAssigned = false;
tree_directory *TreeRootDirectory;
tree_directory *TreeActualDirectory;
char PathToPrepend[MAX_PATH_SIZE];
WelcomeMessage();
while(Running)
{
char CommandLine[MAX_LINE_SIZE];
char CLineLowerCase[MAX_LINE_SIZE];
char CommandName[MAX_LINE_SIZE];
char CommandAction[MAX_LINE_SIZE];
printf("\nC-environment Shell> ");
// TODO: Make space before first world do not count for the string comparisons
gets_s(CommandLine, MAX_LINE_SIZE);
IgnoreSpaces(CommandLine, CharArrayCount(CommandLine));
printf("CommandLine without spaces before: '%s'", CommandLine);
BreakString(CommandLine, CharArrayCount(CLineLowerCase), CommandName,
CommandAction, SPACE_CHAR);
ToLowerCase(CommandName, CLineLowerCase, MAX_LINE_SIZE);
#if 0
// NOTE: Debug Lines
printf("CommandLine: %s\tCLineLowerCase: %s\nCommandAction: %s",CommandLine,
CLineLowerCase, CommandAction);
#endif
// TODO: Program still have some problems with parsing the input with spaces before command
if(CompareStrings(CLineLowerCase, "setprojectname", sizeof("setprojectname")) == 0)
{
if (IS_EMPTY_STRING(CommandAction))
{
printf("\nAction for command '%s' not found\n Usage:\t'%s [Project Name]'\n",
CLineLowerCase, CLineLowerCase);
}
TreeRootDirectory = TreeDirectoryCreate(CommandAction);
TreeActualDirectory = TreeRootDirectory;
StringCopy(PathToPrepend, CommandAction, CharArrayCount(CommandAction));
AppendString(PathToPrepend, "/");
ProjectAssigned = true;
}
else if(CompareStrings(CLineLowerCase, "createdir", sizeof("createdir")) == 0)
{
char ActualPath[MAX_PATH_SIZE];
StringCopy(ActualPath, PathToPrepend, CharArrayCount(PathToPrepend));
if (ProjectAssigned && !IS_EMPTY_STRING(CommandAction))
{
// TODO: Parse if the directory name is valid
// TODO: Prevent PathToPrepend to grow
AppendString(PathToPrepend, CommandAction);
AppendString(PathToPrepend, "/");
// TODO: Virtual file system structured in a tree
tree_directory *TreeDirectory = TreeDirectoryCreate(ActualPath);
// NOTE: More debug lines
printf("Path: %s", ActualPath);
printf("Path2: %s", TreeDirectory->PathName);
TreeDirectoryAddNode(TreeActualDirectory, TreeDirectory);
}
else if (!ProjectAssigned)
{
// TODO: logging system
}
else if (IS_EMPTY_STRING(CommandAction))
{
// TODO: Logging system
}
StringCopy(PathToPrepend, ActualPath, CharArrayCount(ActualPath));
}
// TODO: Not sure how to do pathfinder right now!
else if(CompareStrings(CLineLowerCase, "setdir", sizeof("setdir")) == 0)
{
char *DirName = CommandAction;
if (!IS_EMPTY_STRING(CommandAction))
{
if (TreeDirSearchBrother(TreeActualDirectory, DirName))
{
AppendString(PathToPrepend, CommandAction);
AppendString(PathToPrepend, "/");
TreeDirGoToDirectory(TreeActualDirectory, DirName);
}
}
}
else if(CompareStrings(CLineLowerCase, "saveconfig", sizeof("saveconfig")) == 0)
{
// TODO: Save settings to a file, that can be evoked lately, or in any other
// instance of the program
}
else if(CompareStrings(CLineLowerCase, "exit", sizeof("exit")) == 0)
{
Running = false;
}
else
{
printf("\nCommand not found. Type '-h' for help. Command 'exit' is self explanatory.\n");
}
}
return 0;
}
//CLEAR SCREEN (ACCEPTS COLOUR AS PARAMETER)
void Commands::ClearScreen()
{
byte foreground = 0;
byte background = 0;
byte blinking = 0;
Video::ClearScreen();
Video::Print("Background Colour Options:");
Video::NewLine();
//Background
BackGround:
Video::Print("Black Blue Green Red Aqua Violet Orange White ");
Video::Print(" ", 0);
Video::Print(" ", 16);
Video::Print(" ", 32);
Video::Print(" ", 64);
Video::Print(" ", 48);
Video::Print(" ", 80);
Video::Print(" ", 96);
Video::Print(" ", 112);
Video::Print("Type in the name of the colour: ");
static char colour[10];
byte colourCounter = 0;
while (true)
{
Keyboard::AsciiKey key = Keyboard::GetAsciiKey();
if (key.IsBreak == true)
continue;
if (key.Data != 0)
{
if (key.Data == 19)
{
if (colourCounter == 0)
continue;
Video::BackSpace();
colourCounter--;
colour[colourCounter] = 0;
}
if (key.Data == 2)
{
colour[colourCounter] = 0;
Video::NewLine();
break;
}
continue;
}
char keyPrint[2] = {0};
keyPrint[0] = key.Char;
Video::Print(keyPrint);
colour[colourCounter] = key.Char;
colourCounter++;
if (colourCounter == 9)
{
Video::NewLine();
Video::Print("Invalid Colour, Enter Proper Value");
Video::NewLine();
goto BackGround;
}
}
if (CompareStrings(colour, "Black"))
{
background = 0;
}
else if (CompareStrings(colour, "Blue"))
{
background = 16;
}
else if (CompareStrings(colour, "Green"))
{
background = 32;
}
else if (CompareStrings(colour, "Red"))
{
background = 64;
}
else if (CompareStrings(colour, "Aqua"))
{
background = 48;
}
else if (CompareStrings(colour, "Violet"))
{
background = 80;
}
else if (CompareStrings(colour, "Orange"))
{
background = 96;
}
else if (CompareStrings(colour, "White"))
{
background = 112;
}
else
{
Video::Print("Invalid Colour");
Video::NewLine();
goto BackGround;
}
//ForGround
ForeGround:
Video::NewLine();
Video::Print("Foreground Colour Options:");
Video::NewLine();
Video::Print("Black Blue Green Red Aqua Violet Orange White ");
Video::Print("Foreground", 0 | background);
Video::Print("Foreground", 1 | background);
Video::Print("Foreground", 2 | background);
Video::Print("Foreground", 4 | background);
Video::Print("Foreground", 3 | background);
Video::Print("Foreground", 5 | background);
Video::Print("Foreground", 6 | background);
Video::Print("Foreground", 7 | background);
Video::Print("Type in the name of the colour: ");
static char colourf[10];
byte colourCounterf = 0;
while (true)
{
Keyboard::AsciiKey key = Keyboard::GetAsciiKey();
if (key.IsBreak == true)
continue;
if (key.Data != 0)
{
if (key.Data == 19)
{
if (colourCounterf == 0)
continue;
Video::BackSpace();
colourCounterf--;
colourf[colourCounterf] = 0;
}
if (key.Data == 2)
{
colourf[colourCounterf] = 0;
Video::NewLine();
break;
}
continue;
}
char keyPrint[2] = {0};
keyPrint[0] = key.Char;
Video::Print(keyPrint);
colourf[colourCounterf] = key.Char;
colourCounterf++;
if (colourCounterf == 9)
{
Video::NewLine();
Video::Print("Invalid Colour, Enter Proper Value");
Video::NewLine();
goto ForeGround;
}
}
if (CompareStrings(colourf, "Black"))
{
foreground = 0;
}
else if (CompareStrings(colourf, "Blue"))
{
foreground = 1;
}
else if (CompareStrings(colourf, "Green"))
{
foreground = 2;
}
else if (CompareStrings(colourf, "Red"))
{
foreground = 4;
}
else if (CompareStrings(colourf, "Aqua"))
{
foreground = 3;
}
else if (CompareStrings(colourf, "Violet"))
{
foreground = 5;
}
else if (CompareStrings(colourf, "Orange"))
{
foreground = 6;
}
else if (CompareStrings(colourf, "White"))
{
foreground = 7;
}
else
{
Video::Print("Invalid Colour");
Video::NewLine();
goto ForeGround;
}
//Light
Video::NewLine();
Video::Print("Do you wish to have a light foreground colour? (y/n): ");
while (true)
{
Keyboard::AsciiKey key = Keyboard::GetAsciiKey();
if (key.IsBreak == true)
{
continue;
}
if (key.Char == 'y')
{
Video::Print("y");
foreground |= 8;
break;
}
if (key.Char == 'n')
{
Video::Print("n");
break;
}
}
Video::NewLine();
//Blinking
Video::Print("Do you wish to have the foreground blinking? (y/n): ");
while (true)
{
Keyboard::AsciiKey key = Keyboard::GetAsciiKey();
if (key.IsBreak == true)
{
continue;
}
if (key.Char == 'y')
{
Video::Print("y");
foreground |= 128;
break;
}
if (key.Char == 'n')
{
Video::Print("n");
break;
}
}
DefaultColour = (background | foreground | blinking);
Video::ClearScreen((background | foreground | blinking));
}
//Pauses Operating System
void Commands::Sleep()
{
char password[200];
byte passwordCounter = 0;
Video::Print("Please enter your desired password: "******" ");
password[passwordCounter] = 0;
break;
}
continue;
}
char keychar[2] = {0};
keychar[0] = key.Char;
Video::Print(keychar);
password[passwordCounter] = key.Char;
passwordCounter++;
if (passwordCounter == 200)
{
break;
}
}
Video::Print("Saving...");
PIT::StartSystemTimer(1);
passwordCounter += 10;
for (word i = 0; i < passwordCounter; i++)
{
Video::BackSpace();
}
Video::NewLine();
Video::Print("How many seconds do you want to sleep? ");
dword numbers[10] = {0};
byte numberCounter = 0;
dword number = GetNumber();
char colourholder = Video::CurrentColour();
Video::ChangeColour(00);
PIT::StartSystemTimer(number);
Video::ChangeColour(colourholder);
Password:
char password2[200];
byte passwordCounter2 = 0;
Video::Print("Please enter your password: "******"Password Approved.");
Video::NewLine();
}
else
{
Video::Print("Invalid Password.");
Video::NewLine();
goto Password;
}
}
// Public method for computing the combiner features. The agreement
// output parameter will be true if both answers are identical,
// and false otherwise.
bool TesseractCubeCombiner::ComputeCombinerFeatures(const string &tess_str,
int tess_confidence,
CubeObject *cube_obj,
WordAltList *cube_alt_list,
vector<double> *features,
bool *agreement) {
features->clear();
*agreement = false;
if (cube_alt_list == NULL || cube_alt_list->AltCount() <= 0)
return false;
// Get Cube's best string; return false if empty
char_32 *cube_best_str32 = cube_alt_list->Alt(0);
if (cube_best_str32 == NULL || CubeUtils::StrLen(cube_best_str32) < 1)
return false;
string cube_best_str;
int cube_best_cost = cube_alt_list->AltCost(0);
int cube_best_bigram_cost = 0;
bool cube_best_bigram_cost_valid = true;
if (cube_cntxt_->Bigrams())
cube_best_bigram_cost = cube_cntxt_->Bigrams()->
Cost(cube_best_str32, cube_cntxt_->CharacterSet());
else
cube_best_bigram_cost_valid = false;
CubeUtils::UTF32ToUTF8(cube_best_str32, &cube_best_str);
// Get Tesseract's UTF32 string
string_32 tess_str32;
CubeUtils::UTF8ToUTF32(tess_str.c_str(), &tess_str32);
// Compute agreement flag
*agreement = (tess_str.compare(cube_best_str) == 0);
// Get Cube's second best string; if empty, return false
char_32 *cube_next_best_str32;
string cube_next_best_str;
int cube_next_best_cost = WORST_COST;
if (cube_alt_list->AltCount() > 1) {
cube_next_best_str32 = cube_alt_list->Alt(1);
if (cube_next_best_str32 == NULL ||
CubeUtils::StrLen(cube_next_best_str32) == 0) {
return false;
}
cube_next_best_cost = cube_alt_list->AltCost(1);
CubeUtils::UTF32ToUTF8(cube_next_best_str32, &cube_next_best_str);
}
// Rank of Tesseract's top result in Cube's alternate list
int tess_rank = 0;
for (tess_rank = 0; tess_rank < cube_alt_list->AltCount(); tess_rank++) {
string alt_str;
CubeUtils::UTF32ToUTF8(cube_alt_list->Alt(tess_rank), &alt_str);
if (alt_str == tess_str)
break;
}
// Cube's cost for tesseract's result. Note that this modifies the
// state of cube_obj, including its alternate list by calling RecognizeWord()
int tess_cost = cube_obj->WordCost(tess_str.c_str());
// Cube's bigram cost of Tesseract's string
int tess_bigram_cost = 0;
int tess_bigram_cost_valid = true;
if (cube_cntxt_->Bigrams())
tess_bigram_cost = cube_cntxt_->Bigrams()->
Cost(tess_str32.c_str(), cube_cntxt_->CharacterSet());
else
tess_bigram_cost_valid = false;
// Tesseract confidence
features->push_back(tess_confidence);
// Cube cost of Tesseract string
features->push_back(tess_cost);
// Cube Rank of Tesseract string
features->push_back(tess_rank);
// length of Tesseract OCR string
features->push_back(tess_str.length());
// Tesseract OCR string in dictionary
features->push_back(ValidWord(tess_str));
if (tess_bigram_cost_valid) {
// bigram cost of Tesseract string
features->push_back(tess_bigram_cost);
}
// Cube tess_cost of Cube best string
features->push_back(cube_best_cost);
// Cube tess_cost of Cube next best string
features->push_back(cube_next_best_cost);
// length of Cube string
features->push_back(cube_best_str.length());
// Cube string in dictionary
features->push_back(ValidWord(cube_best_str));
if (cube_best_bigram_cost_valid) {
// bigram cost of Cube string
features->push_back(cube_best_bigram_cost);
}
// case-insensitive string comparison, including punctuation
int compare_nocase_punc = CompareStrings(cube_best_str.c_str(),
tess_str.c_str(), false, true);
features->push_back(compare_nocase_punc == 0);
// case-sensitive string comparison, ignoring punctuation
int compare_case_nopunc = CompareStrings(cube_best_str.c_str(),
tess_str.c_str(), true, false);
features->push_back(compare_case_nopunc == 0);
// case-insensitive string comparison, ignoring punctuation
int compare_nocase_nopunc = CompareStrings(cube_best_str.c_str(),
tess_str.c_str(), true, true);
features->push_back(compare_nocase_nopunc == 0);
return true;
}
// ================================================================================
// FUNCTION : CompareContact
// DESCRIPTION : return true if two contacts equels.
// ================================================================================
bool CContactInfo::CompareContact(CContactInfo *pContact)
{
if ( m_nContactId != pContact->m_nContactId )
return false;
if ( !CompareStrings(m_psFName, pContact->m_psFName) ) return false;
if ( !CompareStrings(m_psLName, pContact->m_psLName) ) return false;
if ( !CompareStrings(m_psCompany, pContact->m_psCompany) ) return false;
if ( !CompareStrings(m_psJTitle, pContact->m_psJTitle) ) return false;
if ( !CompareStrings(m_psFax, pContact->m_psFax) ) return false;
if ( !CompareStrings(m_psFaxH, pContact->m_psFaxH) ) return false;
if ( !CompareStrings(m_psFaxW, pContact->m_psFaxW) ) return false;
if ( !CompareStrings(m_psMobile, pContact->m_psMobile) ) return false;
if ( !CompareStrings(m_psMobileH, pContact->m_psMobileH) ) return false;
if ( !CompareStrings(m_psMobileW, pContact->m_psMobileW) ) return false;
if ( !CompareStrings(m_psTelephone, pContact->m_psTelephone) ) return false;
if ( !CompareStrings(m_psTelephoneH, pContact->m_psTelephoneH) ) return false;
if ( !CompareStrings(m_psTelephoneW, pContact->m_psTelephoneW) ) return false;
if ( !CompareStrings(m_psEmail, pContact->m_psEmail) ) return false;
if ( !CompareStrings(m_psEmailH, pContact->m_psEmailH) ) return false;
if ( !CompareStrings(m_psEmailW, pContact->m_psEmailW) ) return false;
return true;
}
void ReplicaManagerWrapper::CheckState(
wstring const & expectedActiveReplicas,
wstring const & expectedPreviousActiveReplicas,
wstring const & expectedIdleReplicas,
bool expectedQuorumAchieved,
FABRIC_SEQUENCE_NUMBER expectedCommittedLSN,
FABRIC_SEQUENCE_NUMBER expectedCompletedLSN)
{
wstring activeReplicas;
wstring previousActiveReplicas;
wstring idleReplicas;
FABRIC_SEQUENCE_NUMBER committedLSN;
FABRIC_SEQUENCE_NUMBER completedLSN;
bool quorumAchieved;
for (int count = 1; ; count++)
{
bool replicationAckProcessingInProgress = false;
quorumAchieved = replicaManagerSPtr_->Test_TryGetProgress(
activeReplicas,
previousActiveReplicas,
idleReplicas,
committedLSN,
completedLSN,
replicationAckProcessingInProgress);
if (!replicationAckProcessingInProgress)
{
bool reachedDesiredState = CompareStrings(activeReplicas, expectedActiveReplicas, false);
reachedDesiredState &= CompareStrings(previousActiveReplicas, expectedPreviousActiveReplicas, false);
reachedDesiredState &= CompareStrings(idleReplicas, expectedIdleReplicas, false);
if (!reachedDesiredState)
{
Sleep(100);
}
else if (count >= 100)
{
break;
}
}
else
{
Sleep(100);
}
}
VERIFY_ARE_EQUAL_FMT(
quorumAchieved,
expectedQuorumAchieved,
// wait for the ack to be completely processed
"Expected quorum status = {0}, achieved = {1}", expectedQuorumAchieved, quorumAchieved);
if (!expectedQuorumAchieved)
{
return;
}
VERIFY_ARE_EQUAL_FMT(
expectedCommittedLSN,
committedLSN,
"Expected committedLSN {0} = committedLSN {1}", expectedCommittedLSN, committedLSN);
VERIFY_ARE_EQUAL_FMT(
expectedCompletedLSN,
completedLSN,
"Expected completedLSN {0} = completedLSN {1}", expectedCompletedLSN, completedLSN);
}
int main(int argc, char *argv[ ]){
ClearPrints();
chdir(CombineStrings("/home/", GetUser()));
DelFile(output_log);
DebugLog("--- Begin Android Dev Tools ARGS");
for(tick = 1; tick < argc; tick++) DebugLog(CombineStrings("ARG: ", argv[tick]));
DebugLog("");
DebugLog("--- Begin Android Dev Tools");
CmdOut("aDev_adb devices > tmp.txt");
if(IsFileEmpty("tmp.txt")){
ClearPrints();
PrintText("--- Proprietary Files Not Found! ---");
PrintText("Run: \'aDev config\'");
LineSkip();
exit(-1);
}
DelFile("tmp.txt");
if(argc <= 1){
PrintText("--- Invalid parameters! ---");
PrintText("Run: \'aDev --help\'");
LineSkip();
exit(-1);
}
for(tick = 1; tick < argc; tick++){
if(IsStringEmpty(argv[tick])) continue;
if(CompareStrings(argv[tick], "--help") || CompareStrings(argv[tick], "-h")){
PrintHelp();
exit(0);
}
if(CompareStrings(argv[tick], "--version") || CompareStrings(argv[tick], "-v")){
PrintVersion();
exit(0);
}
else if(CompareStrings(argv[tick], "test")){
PrintText("aDev was properly installed, enjoy!");
LineSkip();
exit(0);
}
else if(CompareStrings(argv[tick], "logcat")){
DevLog(1);
exit(0);
}
else if(CompareStrings(argv[tick], "dmesg")){
DevLog(2);
exit(0);
}
else if(CompareStrings(argv[tick], "kmsg")){
DevLog(3);
exit(0);
}
else if(CompareStrings(argv[tick], "screenshot")){
ScreenShot();
exit(0);
}
else if(CompareStrings(argv[tick], "info")){
Info();
exit(0);
}
else if(CompareStrings(argv[tick], "adb")){
text = "aDev_adb ";
for(tick2 = 1; tick2 < argc; tick2++) if(!CompareStrings(argv[tick2], "adb")) text = CombineStrings(text, CombineStrings(argv[tick2], " "));
CmdOut(text);
exit(0);
}
else if(CompareStrings(argv[tick], "fastboot")){
text = "aDev_fastboot ";
for(tick2 = 1; tick2 < argc; tick2++) if(!CompareStrings(argv[tick2], "fastboot")) text = CombineStrings(text, CombineStrings(argv[tick2], " "));
CmdOut(text);
exit(0);
}
else{
for(tick2 = (argc - 1); tick2 < 0; tick2--){
if(!IsValidArg(argv[tick2])) break;
if(tick2 == 1) quit();
}
if(IsValidArg(argv[tick2])) tick2--;
if(IsValidArg(argv[tick2])) quit();
PrintText(CombineStrings("Unknown Parameter: ", argv[tick2]));
quit();
}
}
return 0;
}
int PAT_Acercar(char *cRuta)
{
char cPatron[100]={0};
char cInicio[20]={0};
char cDestino[20]={0};
char *c;
int iControl=0;
long iRotacional;
long iLineal;
//GetCtrlVal (panelHandle, PANEL_strDetalle, cPatron);
//GetCtrlVal (panelHandle, PANEL_strCerca, cInicio);
//Fmt(cPatron,"%s<%s",ENT_LeerDesplazamientoPrueba()); <-------------
Fmt(cPatron,"%s<%s",cRuta); // <-------------
ENT_ColocaMensaje("PAT_Acercar()");
ENT_ColocaMensaje(GRA_Strcat(2,"cPatron -> ", cPatron));
DelayWithEventProcessing(2.0);
MOT_PosicionActual(&iRotacional, &iLineal);
Fmt(cInicio,"%s<%s",PAT_PosicionCercaDe(600, miLista, iRotacional, iLineal));
ENT_ColocaMensaje(GRA_Strcat(2,"cInicio -> ", cInicio));
if (strlen(cPatron)>0)
{
char cLista[30][30]={0};
int iTotal=0;
UTL_Split(cPatron, "->", cLista, &iTotal);
Fmt(cPatron,"%s<%s%s%s",cInicio,"->",cLista[0]);
Fmt(cDestino,"%s<%s",cLista[0]);
ENT_ColocaMensaje(GRA_Strcat(2,"El movimiento de acercamiento es de ", cPatron));
//verifica que la palanca se encuentre en una poscion diferente al inicio
if (CompareStrings(cInicio,0,cDestino,0,0) != 0)
{
UTL_Split(cPatron, "->", cLista, &iTotal);
c=PAT_AnalizarMovimientoLista2(cLista);
ENT_ColocaMensaje(GRA_Strcat(2,"c -> ", c));
UTL_Split(c, "->", cLista, &iTotal);
for (int i=0;i<iTotal;i++)
{
if (iControl==0)
{
//Busca la primer coincidencia
if (CompareStrings(cLista[i],0,cInicio,0,0)==0)
{
Fmt(cPatron,"%s<%s",cInicio);
strcat(cPatron,"->");
iControl++;
}
}
else
{
//espera hasta encontrar cDestino
if (CompareStrings(cLista[i],0,cDestino,0,0)==0)
{
strcat(cPatron,cDestino);
strcat(cPatron,"->");
i=iTotal;
}
else
{
strcat(cPatron,cLista[i]);
strcat(cPatron,"->");
}
}
}
//SetCtrlVal (panelHandle, PANEL_strRutaAcercar, cPatron);
ENT_ColocaMensaje(GRA_Strcat(2,"Se va a ejecutar --> ", cPatron));
ENT_LeeEsperaBoton();
PAT_EjecucionPorPatron2(cPatron);
}
}
return 0;
}
