:param list(SyntheticMember) syntheticMemberList: a list of the class' synthetic members.
503186
def makeEqualFunction(self, originalEqualFunction, syntheticMemberList):
        
        def equal(instance, other):
            if instance.__class__ is not other.__class__:
                return NotImplemented

            for m in syntheticMemberList:
                if getattr(instance, m.privateMemberName()) != getattr(other, m.privateMemberName()):
                    return False

            if inspect.isfunction(originalEqualFunction) or inspect.ismethod(originalEqualFunction):
                return originalEqualFunction(instance, other)

            return True

        return equal
184970
def add_members(self, members):
        
        if not isinstance(members, list):
            members = [members]

        if not getattr(self, 'members', None):
            self.members = members
        else:
            self.members.extend(members)
93390
private void addToList(List<Object> list, Object value) {
    if (value instanceof List) {
      list.addAll((List) value);
    } else {
      list.add(value);
    }
  }
1302170
def add_list_members(self, screen_name=None, user_id=None, slug=None,
                         list_id=None, owner_id=None, owner_screen_name=None):
        
        return self._add_list_members(list_to_csv(screen_name),
                                      list_to_csv(user_id),
                                      slug, list_id, owner_id,
                                      owner_screen_name)
129188
def makeConstructor(self, originalConstructor, syntheticMemberList, doesConsumeArguments):
        

        # Original constructor's expected args.
        originalConstructorExpectedArgList = []
        doesExpectVariadicArgs = False
        doesExpectKeywordedArgs = False

        if inspect.isfunction(originalConstructor) or inspect.ismethod(originalConstructor):
            argSpec = inspect.getargspec(originalConstructor)
            # originalConstructorExpectedArgList = expected args - self.
            originalConstructorExpectedArgList = argSpec.args[1:]
            doesExpectVariadicArgs = (argSpec.varargs is not None)
            doesExpectKeywordedArgs = (argSpec.keywords is not None)

        def init(instance, *args, **kwargs):

            if doesConsumeArguments:
                # Merge original constructor's args specification with member list and make an args dict.
                positionalArgumentKeyValueList = self._positionalArgumentKeyValueList(
                    originalConstructorExpectedArgList,
                    syntheticMemberList,
                    args)

            # Set members values.
            for syntheticMember in syntheticMemberList:
                memberName = syntheticMember.memberName()

                # Default value.
                value = syntheticMember.default()

                # Constructor is synthesized.
                if doesConsumeArguments:
                    value = self._consumeArgument(memberName,
                                                  positionalArgumentKeyValueList,
                                                  kwargs,
                                                  value)

                    # Checking that the contract is respected.
                    syntheticMember.checkContract(memberName, value)

                # Initalizing member with a value.
                setattr(instance,
                        syntheticMember.privateMemberName(),
                        value)

            if doesConsumeArguments:
                # Remove superfluous arguments that have been used for synthesization but are not expected by constructor.
                args, kwargs = self._filterArgsAndKwargs(
                    originalConstructorExpectedArgList=originalConstructorExpectedArgList,
                    syntheticMemberList=syntheticMemberList,
                    positionalArgumentKeyValueList=positionalArgumentKeyValueList,
                    keywordedArgDict=kwargs
                )

            # Call original constructor.
            if originalConstructor is not None:
                originalConstructor(instance, *args, **kwargs)


        return init
632620
def register_members(self):
        

        self._members = {
            name: attr for name, attr in iteritems(type(self).__dict__) if isinstance(attr, Group)}

        for name, m in iteritems(self._members):
            m.init_descriptor(name, self)
1358901
def get_list_class(context, list):
    
    return "list_%s_%s" % (list.model._meta.app_label, list.model._meta.model_name)
1300838
private static void overwriteMembersIfPresent(
      List<MemberDefinition> list, List<MemberDefinition> newMembers) {
    for (MemberDefinition newMember : newMembers) {
      for (MemberDefinition member : list) {
        if (member.name.getString().equals(newMember.name.getString())) {
          list.remove(member);
          break;
        }
      }
      list.add(newMember);
    }
  }
753035
def _str_member_list(self, name):
        
        out = []
        if self[name]:
            out += ['.. rubric:: %s' % name, '']
            prefix = getattr(self, '_name', '')

            if prefix:
                prefix = '~%s.' % prefix

            autosum = []
            others = []
            for param, param_type, desc in self[name]:
                param = param.strip()
                if not self._obj or hasattr(self._obj, param):
                    autosum += ["   %s%s" % (prefix, param)]
                else:
                    others.append((param, param_type, desc))

            if autosum:
                # GAEL: Toctree commented out below because it creates
                # hundreds of sphinx warnings
                # out += ['.. autosummary::', '   :toctree:', '']
                out += ['.. autosummary::', '']
                out += autosum

            if others:
                maxlen_0 = max([len(x[0]) for x in others])
                maxlen_1 = max([len(x[1]) for x in others])
                hdr = "=" * maxlen_0 + "  " + "=" * maxlen_1 + "  " + "=" * 10
                fmt = '%%%ds  %%%ds  ' % (maxlen_0, maxlen_1)
                n_indent = maxlen_0 + maxlen_1 + 4
                out += [hdr]
                for param, param_type, desc in others:
                    out += [fmt % (param.strip(), param_type)]
                    out += self._str_indent(desc, n_indent)
                out += [hdr]
            out += ['']
        return out
969680
def p_const_object_field_list(self, p):
        
        obj = p[1].copy()
        obj.update(p[2])
        p[0] = obj
504378
def tolist(self):
        
        return [[x.val for x in theclass.items] for theclass in self.classes]
51340
public void setList(List<T> list) {
        if (list != mList) {
            mList = list;
            if (mList == null) {
                notifyInvalidated();
            } else {
                notifyChanged();
            }
        }
    }
1116736
def p_objects_list(self, p):
        ''''''
        if len(p) == 3:
            p[1].append(p[2])
            p[0] = p[1]
        elif len(p) == 2:
            p[0] = [p[1]]
1220126
def list_of(cls):
    
    return lambda l: isinstance(l, list) and all(isinstance(x, cls) for x in l)
127323
def list(self, spec=None):
        

        if spec is None:
            spec = {}

        xmlrpc = XMLRPCConnection()
        try:
            pool_list = xmlrpc.connection.list_pool(
                {
                    'pool': spec,
                    'auth': AuthOptions().options
                })
        except xmlrpclib.Fault as xml_fault:
            raise _fault_to_exception(xml_fault)
        res = list()
        for pool in pool_list:
            p = Pool.from_dict(pool)
            res.append(p)

        return res
304887
def members(self):
        
        member_list_request = etcdrpc.MemberListRequest()
        member_list_response = self.clusterstub.MemberList(
            member_list_request,
            self.timeout,
            credentials=self.call_credentials,
            metadata=self.metadata
        )

        for member in member_list_response.members:
            yield etcd3.members.Member(member.ID,
                                       member.name,
                                       member.peerURLs,
                                       member.clientURLs,
                                       etcd_client=self)
1320335
def __construct_list(self, list_value):
        
        array = []
        for value in list_value:
            array.append(self.__iterate_value(value))
        return array