Пример #1
0
 void DeviceCreationParameterFloat::SetValue(String val) throw (Exception) {
     if (Fix()) throw Exception("Device parameter is read only");
     float f = __parse_float(val);
     //if (RangeMinAsFloat() && i < *RangeMinAsFloat()) throw Exception("Invalid device parameter value: too small");
     //if (RangeMaxAsFloat() && i > *RangeMaxAsFloat()) throw Exception("Invalid device parameter value: too big");
     /*if (PossibilitiesAsFloat()) {
         bool valid = false;
         std::vector<float>* pPossibilities = PossibilitiesAsFloat();
         std::vector<float>::iterator iter  = pPossibilities->begin();
         while (iter != pPossibilities->end()) {
             if (f == *iter) {
                 valid = true;
                 break;
             }
             iter++;
         }
         if (!valid) throw Exception("Invalid Device parameter value: not in set of possible values");
     }*/
     SetValue(f);
 }
Пример #2
0
 DeviceCreationParameterFloat::DeviceCreationParameterFloat(String val) throw (Exception) {
     this->fVal = __parse_float(val);
 }
Пример #3
0
static int __parse_primary (struct expr_parser *self, z_expr_t *expr) {
  const z_lexer_token_t *token = z_lexer_peek(self->lex);
  int negate = 0;

  switch (token->type) {
    case Z_LEXER_TOKEN_INT:
      __parse_int(self, expr);
      z_lexer_next(self->lex);
      break;
    case Z_LEXER_TOKEN_FLOAT:
      __parse_float(self, expr);
      z_lexer_next(self->lex);
      break;
    case Z_LEXER_TOKEN_BOOLEAN:
      expr->type = Z_EXPR_TYPE_INT;
      expr->d.integer = (token->length == 4);
      z_lexer_next(self->lex);
      break;
    case Z_LEXER_TOKEN_STRING:
      __parse_string(self, expr);
      z_lexer_next(self->lex);
      break;
    case Z_LEXER_TOKEN_IDENTIFIER:
      __parse_identifier(self, expr);
      z_lexer_next(self->lex);
      if (self->lex->query[token->start] == '(') {
        __parse_function(self, expr);
      }
      break;
    case Z_LEXER_TOKEN_OPERATOR:
      if (self->lex->query[token->start] == '(') {
        z_lexer_next(self->lex);
        __parse_predicate(self, expr);
        token = z_lexer_peek(self->lex);
        if (self->lex->query[token->start] != ')') {
          return(Z_EXPR_EXPECTED_END_PARENTHESIS);
        }
        z_lexer_next(self->lex);
      } else {
        return(Z_EXPR_PRIMARY_EXPECTED_PARENTHESIS);
      }
      break;
    default:
      return(Z_EXPR_UNKNOWN_PRIMARY_TOKEN);
  }

  if (expr == NULL) {
    return(Z_EXPR_NO_PRIMARY);
  }

  token = z_lexer_peek(self->lex);
  if (token->length == 3 && z_memeq(self->lex->query + token->start, "NOT", 3)) {
    z_lexer_next(self->lex);
    negate = 1;
    token = z_lexer_peek(self->lex);
  }

  if (token->length == 2 && z_memeq(self->lex->query + token->start, "IN", 2)) {
    z_lexer_next(self->lex);
    return(__parse_in(self, expr, negate));
  } else if (token->length == 7 && z_memeq(self->lex->query + token->start, "BETWEEN", 7)) {
    z_lexer_next(self->lex);
    return(__parse_between(self, expr, negate));
  } else if (negate) {
    return(Z_EXPR_PRIMARY_NOT_WITHOUT_OP);
  }

  return(Z_EXPR_OK);
}