OpenCVReader::OpenCVReader(list<vector<string> > configList)
{
int notLoaded = 0;
int tempCameraInput = 0;
notLoaded += FindValue(configList, "CVCameraInput", tempCameraInput);
assert(!notLoaded);
cameraInput = (tempCameraInput != 0);
if (!cameraInput)
{
notLoaded += FindValue(configList, "CVMovieFileInput", fileName);
assert(!notLoaded);
cvImageReader = cvCaptureFromFile(fileName);
}
else
{
notLoaded += FindValue(configList, "CVCameraNumber", cameraNumber);
assert(!notLoaded);
cvImageReader = cvCaptureFromCAM(cameraNumber);
}
assert(cvImageReader);
IplImage* cvImage = cvQueryFrame(cvImageReader);
assert(cvImage);
height = cvImage->height;
width = cvImage->width;
channels = cvImage->nChannels;
reset();
//cout << "Height: " << height << " Width: " << width << " Channels: " << channels << endl;
}
ImageProviderEnhancer::ImageProviderEnhancer(list<vector<string> > configList, ImageProvider *realProvider) : realProvider(realProvider), workerThreadRunning(false)
{
assert(realProvider);
int notLoaded = 0;
int tempImageResize = 0;
tempImageResize += FindValue(configList, "ImageEnhResizeWidth", resizeWidth);
tempImageResize += FindValue(configList, "ImageEnhResizeHeight", resizeHeight);
imageResizing = !tempImageResize;
assert(!notLoaded);
}
bool Ardb::DBExist(const DBID& db, DBID& nextdb)
{
KeyObject start(Slice(), KV, db);
Iterator* iter = FindValue(start, false);
bool found = false;
nextdb = db;
if (NULL != iter && iter->Valid())
{
Slice tmpkey = iter->Key();
KeyObject* kk = decode_key(tmpkey, NULL);
if (NULL != kk)
{
if (kk->db == db)
{
found = true;
} else
{
nextdb = kk->db;
}
}
DELETE(kk);
}
DELETE(iter);
return found;
}
bool HLXSListTest::HandleFindCmd(const UTVector<UTString>& info)
{
bool ret = false;
int value = 0;
bool useCurrentPos = false;
if (!UTParamUtil::GetInt(info[1], value) ||
!UTParamUtil::GetBool(info[2], useCurrentPos))
{
DPRINTF(D_ERROR, ("npSList::HandleFindCmd : failed to convert parameter\n"));
}
else
{
LISTPOSITION pos = (useCurrentPos) ? m_pos : m_list.GetHeadPosition();
void* pValue = 0;
bool destroyValue = FindValue(value, pos, pValue);
if (useCurrentPos)
m_pos = m_list.Find(pValue, pos);
else
m_pos = m_list.Find(pValue);
if (destroyValue)
DestroyValue(pValue);
ret = true;
}
return ret;
}
int Ardb::FlushScripts()
{
KeyObject start(Slice(), SCRIPT, ARDB_GLOBAL_DB);
Iterator* iter = FindValue(start, false);
BatchWriteGuard guard(GetEngine());
while (NULL != iter && iter->Valid())
{
Slice tmpkey = iter->Key();
KeyObject* kk = decode_key(tmpkey, NULL);
if (NULL != kk)
{
if (kk->type == SCRIPT)
{
DelValue(*kk);
} else
{
break;
}
}
DELETE(kk);
iter->Next();
}
DELETE(iter);
return 0;
}
/** Parse a option group option. */
void ParseGroupOption(const TokenNode *tp, struct GroupType *group,
const char *option)
{
int x;
if(!option) {
return;
}
/* Look up the option in the option map using binary search. */
x = FindValue(OPTION_MAP, OPTION_MAP_COUNT, option);
if(x >= 0) {
AddGroupOption(group, (OptionType)x);
return;
}
/* These options have arguments and so we handled them separately. */
if(!strncmp(option, "layer:", 6)) {
const WinLayerType layer = ParseLayer(tp, option + 6);
AddGroupOptionUnsigned(group, OPTION_LAYER, layer);
} else if(!strncmp(option, "desktop:", 8)) {
const unsigned int desktop = (unsigned int)atoi(option + 8);
AddGroupOptionUnsigned(group, OPTION_DESKTOP, desktop);
} else if(!strncmp(option, "icon:", 5)) {
AddGroupOptionString(group, OPTION_ICON, option + 5);
} else if(!strncmp(option, "opacity:", 8)) {
const unsigned int opacity = ParseOpacity(tp, option + 8);
AddGroupOptionUnsigned(group, OPTION_OPACITY, opacity);
} else {
ParseError(tp, "invalid Group Option: %s", option);
}
}
void Ardb::Walk(WalkHandler* handler)
{
KeyObject start(Slice(), KV, 0);
Iterator* iter = FindValue(start);
uint32 cursor = 0;
while (NULL != iter && iter->Valid())
{
Slice tmpkey = iter->Key();
KeyObject* kk = decode_key(tmpkey, NULL);
if (NULL == kk)
{
break;
}
ValueObject v;
Buffer readbuf(const_cast<char*>(iter->Value().data()), 0, iter->Value().size());
decode_value(readbuf, v, false);
int ret = handler->OnKeyValue(kk, &v, cursor++);
DELETE(kk);
if (ret < 0)
{
break;
}
iter->Next();
}
DELETE(iter);
}
void Ardb::PrintDB(const DBID& db)
{
Slice empty;
KeyObject start(empty, KV, db);
Iterator* iter = FindValue(start);
while (NULL != iter && iter->Valid())
{
Slice tmpkey = iter->Key();
KeyObject* kk = decode_key(tmpkey, NULL);
if (kk->db != db)
{
DELETE(kk);
break;
}
ValueObject v;
Buffer readbuf(const_cast<char*>(iter->Value().data()), 0, iter->Value().size());
decode_value(readbuf, v, false);
if (NULL != kk)
{
std::string str;
DEBUG_LOG("[%d]Key=%s, Value=%s", kk->type, kk->key.data(), v.ToString(str).c_str());
}
DELETE(kk);
iter->Next();
}
DELETE(iter);
}
NODE* Insert(unsigned int value)
{
NODE *p = root, *q = NULL;
FindValue(value, p, q);
if (p == nil) p = GetNode(value, q);
Splay(p, nil);
return p;
}
NODE* FindNextValue(unsigned int value)
{
NODE *p = root, *q = NULL;
FindValue(value, p, q);
Splay(p, nil);
q = p->ch[1];
while (q->ch[0] != nil) q = q->ch[0];
return q;
}
avtIVPField::Result
avtIVPFlashField::operator()( const double &t,
const avtVector &p,
const avtVector &v,
avtVector& retV ) const
{
if (FindCell(t, p) != OK)
return OUTSIDE_SPATIAL;
avtVector B, E;
if (FindValue(B_vtkDataArray, B) && FindValue(E_vtkDataArray, E))
{
retV = factor * (E + Cross(v, B) );
return OK;
}
else
return OUTSIDE_SPATIAL;
}
/** Parse popup style. */
void ParsePopupStyle(const TokenNode *tp)
{
static const StringMappingType enable_mapping[] = {
{ "button", POPUP_BUTTON },
{ "clock", POPUP_CLOCK },
{ "false", POPUP_NONE },
{ "pager", POPUP_PAGER },
{ "task", POPUP_TASK },
{ "true", POPUP_ALL }
};
const TokenNode *np;
const char *str;
char *tok;
tok = FindAttribute(tp->attributes, "enabled");
if(tok) {
settings.popupMask = POPUP_NONE;
tok = strtok(tok, ",");
while(tok) {
const int x = FindValue(enable_mapping,
ARRAY_LENGTH(enable_mapping), tok);
if(JLIKELY(x >= 0)) {
settings.popupMask |= x;
} else {
ParseError(tp, "invalid value for 'enabled': \"%s\"", tok);
}
tok = strtok(NULL, ",");
}
}
str = FindAttribute(tp->attributes, "delay");
if(str) {
settings.popupDelay = ParseUnsigned(tp, str);
}
for(np = tp->subnodeHead; np; np = np->next) {
switch(np->type) {
case TOK_FONT:
SetFont(FONT_POPUP, np->value);
break;
case TOK_FOREGROUND:
SetColor(COLOR_POPUP_FG, np->value);
break;
case TOK_BACKGROUND:
SetColor(COLOR_POPUP_BG, np->value);
break;
case TOK_OUTLINE:
SetColor(COLOR_POPUP_OUTLINE, np->value);
break;
default:
InvalidTag(np, TOK_POPUPSTYLE);
break;
}
}
}
int main(int argc, char *argv[])
{
std::vector<int> a = {1,2,3,4,5,6,7,8,9,10};
std::vector<int> b = {0,9,234,432,56,12,532};
if (FindValue(a, 7)) {
std::cout << "找到" << std::endl;
} else {
std::cout << "未找到" << std::endl;
}
if (FindValue(b, 12345)) {
std::cout << "找到" << std::endl;
} else {
std::cout << "未找到" << std::endl;
}
return EXIT_SUCCESS;
}
void
nsXBLContentSink::ConstructParameter(const PRUnichar **aAtts)
{
if (!mMethod)
return;
const PRUnichar* name = nsnull;
if (FindValue(aAtts, nsGkAtoms::name, &name)) {
mMethod->AddParameter(nsDependentString(name));
}
}
string CIniFile::GetValue( string const keyname, string const valuename, string const defValue) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return defValue;
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID)
return defValue;
return keys[keyID].values[valueID];
}
void EditValue(HashTable* hashTable, char* key, char* value)
{
if(hashTable != NULL && value != NULL)
{
Node* tmpNode = FindValue(hashTable, key);
if(tmpNode != NULL)
{
tmpNode->value = (char*)realloc(tmpNode->value, strlen(value) + 1);
strcpy(tmpNode->value, value);
}
}
}
void
nsXBLContentSink::ConstructResource(const PRUnichar **aAtts,
nsIAtom* aResourceType)
{
if (!mBinding)
return;
const PRUnichar* src = nsnull;
if (FindValue(aAtts, nsGkAtoms::src, &src)) {
mBinding->AddResource(aResourceType, nsDependentString(src));
}
}
void Delete(unsigned int value)
{
NODE *p = root, *q = NULL;
FindValue(value, p, q);
if (p != nil)
{
// printf("Enter Delete\n");
Splay(p, nil);
NODE *p1 = FindPrevValue(value);
NODE *p2 = FindNextValue(value);
Splay(p1, nil); Splay(p2, root);
p2->ch[0] = nil;
}
}
void
nsXBLContentSink::ConstructMethod(const PRUnichar **aAtts)
{
mMethod = nsnull;
const PRUnichar* name = nsnull;
if (FindValue(aAtts, nsGkAtoms::name, &name)) {
mMethod = new nsXBLProtoImplMethod(name);
}
if (mMethod) {
AddMember(mMethod);
}
}
/** Parse a key binding. */
void ParseKey(const TokenNode *tp) {
const char *key;
const char *code;
const char *mask;
const char *action;
const char *command;
KeyType k;
Assert(tp);
mask = FindAttribute(tp->attributes, "mask");
key = FindAttribute(tp->attributes, "key");
code = FindAttribute(tp->attributes, "keycode");
action = tp->value;
if(JUNLIKELY(action == NULL)) {
ParseError(tp, "no action specified for Key");
return;
}
command = NULL;
k = KEY_NONE;
if(!strncmp(action, "exec:", 5)) {
k = KEY_EXEC;
command = action + 5;
} else if(!strncmp(action, "root:", 5)) {
k = KEY_ROOT;
command = action + 5;
} else {
/* Look up the option in the key map using binary search. */
const int x = FindValue(KEY_MAP, KEY_MAP_COUNT, action);
if(x >= 0) {
k = (KeyType)x;
}
}
/* Insert the binding if it's valid. */
if(JUNLIKELY(k == KEY_NONE)) {
ParseError(tp, "invalid Key action: \"%s\"", action);
} else {
InsertBinding(k, mask, key, code, command);
}
}
/** Parse layer. */
WinLayerType ParseLayer(const TokenNode *tp, const char *str)
{
static const StringMappingType mapping[] = {
{ "above", LAYER_ABOVE },
{ "below", LAYER_BELOW },
{ "normal", LAYER_NORMAL }
};
const int x = FindValue(mapping, ARRAY_LENGTH(mapping), str);
if(JLIKELY(x >= 0)) {
return x;
} else {
ParseError(tp, "invalid layer: %s", str);
return LAYER_NORMAL;
}
}
/** Parse a string using a string mapping. */
int ParseAttribute(const StringMappingType *mapping, int count,
const TokenNode *tp, const char *attr, int def)
{
const char *str = FindAttribute(tp->attributes, attr);
if(str == NULL) {
return def;
} else {
const int x = FindValue(mapping, count, str);
if(JLIKELY(x >= 0)) {
return x;
} else {
ParseError(tp, "invalid value for %s: \"%s\"", attr, str);
return def;
}
}
}
/** Parse a token value using a string mapping. */
int ParseTokenValue(const StringMappingType *mapping, int count,
const TokenNode *tp, int def)
{
if(JUNLIKELY(tp->value == NULL)) {
ParseError(tp, "%s is empty", GetTokenName(tp));
return def;
} else {
const int x = FindValue(mapping, count, tp->value);
if(JLIKELY(x >= 0)) {
return x;
} else {
ParseError(tp, "invalid %s: \"%s\"", GetTokenName(tp), tp->value);
return def;
}
}
}
// Check if a string(aToken) is present in another string(aLine). If present, then find the last position
//where aDelimiter is present in aLine. Store the string after aDelimiter in aValue.
//@return bool return true if a value is retrieved after aToken match and aDelimiter match
//@param aLine modified string that contains the part of the string after aToken
//@param aToken string that needs to be searched for
//@param aDelimiter generally a single character string like ",", ".", etc.
//@param aValue string containing the value, i.e., the part of the string after aDelimiter.
bool TestTzUtil::FindValue(string& aLine, const string& aToken, string& aDelimiter, string& aValue)
{
bool rc = false;
string::size_type loc;
loc = aLine.find(aToken.c_str());
if (loc != string::npos)
{
int tokenLength = aToken.length();
aLine = aLine.substr(loc+tokenLength);
rc = FindValue(aLine, aDelimiter, aValue);
}
return rc;
}
void Ardb::Walk(KeyObject& key, bool reverse, WalkHandler* handler)
{
bool isFirstElement = true;
Iterator* iter = FindValue(key);
if (NULL != iter && !iter->Valid() && reverse)
{
iter->SeekToLast();
isFirstElement = false;
}
uint32 cursor = 0;
while (NULL != iter && iter->Valid())
{
Slice tmpkey = iter->Key();
KeyObject* kk = decode_key(tmpkey, &key);
if (NULL == kk || kk->type != key.type
|| kk->key.compare(key.key) != 0)
{
DELETE(kk);
if (reverse && isFirstElement)
{
iter->Prev();
isFirstElement = false;
continue;
}
break;
}
ValueObject v;
Buffer readbuf(const_cast<char*>(iter->Value().data()), 0,
iter->Value().size());
decode_value(readbuf, v, false);
int ret = handler->OnKeyValue(kk, &v, cursor++);
DELETE(kk);
if (ret < 0)
{
break;
}
if (reverse)
{
iter->Prev();
}
else
{
iter->Next();
}
}
DELETE(iter);
}
avtVector
avtIVPVTKOffsetField::operator()( const double &t, const avtVector &p ) const
{
avtVector zeros(0, 0, 0);
std::vector<avtVector> velocities(3);
for ( size_t j = 0; j < 3; ++j )
{
if (FindCell(t, p) != OK)
{
// ghost cells on the base mesh may be required to avoid this failure
debug5 <<"avtIVPVTKOffsetField::operator() - UNABLE TO FIND CELL!"
<<std::endl;
return zeros;
}
avtVector displ = GetPositionCorrection( j );
avtVector pCorrected = p - displ;
avtVector displ2 = displ;
if (FindCell(t, pCorrected) != OK)
{
// the displacement seen from the base target position may be
// a little different.
displ2 = GetPositionCorrection( j );
}
pCorrected = p - 0.5*(displ2 + displ);
if (FindCell(t, pCorrected) != OK)
{
debug5 <<"avtIVPVTKOffsetField::operator() - UNABLE TO FIND CORRECTED CELL!"
<<std::endl;
return zeros;
}
// velocity for this staggering
FindValue(velData, velocities[j]);
}
// compose the velocity, assuming each component is purely
// aligned to each axis. How should this be generalized when
// the velocites are not alog axes?
avtVector vel( velocities[0].x, velocities[1].y, velocities[2].z );
return vel;
}
/** Get the token for a tag name. */
TokenType LookupType(const char *name, TokenNode *np)
{
const int x = FindValue(TOKEN_MAP, TOKEN_MAP_COUNT, name);
if(x >= 0) {
if(np) {
np->type = x;
}
return x;
}
if(JUNLIKELY(np)) {
np->type = TOK_INVALID;
np->invalidName = CopyString(name);
}
return TOK_INVALID;
}
bool CIniFile::DeleteValue( string const keyname, string const valuename)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return false;
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID)
return false;
// This looks strange, but is neccessary.
vector<string>::iterator npos = keys[keyID].names.begin() + valueID;
vector<string>::iterator vpos = keys[keyID].values.begin() + valueID;
keys[keyID].names.erase( npos, npos + 1);
keys[keyID].values.erase( vpos, vpos + 1);
return true;
}
/* Matches python dict.get(key, [default]) */
PyObject *CListValue::Pyget(PyObject *args)
{
char *key;
PyObject *def = Py_None;
if (!PyArg_ParseTuple(args, "s|O:get", &key, &def))
return NULL;
CValue *item = FindValue((const char *)key);
if (item) {
PyObject *pyobj = item->ConvertValueToPython();
if (pyobj)
return pyobj;
else
return item->GetProxy();
}
Py_INCREF(def);
return def;
}
/** Set the vertical tray alignment. */
void SetTrayVerticalAlignment(TrayType *tp, const char *str)
{
static const StringMappingType mapping[] = {
{ "bottom", TALIGN_BOTTOM },
{ "center", TALIGN_CENTER },
{ "fixed", TALIGN_FIXED },
{ "top", TALIGN_TOP }
};
if(!str) {
tp->valign = TALIGN_FIXED;
} else {
const int x = FindValue(mapping, ARRAY_LENGTH(mapping), str);
if(JLIKELY(x >= 0)) {
tp->valign = x;
} else {
Warning(_("invalid tray vertical alignment: \"%s\""), str);
tp->valign = TALIGN_FIXED;
}
}
}
