Read a property.
 @param propname [String]
186960
def [](propname)
      ret = object[PROPERTY_INTERFACE].Get(name, propname)
      # this method always returns the single property
      if @object.api.proxy_method_returns_array
        ret[0]
      else
        ret
      end
    end
462511
def get_property(self, prop):
        
        prop = prop.split('.')
        root = self
        for p in prop:
            if p in root:
                root = root[p]
            else:
                return None
        return root
495615
private void loadProperties(String propFileName) {
		if (propFileName != null) {
			loadProperties(getClass().getResourceAsStream(propFileName), propFileName);
		}
	}
1194467
Object getPropertyValue(final String propName, final Interpreter interp)
            throws UtilEvalError {
        String accessorName = Reflect.accessorName(Reflect.GET_PREFIX, propName);
        final Class<?>[] classArray = Reflect.ZERO_TYPES;
        BshMethod m = this.getMethod(accessorName, classArray);
        try {
            if (m != null)
                return m.invoke((Object[]) null, interp);
            accessorName = Reflect.accessorName(Reflect.IS_PREFIX, propName);
            m = this.getMethod(accessorName, classArray);
            if (m != null && m.getReturnType() == Boolean.TYPE)
                return m.invoke((Object[]) null, interp);
            return Primitive.VOID;
        } catch (final EvalError ee) {
            throw new UtilEvalError("'This' property accessor threw exception: "
                    + ee.getMessage(), ee);
        }
    }
199882
private String checkProperty(String propName) throws AttributeNotSupportedException {
        final String METHODNAME = "checkProperty";
        boolean inRepos = false;
        boolean inLA = false;
        if (propName.equals(xsiType)) {
/*
 * if (trcLogger.isLoggable(Level.FINER)) {
 * trcLogger.exiting(CLASSNAME, METHODNAME, " " + propName
 * + " is defined in Repository " + repos);
 * }
 */ return repos;
        }
        inRepos = false;
        for (int i = 0; i < entityTypes.size() && !inRepos; i++) {
            inRepos = _metaDataMapper.isPropertyInRepository(propName,
                                                             entityTypes.get(i));
        }
        if (!inRepos) {
            for (int i = 0; i < entityTypes.size(); i++) {
                inLA = _metaDataMapper.isPropertyInLookAside(propName,
                                                             entityTypes.get(i));
            }
        } else {
/*
 * if (trcLogger.isLoggable(Level.FINER)) {
 * trcLogger.exiting(CLASSNAME, METHODNAME, "Property " + propName
 * + " is defined in Repository " + repos);
 * }
 */ return repos;
        }
        if (!inRepos && !inLA) {
            throw new AttributeNotSupportedException(WIMMessageKey.ATTRIBUTE_NOT_SUPPORTED, WIMMessageKey.ATTRIBUTE_NOT_SUPPORTED);
        }
/*
 * if (trcLogger.isLoggable(Level.FINER)) {
 * trcLogger.exiting(CLASSNAME, METHODNAME, "Property " + propName
 * + " is defined in Repository " + la);
 * }
 */ return la;
    }
128411
private static JsonObject getJsonObject(JsonObject object, String propName) {
        JsonObject obj = null;
        JsonValue val = object.get(propName);
        if (val != null && val.getValueType() == ValueType.OBJECT) {
            obj = val.asJsonObject();
        }
        return obj;
    }
532867
@Override
    public Object get(String propName) {
        if (propName.equals("level")) {
            return getLevel();
        }
        return super.get(propName);
    }
233496
def do_read(self, args):
        """"""
        args = args.split()
        if _debug: ReadPropertyMultipleConsoleCmd._debug("do_read %r", args)

        try:
            i = 0
            addr = args[i]
            i += 1

            read_access_spec_list = []
            while i < len(args):
                obj_id = ObjectIdentifier(args[i]).value
                i += 1

                prop_reference_list = []
                while i < len(args):
                    prop_id = args[i]
                    if prop_id not in PropertyIdentifier.enumerations:
                        break

                    i += 1
                    if prop_id in ('all', 'required', 'optional'):
                        pass
                    else:
                        datatype = get_datatype(obj_id[0], prop_id)
                        if not datatype:
                            raise ValueError("invalid property for object type")

                    # build a property reference
                    prop_reference = PropertyReference(
                        propertyIdentifier=prop_id,
                        )

                    # check for an array index
                    if (i < len(args)) and args[i].isdigit():
                        prop_reference.propertyArrayIndex = int(args[i])
                        i += 1

                    # add it to the list
                    prop_reference_list.append(prop_reference)

                # check for at least one property
                if not prop_reference_list:
                    raise ValueError("provide at least one property")

                # build a read access specification
                read_access_spec = ReadAccessSpecification(
                    objectIdentifier=obj_id,
                    listOfPropertyReferences=prop_reference_list,
                    )

                # add it to the list
                read_access_spec_list.append(read_access_spec)

            # check for at least one
            if not read_access_spec_list:
                raise RuntimeError("at least one read access specification required")

            # build the request
            request = ReadPropertyMultipleRequest(
                listOfReadAccessSpecs=read_access_spec_list,
                )
            request.pduDestination = Address(addr)
            if _debug: ReadPropertyMultipleConsoleCmd._debug("    - request: %r", request)

            # make an IOCB
            iocb = IOCB(request)
            if _debug: ReadPropertyMultipleConsoleCmd._debug("    - iocb: %r", iocb)

            # give it to the application
            deferred(this_application.request_io, iocb)

            # wait for it to complete
            iocb.wait()

            # do something for success
            if iocb.ioResponse:
                apdu = iocb.ioResponse

                # should be an ack
                if not isinstance(apdu, ReadPropertyMultipleACK):
                    if _debug: ReadPropertyMultipleConsoleCmd._debug("    - not an ack")
                    return

                # loop through the results
                for result in apdu.listOfReadAccessResults:
                    # here is the object identifier
                    objectIdentifier = result.objectIdentifier
                    if _debug: ReadPropertyMultipleConsoleCmd._debug("    - objectIdentifier: %r", objectIdentifier)

                    # now come the property values per object
                    for element in result.listOfResults:
                        # get the property and array index
                        propertyIdentifier = element.propertyIdentifier
                        if _debug: ReadPropertyMultipleConsoleCmd._debug("    - propertyIdentifier: %r", propertyIdentifier)
                        propertyArrayIndex = element.propertyArrayIndex
                        if _debug: ReadPropertyMultipleConsoleCmd._debug("    - propertyArrayIndex: %r", propertyArrayIndex)

                        # here is the read result
                        readResult = element.readResult

                        sys.stdout.write(propertyIdentifier)
                        if propertyArrayIndex is not None:
                            sys.stdout.write("[" + str(propertyArrayIndex) + "]")

                        # check for an error
                        if readResult.propertyAccessError is not None:
                            sys.stdout.write(" ! " + str(readResult.propertyAccessError) + '\n')

                        else:
                            # here is the value
                            propertyValue = readResult.propertyValue

                            # find the datatype
                            datatype = get_datatype(objectIdentifier[0], propertyIdentifier)
                            if _debug: ReadPropertyMultipleConsoleCmd._debug("    - datatype: %r", datatype)
                            if not datatype:
                                raise TypeError("unknown datatype")

                            # special case for array parts, others are managed by cast_out
                            if issubclass(datatype, Array) and (propertyArrayIndex is not None):
                                if propertyArrayIndex == 0:
                                    value = propertyValue.cast_out(Unsigned)
                                else:
                                    value = propertyValue.cast_out(datatype.subtype)
                            else:
                                value = propertyValue.cast_out(datatype)
                            if _debug: ReadPropertyMultipleConsoleCmd._debug("    - value: %r", value)

                            sys.stdout.write(" = " + str(value) + '\n')
                        sys.stdout.flush()

            # do something for error/reject/abort
            if iocb.ioError:
                sys.stdout.write(str(iocb.ioError) + '\n')

        except Exception, error:
            ReadPropertyMultipleConsoleCmd._exception("exception: %r", error)
411322
def read_property_to_result_element(obj, propertyIdentifier, propertyArrayIndex=None):
    """"""
    if _debug: read_property_to_result_element._debug("read_property_to_result_element %s %r %r", obj, propertyIdentifier, propertyArrayIndex)

    # save the result in the property value
    read_result = ReadAccessResultElementChoice()

    try:
        if not obj:
            raise ExecutionError(errorClass='object', errorCode='unknownObject')

        read_result.propertyValue = read_property_to_any(obj, propertyIdentifier, propertyArrayIndex)
        if _debug: read_property_to_result_element._debug("    - success")
    except PropertyError as error:
        if _debug: read_property_to_result_element._debug("    - error: %r", error)
        read_result.propertyAccessError = ErrorType(errorClass='property', errorCode='unknownProperty')
    except ExecutionError as error:
        if _debug: read_property_to_result_element._debug("    - error: %r", error)
        read_result.propertyAccessError = ErrorType(errorClass=error.errorClass, errorCode=error.errorCode)

    # make an element for this value
    read_access_result_element = ReadAccessResultElement(
        propertyIdentifier=propertyIdentifier,
        propertyArrayIndex=propertyArrayIndex,
        readResult=read_result,
        )
    if _debug: read_property_to_result_element._debug("    - read_access_result_element: %r", read_access_result_element)

    # fini
    return read_access_result_element
114149
private void parse(String propKey, String propValue) {
        if (ARG_TAG.equals(propValue)) {
            String value = System.getProperty(propKey);

            if (StringUtils.isNotBlank(value) && value.startsWith(CRYPTEX_TAG)) {
                value = decrypt(value);
            }

            if (StringUtils.isNotBlank(value)) {
                this.props.setValue(propKey, value, Application.getMode().toString());
            }
        }

        if (propValue.startsWith(CRYPTEX_TAG)) {
            this.props.setValue(propKey, decrypt(propValue), Application.getMode().toString());
        }
    }
983103
final protected function _isProperty(
        $propName)
    {
        // Object instance's data has the property and it evaluates to true?
        return array_key_exists($propName, $this->_objectData)
            && (bool) $this->_objectData[$propName];
    }
868291
function checkProperties(name){
  var bul=false; // boolean to control if its defined the property

  for(var i=0; i<properties.length; i++){//iterate over prop names
    if(properties[i] === name){//if it is
      bul=true;
    }
  }
  if(bul!==true){// it isn't finded the statement of the tag
    throw new Error('Not defined '+name);
    }  
}
1171391
private String resolve(final String propName) {
        return ResolverUtil.resolveProperty(propName, null, node, frameworkProject, framework);
    }
1258192
static String[] getProp(final Map<String, String[]> prop, final String propertyName) {
        String[] result = null;
        if (prop != null) {
            for (final Entry<String, String[]> entry : prop.entrySet()) {
                if (entry.getKey().equalsIgnoreCase(propertyName)) {
                    result = entry.getValue();
                }
            }
        }
        return result;
    }
1044497
public function __isset($propName)
	{
		$methodName = 'isset' . ucfirst($propName);
		if (method_exists($this, $methodName))
		{
			return $this->$methodName();
		}

		return isset($this->$propName);
	}
485887
public Object get(String propName) {
        if (propName.equals("roles")) {
            return getRoles();
        }
        if (propName.equals("entitlements")) {
            return getEntitlements();
        }
        return null;
    }
775362
@Override
    public Object get(String propName) {
        if (propName.equals(PROP_C)) {
            return getC();
        }
        if (propName.equals(PROP_COUNTRY_NAME)) {
            return getCountryName();
        }
        if (propName.equals(PROP_DESCRIPTION)) {
            return getDescription();
        }
        return super.get(propName);
    }