create a getter for computed properties
774533
function createGetter$1(namespace, mapping) {
        if (namespace) {
            return function () {
                var state = resolveObjectPath(this.$store.state, namespace, '/');

                return resolveObjectPath(state, mapping.key, '.');
            };
        }

        return function () {
            return resolveObjectPath(this.$store.state, mapping.key, '.');
        };
    }
1049949
def cached_property(func):
    """"""
    @functools.wraps(func)
    def cached_func(self):
        cacheattr = '_{}'.format(func.func_name)
        try:
            return getattr(self, cacheattr)
        except AttributeError:
            value = func(self)
            setattr(self, cacheattr, value)
            return value
    return property(cached_func)
1038929
def get_property(self):
        """"""
        scope = self

        def fget(self):
            """Call dynamic function then validate output"""
            scope.display_warning()
            return getattr(self, scope.new_name)

        def fset(self, value):
            """Validate and call setter"""
            scope.display_warning()
            setattr(self, scope.new_name, value)

        def fdel(self):
            """call deleter"""
            scope.display_warning()
            delattr(self, scope.new_name)

        return property(fget=fget, fset=fset, fdel=fdel, doc=scope.sphinx())
758587
function getModelProperty(model) {
    const className = model.constructor.name;
    const propsForModel = getProperties(model);
    return (prop) => {
        return propsForModel.find(value => {
            return value.property === prop;
        });
    };
}
710134
def cached_property(getter):
    
    def decorator(self):
        key = "_cached_property_" + getter.__name__

        if not hasattr(self, key):
            setattr(self, key, getter(self))

        return getattr(self, key)

    decorator.__name__ = getter.__name__
    decorator.__module__ = getter.__module__
    decorator.__doc__ = getter.__doc__

    return property(decorator)
688027
function get (obj, property, defaultValue) {
  if (isNull(obj) || isUndefined(obj)) {
    return defaultValue
  }
  var result = pathGet(obj, property)
  return isUndefined(result) ? defaultValue : result
}
325859
function makeGetterSetter(name) {
        xkcd[name] = function (value) {
            if (arguments.length === 0) {
                return config[name];
            }
            config[name] = value;
            return xkcd;
        };
    }
256752
function(property, sorted) {
            var getters = this.__collectAllPropertyValues.apply(this, ['__getters', 1].concat(property || []));

            if (!property) {
                return getters;
            }

            getters = getters[property];

            if (!sorted) {
                return getters[property];
            }

            var sortedGetters = [];

            for (var name in getters) {
                sortedGetters.push(getters[name]);
            }

            sortedGetters = sortedGetters.sort(function(s1, s2) { return s2[0] - s1[0]; });

            for (var i = 0, ii = sortedGetters.length; i < ii; ++i) {
                sortedGetters[i] = sortedGetters[i][1];
            }

            return sortedGetters;
        }
863920
function getProperty(object, propertyName) {
  const parts = propertyName.split('.');
  const length = parts.length;
  let property = object;

  for (let i = 0; i < length; i++) {
    if (property === undefined || property === null) {return property;}
    property = property[parts[i]];
  }

  return property;
}
85213
function createPropertyProvider(getValue, onchange) {
			var ret = new Object();
			ret.getValue = getValue;
			ret.onchange = onchange;
			return ret;
		}
626034
private String getPropertyForGetter(String getterName) {
        if (getterName == null || getterName.length() == 0) return null;

        if (getterName.startsWith("get")) {
            String prop = getterName.substring(3);
            return MetaClassHelper.convertPropertyName(prop);
        } else if (getterName.startsWith("is")) {
            String prop = getterName.substring(2);
            return MetaClassHelper.convertPropertyName(prop);
        }
        return null;
    }
500411
function setter(obj, path, setValue, fullExp) {
   var element = path.split('.'),
      key;
   for (var i = 0; element.length > 1; i++) {
      key = ensureSafeMemberName(element.shift(), fullExp);
      var propertyObj = obj[key];
      if (!propertyObj) {
         propertyObj = {};
         obj[key] = propertyObj;
      }
      obj = propertyObj;
   }
   key = ensureSafeMemberName(element.shift(), fullExp);
   obj[key] = setValue;
   return setValue;
}
48037
function (callback, binding) {
      var property;
      var empty = {};

      var properties = _emberMetalProperty_get.get(this, '_computedProperties');

      for (var i = 0, length = properties.length; i < length; i++) {
        property = properties[i];
        callback.call(binding || this, property.name, property.meta || empty);
      }
    }
598437
function elegantlyGet(obj, props) {
  if (typeof props === 'string') {
    props = props.split('/')
  }

  if (props.length === 0) {
    return obj
  }

  var prop = props.shift()

  if (prop && obj.hasOwnProperty(prop)) {
    return elegantlyGet(obj[prop], props)
  }

  return undefined
}
743107
function(path, value, data , op, computed){
    var computed = this.computed,
      op = op || "=", prev, 
      computedProperty = computed? computed[path]:null;

    if(op !== '='){
      prev = computedProperty? computedProperty.get(this): data[path];
      switch(op){
        case "+=":
          value = prev + value;
          break;
        case "-=":
          value = prev - value;
          break;
        case "*=":
          value = prev * value;
          break;
        case "/=":
          value = prev / value;
          break;
        case "%=":
          value = prev % value;
          break;
      }
    }
    if(computedProperty) {
      if(computedProperty.set) return computedProperty.set(this, value);
    }
    data[path] = value;
    return value;
  }
98231
function toEntries(object, properties) {
  return flatten(properties.map(name => {
    const p = descriptorOf(object, name);

    let result = [];

    if (p.get) {
      result.push({ name, value: p.get, kind: 'getter' });
    }
    if (p.set) {
      result.push({ name, value: p.set, kind: 'setter' });
    }
    if (p.value) {
      result.push({ name, value: p.value, kind: 'value' });
    }

    return result;
  }));
}
1356830
function(property, value, fields) {
            fields = fields || [];
            var getters = this.__getGetters(property, true);

            for (var i = 0, ii = getters.length; i < ii; ++i) {
                var result = getters[i].call(this, value, fields);

                if (!_.isUndefined(result)) {
                    value = result;
                }
            }

            return value;
        }