bool Value::
IsNumber (int &i) const
{
long long i2;
if ( IsNumber( i2 ) ) {
i = (int)i2; // truncation
return true;
} else {
return false;
}
}
bool Value::
IsNumber (long &i) const
{
long long i2;
if ( IsNumber( i2 ) ) {
i = (long)i2; // possible truncation
return true;
} else {
return false;
}
}
double AnnotationValue::GetValueAsNumber() const
{
if (!IsNumber())
{
std::stringstream ss;
ss << "Attempted to access " << GetTypeString()
<< " annotation as a number.";
throw AnnotationValueTypeException(ss.str());
}
return boost::get<double>(value);
}
TITANIUM_FUNCTION(TableView, deleteSection)
{
if (arguments.size() < 2) {
return get_context().CreateUndefined();
} else if (arguments.size() >= 2) {
const auto _0 = arguments.at(0);
TITANIUM_ASSERT(_0.IsNumber());
const auto _1 = arguments.at(1);
TITANIUM_ASSERT(_1.IsObject());
const uint32_t section = static_cast<uint32_t>(_0);
const auto animation = static_cast<JSObject>(_1);
deleteSection(section, animation.GetPrivate<TableViewAnimationProperties>());
} else if (arguments.size() >= 1) {
const auto _0 = arguments.at(0);
TITANIUM_ASSERT(_0.IsNumber());
const uint32_t section = static_cast<uint32_t>(_0);
const auto animation = get_context().CreateObject();
deleteSection(section, animation.GetPrivate<TableViewAnimationProperties>());
}
return get_context().CreateUndefined();
}
TITANIUM_FUNCTION(TableView, scrollToTop)
{
TITANIUM_LOG_WARN("TableView.scrollToTop is not implemented yet");
if (arguments.size() < 2) {
return get_context().CreateUndefined();
} else if (arguments.size() >= 2) {
const auto _0 = arguments.at(0);
TITANIUM_ASSERT(_0.IsNumber());
const auto _1 = arguments.at(1);
//TITANIUM_ASSERT(_1.IsTableViewAnimationProperties());
const double top = static_cast<double>(_0);
const auto animation = static_cast<JSObject>(_1);
// scrollToTop(top, animation);
} else if (arguments.size() >= 1) {
const auto _0 = arguments.at(0);
TITANIUM_ASSERT(_0.IsNumber());
const double top = static_cast<double>(_0);
// scrollToTop(top);
}
return get_context().CreateUndefined();
}
TITANIUM_FUNCTION(ResultSet, fieldByName)
{
ENSURE_STRING_AT_INDEX(name, 0);
if (arguments.size() > 1) {
const auto _1 = arguments.at(1);
TITANIUM_ASSERT(_1.IsNumber());
const auto fieldType = Constants::to_FIELD_TYPE(static_cast<std::underlying_type<FIELD_TYPE>::type>(_1));
return fieldByName(name, fieldType);
}
return fieldByName(name);
}
template<> void Jsonize(JsonIO& io, bool& var)
{
if(io.IsLoading()) {
const Value& v = io.Get();
if(IsNumber(v) && !IsNull(v))
var = (bool)v;
else
throw JsonizeError("boolean expected");
}
else
io.Set(var);
}
//++
// Details: Extract the number from the string. The number can be either a
// hexadecimal or
// natural number. It cannot contain other non-numeric characters.
// Type: Method.
// Args: vwrNumber - (W) Number extracted from the string.
// Return: bool - True = yes number, false not a number.
// Throws: None.
//--
bool CMIUtilString::ExtractNumber(MIint64 &vwrNumber) const {
vwrNumber = 0;
if (!IsNumber()) {
return ExtractNumberFromHexadecimal(vwrNumber);
}
std::stringstream ss(const_cast<CMIUtilString &>(*this));
ss >> vwrNumber;
return true;
}
bool SoftClipRead::SortSoftClippedReads(SoftClipRead scRead1, SoftClipRead scRead2)
{
std::string chromosome1 = scRead1.chromosome.substr(3,std::strlen(scRead1.chromosome.c_str()) - 2);
std::string chromosome2 = scRead2.chromosome.substr(3,std::strlen(scRead2.chromosome.c_str()) - 2);
if(IsNumber(chromosome1) && IsNumber(chromosome2))
{
if (atoi(chromosome1.c_str()) == atoi(chromosome2.c_str()))
return scRead1.softclip_start > scRead2.softclip_start;
return atoi(chromosome1.c_str()) > atoi(chromosome2.c_str());
return false;
}
else
{
if(chromosome1 == chromosome2)
return scRead1.softclip_start > scRead2.softclip_start;
return chromosome1 > chromosome2;
return false;
}
}
bool IsNumber2(const Value &val) {
if (IsNull(val))
return false;
if (IsNumber(val))
return true;
if (IsString(val)) {
double d = ScanDouble(val.ToString());
if (!IsNull(d))
return true;
}
return false;
}
String FormatXmlRpcValue(const Value& _v)
{
String r;
Value v = _v;
if(v.GetType() == INT64_V) {
int64 x = v;
if((int)x == x)
v = (int)x;
}
if(IsNull(v) && !IsString(v) && !IsValueArray(v))
r = XmlTag("nil")();
else
if(v.GetType() == INT_V)
r = XmlTag("int")(Format("%d", (int)v));
else
if(v.GetType() == BOOL_V)
r = XmlTag("boolean")(AsString((int)(bool)v));
else
if(IsNumber(v))
r = XmlTag("double")(Format("%.16g", (double)v));
else
if(IsDateTime(v)) {
Time t = v;
r = XmlTag("dateTime.iso8601")
(Format("%04.4d%02.2d%02.2d`T%02.2d`:%02.2d`:%02.2d",
t.year, t.month, t.day, t.hour, t.minute, t.second));
}
else
if(v.GetType() == VALUEMAP_V) {
r = "<struct>";
ValueMap vm = v;
const Index<Value>& k = vm.GetKeys();
ValueArray va = vm.GetValues();
for(int i = 0; i < k.GetCount(); i++)
r << XmlTag("member")(XmlTag("name")(k[i]) + FormatXmlRpcValue(va[i]));
r << "</struct>";
}
else
if(v.GetType() == VALUEARRAY_V) {
r = "<array><data>";
ValueArray va = v;
for(int i = 0; i < va.GetCount(); i++)
r << FormatXmlRpcValue(va[i]);
r << "</data></array>";
}
else
if(v.Is<RawJsonText>())
r = XmlTag("string").Text(v.To<RawJsonText>().json);
else
r = XmlTag("string").Text(v);
return XmlTag("value")(r);
}
int ObjLexer::AddNewToken(Token::Type const& type, int i, std::string const& raw_object)
{
Token new_token;
new_token.SetType(type);
std::string str = getLiteral(i, raw_object);
if (IsNumber(str))
new_token.SetFloat(StringToNumber<float>(str));
tokens_.push(new_token);
return str.size();
}
void CppScanner::GetNext()
{
SetEmpty();
SkipWhitespace();
if (f.Get() == '/') { SkipComment(); SkipWhitespace(); }
char ch = f.Get();
if (IsNumber(ch) || (ch == '+') || (ch == '-')) GetNumber();
else if (IsAlpha(ch)) GetName();
else if (ch == '(' || ch == ')' || ch == '<' || ch == '>' || ch == '=' || ch == ',' || ch == ';' || ch == '&')
{ type = CToken::DELIMITER; delimiter = ch; f.GetNext(); }
else throw CPError(CPError::UNKNOWN_CHARACTER);
}
TITANIUM_FUNCTION(TableView, setRowHeight)
{
TITANIUM_LOG_WARN("TableView.setRowHeight is not implemented yet");
if (arguments.empty()) {
return get_context().CreateUndefined();
} else if (arguments.size() >= 1) {
const auto _0 = arguments.at(0);
TITANIUM_ASSERT(_0.IsNumber());
const double rowHeight = static_cast<double>(_0);
// setRowHeight(rowHeight);
}
return get_context().CreateUndefined();
}
Token* Scanner::GetNumber(char currentChar) {
string s = "";
int pos = currentPos, line = currentLine, dot = 0, E = 0;
s += currentChar;
while( (currentChar = GetChar()) != '\0' && !IsSpace(currentChar)) {
if(dot && IsDot(currentChar))
throw ScannerException(currentLine, currentPos, "Too many dots in real number: \"" + GetInvalidToken(pos) + "\"");
if(E) {
if(IsE(currentChar))
throw ScannerException(currentLine, currentPos, "Too many symbol \"E\" in real number: \"" + GetInvalidToken(pos) + "\"");
if(IsNumber(currentChar) || currentChar == '-' || currentChar == '+') {
s += currentChar;
continue;
}
else
throw ScannerException(currentLine, currentPos, "Invalid real number: \"" + GetInvalidToken(pos) + "\"");
}
if( IsNumber(currentChar) || IsE(currentChar) || IsDot(currentChar) ) {
E += IsE(currentChar);
dot += IsDot(currentChar);
s += currentChar;
}
else {
if(IsLetter(currentChar))
throw ScannerException(currentLine, currentPos, "Invalid identificator: \"" + GetInvalidToken(pos) + "\"");
BackToPreviousChar();
break;
}
}
if(IsE(s[s.length() - 1]) || IsDot(s[s.length() - 1]))
throw ScannerException(currentLine, currentPos, "Invalid real number: \"" + s + "\"");
return new Token(line, pos, dot || E ? CONST_REAL : CONST_INTEGER, DEFAULT, s);
}
int CALLBACK CSortListCtrl::CompareFunction( LPARAM lParam1, LPARAM lParam2, LPARAM lParamData )
{
CSortListCtrl* pListCtrl = reinterpret_cast<CSortListCtrl*>( lParamData );
ASSERT( pListCtrl->IsKindOf( RUNTIME_CLASS( CListCtrl ) ) );
ItemData* pid1 = reinterpret_cast<ItemData*>( lParam1 );
ItemData* pid2 = reinterpret_cast<ItemData*>( lParam2 );
ASSERT( pid1 );
ASSERT( pid2 );
LPCTSTR pszText1 = pid1->arrpsz[ pListCtrl->m_iSortColumn ];
LPCTSTR pszText2 = pid2->arrpsz[ pListCtrl->m_iSortColumn ];
ASSERT_VALID_STRING( pszText1 );
ASSERT_VALID_STRING( pszText2 );
if( IsNumber( pszText1 ) && IsNumber( pszText2 ))
return pListCtrl->m_bSortAscending ? NumberCompare( pszText1, pszText2 ) : NumberCompare( pszText2, pszText1 );
else
// text.
return pListCtrl->m_bSortAscending ? lstrcmp( pszText1, pszText2 ) : lstrcmp( pszText2, pszText1 );
}
TITANIUM_FUNCTION(ListSection, deleteItemsAt)
{
const auto js_context = this_object.get_context();
if (arguments.size() >= 2) {
const auto _0 = arguments.at(0);
TITANIUM_ASSERT(_0.IsNumber());
const auto _1 = arguments.at(1);
TITANIUM_ASSERT(_1.IsNumber());
JSObject animation = js_context.CreateObject();
const auto itemIndex = static_cast<std::uint32_t>(_0);
const auto count = static_cast<std::uint32_t>(_1);
if (arguments.size() >= 3) {
const auto _2 = arguments.at(2);
if (_2.IsObject()) {
animation = listviewAnimationProperties_ctor__.CallAsConstructor({ _2 });
}
}
deleteItemsAt(itemIndex, count, animation.GetPrivate<ListViewAnimationProperties>());
}
return get_context().CreateUndefined();
}
void CEditKDATADlg::OnOK()
{
// TODO: Add extra validation here
UpdateData( );
if( !IsNumber( m_strOpen, FALSE ) || !IsNumber( m_strHigh, FALSE )
|| !IsNumber( m_strLow, FALSE ) || !IsNumber( m_strClose, FALSE ) )
{
AfxMessageBox( IDS_EDITKDATA_NOTNUMBER, MB_OK|MB_ICONINFORMATION );
return;
}
CSPTime sptime( m_tmDate.GetTime() );
m_kd.m_date = sptime.ToStockTime( CKData::IsDayOrMin(m_nKType) );
m_kd.m_fOpen = (float)atof(m_strOpen);
m_kd.m_fHigh = (float)atof(m_strHigh);
m_kd.m_fLow = (float)atof(m_strLow);
m_kd.m_fClose = (float)atof(m_strClose);
m_kd.m_fVolume = (float)m_dwVolume*100;
m_kd.m_fAmount = (float)m_dwAmount*1000;
CXFDialog::OnOK();
}
void LispCharString(LispEnvironment& aEnvironment, LispInt aStackTop)
{
const LispString* str = ARGUMENT(1)->String();
CheckArg(str, 2, aEnvironment, aStackTop);
CheckArg(IsNumber(str->c_str(), false), 2, aEnvironment, aStackTop);
LispInt asciiCode = InternalAsciiToInt(*str);
LispChar ascii[4];
ascii[0] = '\"';
ascii[1] = (LispChar)asciiCode;
ascii[2] = '\"';
ascii[3] = '\0';
RESULT = (LispAtom::New(aEnvironment,ascii));
}
bool ezVariant::operator==(const ezVariant& other) const
{
if (IsFloatingPoint(m_Type) && IsNumber(other.m_Type))
{
return ConvertNumber<double>() == other.ConvertNumber<double>();
}
else if (IsNumber(m_Type) && IsNumber(other.m_Type))
{
return ConvertNumber<ezInt64>() == other.ConvertNumber<ezInt64>();
}
else if (m_Type == other.m_Type)
{
CompareFunc compareFunc;
compareFunc.m_pThis = this;
compareFunc.m_pOther = &other;
DispatchTo(compareFunc, GetType());
return compareFunc.m_bResult;
}
return false;
}
bool cConsole::cfAddPerlScript::operator()()
{
string scriptfile, pathname, filename;
bool number = false;
int num = 0;
GetParStr(1, scriptfile);
vector<cPerlInterpreter *>::iterator it;
cPerlInterpreter *pi;
if (IsNumber(scriptfile.c_str())) {
num = atoi(scriptfile.c_str());
number = true;
}
cServerDC *server= cServerDC::sCurrentServer;
pathname = server->mConfigBaseDir;
if(number) {
DIR *dir = opendir(pathname.c_str());
int i = 0;
if(!dir) {
(*mOS) << autosprintf(_("Failed loading directory %s."), pathname.c_str()) << " ";
return false;
}
struct dirent *dent = NULL;
while(NULL != (dent=readdir(dir))) {
filename = dent->d_name;
if((filename.size() > 4) && (StrCompare(filename,filename.size()-3,3,".pl")==0)) {
if(i == num)
scriptfile = pathname + "/" + filename;
i++;
}
}
closedir(dir);
}
char *argv[] = { (char*)"", (char*)scriptfile.c_str(), NULL };
for(it = GetPI()->mPerl.mPerl.begin(); it != GetPI()->mPerl.mPerl.end(); ++it) {
pi = *it;
if (StrCompare(pi->mScriptName,0,pi->mScriptName.size(),scriptfile)==0) {
(*mOS) << autosprintf(_("Script %s is already running."), scriptfile.c_str()) << " ";
return false;
}
}
GetPI()->mPerl.Parse(2, argv);
(*mOS) << autosprintf(_("Script %s is now running."), scriptfile.c_str()) << " ";
return true;
}
static BOOL CheckForNumber(char * String)
{
return IsNumber(String);
errno = 0;
char* p = String;
unsigned long test = strtol(String, &p, 10);
if ((errno != 0) || (String == p) || (*p != 0))
{
return FALSE;
}
return TRUE;
}
void CNumberEdit::ProcessTextChangingMessage()
{
CString csOrigText;
GetWindowText(csOrigText);
Default();
CString csNewText;
GetWindowText(csNewText);
if (!IsNumber(csNewText) || !IsInRange(_tstoi(csNewText)))
{
MessageBeep(-1);
SetWindowText(csOrigText);
}
}
Token* Scanner::GetIdentificator(char currentChar) {
string s = "";
int pos = currentPos, line = currentLine;
s += currentChar;
while( !IsEndOfLine( currentChar = GetChar() ) && !IsSpace(currentChar) ) {
if( IsLetter(currentChar) || IsNumber(currentChar) )
s += currentChar;
else {
BackToPreviousChar();
break;
}
}
return new Token(line, pos, IsKeyWord(s) ? KEYWORD : IDENTIFIER, IsKeyWord(s) ? keyWord[s] : DEFAULT, s);
}
inline double Object::GetOpt<double>(const std::string &key, const double &defaultValue) const
{
auto value = FindOpt(key);
if(!value || (!value->IsNumber() && !value->IsString()))
return defaultValue;
try
{
return std::stod(value->AsString());
}
catch(std::exception &)
{
return defaultValue;
}
}
/* Funcion:IsValidPort()
* -------------------
* Devuelve 1 en caso de que token corresponda a un puerto valido,
* y 0 en caso contrario
*/
static int
IsValidPort(char * token)
{
int i;
int len = strlen(token);
if(len == 0 || len > 5){
return 0;
}
for(i = 0; i<len; i++){
if(!IsNumber(*(token + i))){
return 0;
}
}
return 1;
}
BOOL CSetRate::ValidData( )
{
if( IsNumber(m_strTaxShaa,FALSE) && IsNumber(m_strTaxShab,FALSE) && IsNumber(m_strTaxShafund,FALSE)
&& IsNumber(m_strTaxSzna,FALSE) && IsNumber(m_strTaxSznb,FALSE) && IsNumber(m_strTaxSznfund,FALSE) )
{
return TRUE;
}
AfxMessageBox( IDS_SETRATE_NOTNUMBER, MB_OK | MB_ICONINFORMATION );
return FALSE;
}
/******************************************************************************
* Function: int _DtHelpCeGetSdlNumber (BufFilePtr f, char **number_str)
*
* Parameters:
*
*
* Returns 0 if successfully retrieved an attribute name.
* -1 if errors.
*
* errno Values:
*
* Purpose:
*
* Memory Owned By Caller: number_str
*
*****************************************************************************/
int
_DtHelpCeGetSdlNumber (
BufFilePtr f,
char *number_str)
{
if (_DtHelpCeGetSdlAttributeCdata(f, True, &number_str) != 0)
return -1;
/*
* check that the attribute name starts correctly
*/
if (!IsNumber(*number_str))
return -1;
return 0;
}
Value Compiler::ExeBracket::Eval(ExeContext& x) const
{
Value m = value->Eval(x);
Value q = index->Eval(x);
if(IsNumber(q) && m.Is<ValueArray>()) {
ValueArray va = m;
int i = q;
if(i >= 0 && i < va.GetCount())
return va[i];
}
if(IsValueMap(m)) {
ValueMap map = m;
return map[q];
}
return Value();
}
TITANIUM_FUNCTION(File, open)
{
auto js_context = this_object.get_context();
if (arguments.size() == 0) {
return js_context.CreateUndefined();
}
const auto _0 = arguments.at(0);
TITANIUM_ASSERT(_0.IsNumber());
const auto result = open(Constants::to_MODE(static_cast<std::underlying_type<MODE>::type>(_0)));
if (result != nullptr) {
return result->get_object();
} else {
return js_context.CreateNull();
}
}
