PRIVATE INSTANCE METHODS:
557593
private boolean setRangeMask(String ipString, String maskBitsString) {
		byte[] tmpMask = maskBits(maskBitsString);
		if(tmpMask != null) {
			if(setRangeIP(ipString)) {
				mask = tmpMask;
				ip = and(ip,mask);
				return true;
			}
		}
		return false;
	}
729842
def build_leaf(object)
      this = self
      run_validator = method(:run_validator)
      check_types = method(:check_types)

      object.instance_exec do
        define_singleton_method(this.name) { this.value }
        define_singleton_method("#{this.name}=") do |value|
          run_validator.call(value)
          check_types.call(value)
          this.value = value
        end
      end

      object
    end
613712
def instance_get(attribute)
      getter = :"#{self.name}_#{attribute}"
      self.instance.send(getter) if instance.respond_to?(getter)
    end
1033926
def setup(only: nil, except: nil)
      items = instance_methods.map(&:to_s) - %w[setup]
      items -= Array.wrap(except).map(&:to_s) if except
      if only
        only = Array.wrap(only).map(&:to_s)
        items &= only
        items += only
      end
      items.uniq.each { |item| public_send(item) }
    end
1067017
def create_getter(name, value)
      instance_variable_set(:"@#{name}", value)
      create_method(name.to_sym) do
        instance_variable_get(:"@#{name}")
      end
    end
497793
def instantiate(self, scope, args, interp):
        
        param_instances = []

        BYREF = "byref"

        # TODO are default values for function parameters allowed in 010?
        for param_name, param_cls in self._params:
            # we don't instantiate a copy of byref params
            if getattr(param_cls, "byref", False):
                param_instances.append(BYREF)
            else:
                field = param_cls()
                field._pfp__name = param_name
                param_instances.append(field)

        if len(args) != len(param_instances):
            raise errors.InvalidArguments(
                self._coords,
                [x.__class__.__name__ for x in args],
                [x.__class__.__name__ for x in param_instances]
            )

        # TODO type checking on provided types

        for x in six.moves.range(len(args)):
            param = param_instances[x]
             
            # arrays are simply passed through into the function. We shouldn't
            # have to worry about frozenness/unfrozenness at this point
            if param is BYREF or isinstance(param, pfp.fields.Array):
                param = args[x]
                param_instances[x] = param
                scope.add_local(self._params[x][0], param)
            else:
                param._pfp__set_value(args[x])
                scope.add_local(param._pfp__name, param)
            param._pfp__interp = interp

        return ParamList(param_instances)
289504
def public_attributes(instance)
      definitions.values.each_with_object({}) do |item, obj|
        key = item.target
        next unless instance.respond_to? key
        val = instance.send(key)
        obj[key] = val unless null == val
      end
    end
695272
function(contexts) {

        if ( typeof(contexts) == 'undefined' ) {
            var contexts = {
                paths : {}
            }
        }

        self.contexts = contexts;

        if ( typeof(ContextHelper.initialized) != 'undefined' && ContextHelper.instance) {
            self = ContextHelper.instance;
        } else {
            ContextHelper.initialized = true;
            ContextHelper.instance = self
        }



        return self
    }
1040844
function(context, descriptor, args) {
		var name = args[0],
			value = args[1],
			hasValue = typeof value !== 'undefined';
		descriptor.attributes += ' ' + name + (hasValue ? ('="' + (value.__interpolable__ ? value.output(context) : value) + '"') : '');
	}
537763
function() {
    var objKeys = []
    var self = this

    this.use(function() {
      // get all current property names
      objKeys = Object.keys(this)
    }, 90)

    this.on('finished', function() {
      // an now search for new ones ==> instance methods for our new model class

      Object.keys(self).forEach(function(name) {
        if (objKeys.indexOf(name) === -1) {
          self.instanceMethods[name] = self[name]
          delete self[name]
        }
      })
    })
  }
279780
function instance_getters () {
        var _parseArguments = parseArguments$1(arguments),
            getters = _parseArguments.getters,
            options = _parseArguments.options;

        return Object.keys(getters).reduce(function (instanceGetters, name) {
            instanceGetters[name] = function (state, otherGetters) {
                return function (instanceKey) {
                    var instance = state[options.stateKey || 'instances'].find(function (obj) {
                        return obj[options.instanceKey || 'id'] === instanceKey;
                    });

                    if (instance) {
                        return getters[name](instance, otherGetters, state, instanceKey);
                    }
                };
            };

            return instanceGetters;
        }, {});
    }
1010200
function (objData, resource) {

    if(Utils.isObject(objData)){

      if(objData instanceof Resource){
        this.resource = objData;
      } else {
        this.resource = resource;
        Utils.extend(this, objData, true);
      }

    }
  }
676019
function each(obj, iterator, context) {
    var i;

    if (!obj) {
        return;
    }

    if (obj.forEach) {
        obj.forEach(iterator, context);
    } else if (obj.length !== undefined) {
        i = 0;
        while (i < obj.length) {
            iterator.call(context, obj[i], i, obj);
            i++;
        }
    } else {
        for (i in obj) {
            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
        }
    }
}
1008131
protected void recursiveExtractInstances(Area root, Instances dest)
    {
        Instance newinst = features.getAreaFeatures(root, dest);
        
        String cls = defaultClass;
        for (Tag tag : root.getTags().keySet())
        {
            if (tag.getType().equals(tagType))
                cls = tag.getValue();
        }
        newinst.setClassValue(cls);
        dest.add(newinst);
        
        for (int i = 0; i < root.getChildCount(); i++)
            recursiveExtractInstances(root.getChildAt(i), dest);
    }
335909
function NWTEventInstance (e, attrs) {
	this._e = e;
	this.target = new NWTNodeInstance(e.target);

	for (var i in attrs) {
		this[i] = attrs[i];
	}
}
777037
public static void initialize(Object backend,
            BackendInstanceSpec backendInstanceSpec)  {
        assert backend != null : "backend cannot be null";
        assert backendInstanceSpec != null :
            "backendInstanceSpec cannot be null";
        for (Method method : backend.getClass().getMethods()) {
            if (method.isAnnotationPresent(BackendProperty.class)) {
                try {
                    BackendProperty annotation =
                            method.getAnnotation(BackendProperty.class);
                    String propertyName = propertyName(annotation, method);
                    Object propertyValue =
                            backendInstanceSpec.getProperty(propertyName);
                    if (propertyValue != null) {
                            method.invoke(backend,
                                    new Object[]{propertyValue
                                });
                    }
                } catch (IllegalAccessException | InvalidPropertyNameException | InvocationTargetException ex) {
                    throw new AssertionError(ex);
                }
            }
        }
    }
455461
def private_props(obj):
    
    # Get private properties but NOT magic methods
    props = [item for item in dir(obj)]
    priv_props = [_PRIVATE_PROP_REGEXP.match(item) for item in props]
    call_props = [callable(getattr(obj, item)) for item in props]
    iobj = zip(props, priv_props, call_props)
    for obj_name in [prop for prop, priv, call in iobj if priv and (not call)]:
        yield obj_name