Evaluate text and return (obj, valid)
        where *obj* is the object represented by *text*
        and *valid* is True if object evaluation did not raise any exception
181507
def _eval(self, text):
        
        from spyder_kernels.py3compat import is_text_string

        assert is_text_string(text)
        ns = self._get_current_namespace(with_magics=True)
        try:
            return eval(text, ns), True
        except:
            return None, False
732532
@Override
	public Object evaluate(Message message) throws JMSException
    {
        Object operandValue = operand.evaluate(message);
        return operandValue == null ? Boolean.TRUE : Boolean.FALSE;
    }
857768
def valid(cls, data, context=None):
        """"""
        return cls(cls.TagType.VALID, data, context)
407672
def eval_objfn(self):
        

        fval = self.obfn_f(self.X)
        gval = self.obfn_g(self.X)
        obj = fval + gval
        return (obj, fval, gval)
1293883
def validateData(self, text):
        '''
        
        '''
        if text == "\n":
            return False
        for c in text:
            try:
                if str(c) != " ":
                    return True
            except:
                return False
        return False
1196027
private Object doNewInner(Object obj, boolean toLHS,
            CallStack callstack, Interpreter interpreter) throws EvalError {
        BSHAllocationExpression alloc = (BSHAllocationExpression) jjtGetChild(0);
        if (Reflect.isGeneratedClass(obj.getClass())) {
            callstack.pop();
            callstack.push(Reflect.getThisNS(obj));
            return alloc.eval(callstack, interpreter);
        }

        return alloc.constructFromEnclosingInstance(obj, callstack, interpreter);
    }
740621
function _checkResult(type, err, obj, options)
{
    if (options) {
        if (options.logger) logger.logger(options.logger, 'parse:', type, options, lib.traceError(err), obj);
        if (options.datatype == "object" || options.datatype == "obj") return {};
        if (options.datatype == "list") return [];
        if (options.datatype == "str") return "";
    }
    return null;
}
206824
function isArguments(obj) {
    var result = isExisty(obj) &&
        ((toString.call(obj) === '[object Arguments]') || !!obj.callee);

    return result;
}
937054
@Override
	public Object evaluate( Message message ) throws JMSException
    {
        Boolean leftOperandValue = leftOperand.evaluateBoolean(message);
        if (leftOperandValue == null)
        {
            Boolean rightOperandValue = rightOperand.evaluateBoolean(message);
            if (rightOperandValue == null || !rightOperandValue.booleanValue())
                return null;
            
            return Boolean.TRUE;
        }
        else
        {
            if (leftOperandValue.booleanValue())
                return Boolean.TRUE;
            
            return rightOperand.evaluateBoolean(message);
        }
    }
652369
public Boolean evaluate(Object o) {

        EntityClassReader classReader = EntityClassReader.getClassReaderFor(o.getClass());

        if (classReader.getPropertyType(propertyName) != Boolean.class)
                throw new RuntimeException("Property " + propertyName + " on object " + o + " is not of type Boolean");

        Object result = null;
        try {
            result = classReader.getPropertyValue(o, propertyName);
        }
        catch (InvalidObjectReaderException e) {
            ; // can never occur
        }

        return (Boolean)result;
    }
1157333
function (obj) {
			this.writeDebug('hasEmptyObjectVals',arguments);
				var objTest = true;

				for(var key in obj) {
					if (obj.hasOwnProperty(key)) {
						if (obj[key] !== '' && obj[key].length !== 0) {
							objTest = false;
						}
					}
				}

				return objTest;
		}
816103
private Object eval(ExpressionContext expr) {
    Object res = expr;
    while(res instanceof ExpressionContext)
      res = ((ExpressionContext)res).accept(visitor);
    if(res instanceof LValue)
      res = ((LValue) res).get(expr);
    return res;
  }
837284
def check_obj(keys, name, obj):
    """"""
    msg = validate_obj(keys, obj)

    if msg:
        raise aomi.exceptions.AomiData("object check : %s in %s" % (msg, name))
363617
function toText (obj) {
  if (obj instanceof Error) {
    return {
      isJSON: false,
      text: obj.message + "\n\n" + obj.stack
    };
  }
  else {
    try {
      return {
        isJSON: true,
        text: JSON.stringify(obj, null, 2)
      };
    }
    catch (e) {
      return {
        isJSON: false,
        text: "This API is valid, but it cannot be shown because it contains circular references\n\n" + e.stack
      };
    }
  }
}
274809
public Object eval( CallStack callstack, Interpreter interpreter )
        throws EvalError
    {
        throw new InterpreterError(
            "Unimplemented or inappropriate for " + getClass().getName() );
    }
888709
def textx_isinstance(obj, obj_cls):
    
    if isinstance(obj, obj_cls):
        return True
    if hasattr(obj_cls, "_tx_fqn") and hasattr(obj, "_tx_fqn"):
        if obj_cls._tx_fqn == obj._tx_fqn:
            return True
    if hasattr(obj_cls, "_tx_inh_by"):
        for cls in obj_cls._tx_inh_by:
            if (textx_isinstance(obj, cls)):
                return True
    return False
162282
public static Result ok(String object) {
        return status(Result.OK).render(object).as(MimeTypes.TEXT);
    }