append new cards into adapter

@param cards new cards will be added to the end
325698
public void appendGroup(@Nullable List<L> cards) {
        if (cards == null || cards.size() == 0)
            return;

        createSnapshot();

        final List<LayoutHelper> helpers = new LinkedList<>(getLayoutHelpers());

        mCards.ensureCapacity(mCards.size() + cards.size());

        helpers.addAll(transformCards(cards, mData, mCards));

        setLayoutHelpers(helpers);

        diffWithSnapshot();

        // not use {@link notifyItemRangeChanged} because not sure whether animations is required
        // notifyItemRangeChanged(oldItem, newitems);
        notifyDataSetChanged();
    }
663608
public void addExtensions(Collection<ExtensionElement> extensions) {
        if (extensions == null) return;
        for (ExtensionElement packetExtension : extensions) {
            addExtension(packetExtension);
        }
    }
1017592
function addCard(contentType, currentActivity, rest) {
    let card = { buttons: [] };
    let lines = rest.split('\n');
    for (let line of lines) {
        let start = line.indexOf('=');
        let property = line.substr(0, start).trim().toLowerCase();
        let value = line.substr(start + 1).trim();
        switch (property) {
        case 'title':
        case 'subtitle':
        case 'text':
        case 'aspect':
        case 'value':
        case 'connectioname':
            card[property] = value;
            break;
        case 'image':
            card.image = { url: value };
            break;
        case 'images':
            if (!card.images) {
                card.images = [];
            }
            card.images.push({ url: value });
            break;
        case 'media':
            if (!card.media)
                card.media = [];
            card.media.push({ url: value });
            break;
        case 'buttons':
            for (let button of value.split('|')) {
                card.buttons.push({ title: button.trim(), type: "imBack", value: button.trim() });
            }
            break;
        case 'autostart':
        case 'sharable':
        case 'autoloop':
            card[property] = value.toLowerCase() == 'true';
            break;
        case '':
            break;
        default:
            console.warn(chalk.red.bold(`Skipping unknown card property ${property}\n${line}`));
            break;
        }
    }
    let attachment = { contentType: contentType, content: card };
    (currentActivity.attachments || (currentActivity.attachments = [])).push(attachment);
}
1353832
public void add(ShortArrayList values) {
        ensureCapacity(size + values.size);
        for (int i=0; i<values.size; i++) {
            this.add(values.elements[i]);
        }
    }
401539
public boolean addAll(int[] items) {
    ensureCapacity(size + items.length);
    for (int i = 0; i < items.length; i++) {
      elements[size++] = items[i];
    }
    return items.length > 0;
  }
1029864
@Override
    public void addAppender(Appender newAppender) {
        // Null values for newAppender parameter are strictly forbidden.
        if (newAppender == null) {
            return;
        }
        // If the appender is already there, add this one to the end before
        // removing the
        // previous one
        boolean isAppenderPresent = appenderList.contains(newAppender);
        String appenderName = newAppender.getName() != null ? newAppender.getName(): "default";
        if (isAppenderPresent) {
            appenderList.add(newAppender);
            for (Iterator<Appender> it = appenderList.iterator(); it.hasNext();) {
                Appender appender = it.next();
                if (newAppender.equals(appender)) {
                    configuredAppenderList.add(appenderName);
                    it.remove();
                    appender.close();
                    return;
                }
            }
        } else {
            appenderList.add(newAppender);
        }
        configuredAppenderList.add(appenderName);
    }
1374144
public void add(LongArrayList values) {
        ensureCapacity(size + values.size);
        for (int i=0; i<values.size; i++) {
            this.add(values.elements[i]);
        }
    }
1094636
def create(cls, cards, custom_headers=None):
        

        if custom_headers is None:
            custom_headers = {}

        request_map = {
            cls.FIELD_CARDS: cards
        }
        request_map_string = converter.class_to_json(request_map)
        request_map_string = cls._remove_field_for_request(request_map_string)

        api_client = client.ApiClient(cls._get_api_context())
        request_bytes = request_map_string.encode()
        endpoint_url = cls._ENDPOINT_URL_CREATE.format(cls._determine_user_id())
        response_raw = api_client.post(endpoint_url, request_bytes,
                                       custom_headers)

        return BunqResponseCardBatch.cast_from_bunq_response(
            cls._from_json(response_raw, cls._OBJECT_TYPE_POST)
        )
394573
def attachments
      attachments = Attachment.from_response client.get("/cards/#{id}/attachments")
      MultiAssociation.new(self, attachments).proxy
    end
1997
public void addAll(int index, T... items) {
        List<T> collection = Arrays.asList(items);
        synchronized (mLock) {
            if (mOriginalValues != null) {
                mOriginalValues.addAll(index, collection);
            } else {
                mObjects.addAll(index, collection);
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
    }
47892
@CheckResult
    @NonNull
    public final PowerAdapter prepend(@NonNull PowerAdapter... adapters) {
        checkNotNull(adapters, "adapters");
        if (adapters.length == 0) {
            return this;
        }
        return new ConcatAdapterBuilder().addAll(adapters).add(this).build();
    }
331130
protected void readWithAID() throws CommunicationException {
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("Try to read card with AID");
		}
		// Test each card from know EMV AID
		Application app = new Application();
		for (EmvCardScheme type : EmvCardScheme.values()) {
			for (byte[] aid : type.getAidByte()) {
				app.setAid(aid);
				app.setApplicationLabel(type.getName());
				String applicationAid = BytesUtils.bytesToStringNoSpace(aid);
				for (IParser impl : parsers) {
					if (impl.getId() != null && impl.getId().matcher(applicationAid).matches() && impl.parse(app)) {
						// Remove previously added Application template
						card.getApplications().clear();
						// Add Application
						card.getApplications().add(app);
						return;
					}
				}
			}
		}
	}
200426
public final void addEntries(Iterator<Entry<?>> entries) {
        if (entries != null) {
            while (entries.hasNext()) {
                addEntry(entries.next());
            }
        }
    }
1078718
public void appendElements(ExtensionPoint... elements) {
    List<ExtensionPoint> rc = new ArrayList<ExtensionPoint>();
    rc.addAll(Arrays.asList(this.elements));
    rc.addAll(Arrays.asList(elements));
    this.elements = rc.toArray(new ExtensionPoint[0]);
  }
291258
public void addAdapters(int position, @Nullable List<Adapter> adapters) {
        if (adapters == null || adapters.size() == 0) {
            return;
        }
        if (position < 0) {
            position = 0;
        }

        if (position > mAdapters.size()) {
            position = mAdapters.size();
        }

        List<Adapter> newAdapter = new ArrayList<>();
        Iterator<Pair<AdapterDataObserver, Adapter>> itr = mAdapters.iterator();
        while (itr.hasNext()) {
            Pair<AdapterDataObserver, Adapter> pair = itr.next();
            Adapter theOrigin = pair.second;
            newAdapter.add(theOrigin);
        }
        for (Adapter adapter : adapters) {
            newAdapter.add(position, adapter);
            position++;
        }
        setAdapters(newAdapter);
    }
1053172
def _update_card(self, card_name, new_value, add_quotes=False):
        
        self.project_manager.setCard(card_name, new_value, add_quotes)
1104217
public void addProcessors(Collection<ItemProcessor> processors) {
        if (processors == null) {
            processors = new ArrayList<>();
        }

        processors.addAll(processors);
    }