// Card will add a card to the Alexa app's response with the provided title and content strings.
192515
func (r *EchoResponse) Card(title string, content string) *EchoResponse {
	return r.SimpleCard(title, content)
}
501128
func (sd *StandardDeck) NextCard() (*card.Card, error) {
	var ans *card.Card

	if sd.idx < sd.Size() { // ensure we're not at the end of the cards array
		ans = sd.cards[sd.idx]
		sd.idx += 1 // go to the next card
		return ans, nil
	}

	// otherwise
	return &card.Card{}, deck.EmptyDeck{}
}
842997
func (c *Client) GetCreditCards(ccf *CreditCardsFilter) (*CreditCards, error) {
	page := 1
	if ccf != nil && ccf.Page > 0 {
		page = ccf.Page
	}
	pageSize := 10
	if ccf != nil && ccf.PageSize > 0 {
		pageSize = ccf.PageSize
	}

	req, err := c.NewRequest("GET", fmt.Sprintf("%s/v1/vault/credit-cards?page=%d&page_size=%d", c.APIBase, page, pageSize), nil)
	if err != nil {
		return nil, err
	}

	response := CreditCards{}

	if err = c.SendWithAuth(req, &response); err != nil {
		return nil, err
	}

	return &response, nil
}
157724
func (c ActionCollection) FirstCardCreateAction() *Action {
	sort.Sort(c)
	for _, action := range c {
		if action.DidCreateCard() {
			return action
		}
	}
	return nil
}
546681
func (db *RedisDB) ssetCard(key string) int {
	ss := db.sortedsetKeys[key]
	return ss.card()
}
755673
func (s *Statement) Id(name string) *Statement {
	t := token{
		typ:     identifierToken,
		content: name,
	}
	*s = append(*s, t)
	return s
}
1087895
func (_m *Light) ID() uint64 {
	ret := _m.Called()

	var r0 uint64
	if rf, ok := ret.Get(0).(func() uint64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(uint64)
	}

	return r0
}
1026038
func (api *ProductLicenseAPI) Include(key string) *ProductLicenseAPI {
	api.include(key)
	return api
}
1148655
func (r *EchoResponse) StandardCard(title string, content string, smallImg string, largeImg string) *EchoResponse {
	r.Response.Card = &EchoRespPayload{
		Type:    "Standard",
		Title:   title,
		Content: content,
	}

	if smallImg != "" {
		r.Response.Card.Image.SmallImageURL = smallImg
	}

	if largeImg != "" {
		r.Response.Card.Image.LargeImageURL = largeImg
	}

	return r
}
203105
func IsCreditCard(str string) bool {
	r, _ := regexp.Compile("[^0-9]+")
	sanitized := r.ReplaceAll([]byte(str), []byte(""))
	if !rxCreditCard.MatchString(string(sanitized)) {
		return false
	}
	var sum int64
	var digit string
	var tmpNum int64
	var shouldDouble bool
	for i := len(sanitized) - 1; i >= 0; i-- {
		digit = string(sanitized[i:(i + 1)])
		tmpNum, _ = ToInt(digit)
		if shouldDouble {
			tmpNum *= 2
			if tmpNum >= 10 {
				sum += ((tmpNum % 10) + 1)
			} else {
				sum += tmpNum
			}
		} else {
			sum += tmpNum
		}
		shouldDouble = !shouldDouble
	}

	if sum%10 == 0 {
		return true
	}
	return false
}
996376
func (t *FpdfTpl) ID() string {
	return fmt.Sprintf("%x", sha1.Sum(t.Bytes()))
}
428051
func (c *Client) PatchCreditCard(id string, ccf []CreditCardField) (*CreditCard, error) {
	req, err := c.NewRequest("PATCH", fmt.Sprintf("%s/v1/vault/credit-cards/%s", c.APIBase, id), ccf)
	if err != nil {
		return nil, err
	}

	response := CreditCard{}

	if err = c.SendWithAuth(req, &response); err != nil {
		return nil, err
	}

	return &response, nil
}
447168
func New(params *stripe.CardParams) (*stripe.Card, error) {
	return getC().New(params)
}
1322317
def set_card_simple(self, title, content):
        
        self.response.card.type = 'Simple'
        self.response.card.title = title
        self.response.card.content = content
589463
func NewImageCard(title, fimg, icon, textcontent string) ImageCard {
	card := ImageCard{}

	card.AddClass("card")

	card.image.AddClass("card-image")

	img := valente.Image{Source: fimg}
	card.image.AddElement(img)

	stitle := valente.Span{Text: title}
	stitle.AddClass("card-title")
	stitle.SetStyle("background-color", "#22222299")
	stitle.SetStyle("padding", "3px")

	card.image.AddElement(stitle)

	if len(icon) != 0 {
		aicon := valente.Link{Text: "<i class='material-icons'>" + icon + "</i>"}
		aicon.AddClass("btn-floating halfway-fab waves-effect waves-light red")
		card.image.AddElement(aicon)
	}

	card.Content.AddClass("card-content")
	card.Content.Text = "<p>" + textcontent + "</p>"

	card.AddElement(card.image)
	card.AddElement(card.Content)

	return card
}
1875
func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
	var key, value []byte
	parts := bytes.Split(tx, []byte("="))
	if len(parts) == 2 {
		key, value = parts[0], parts[1]
	} else {
		key, value = tx, tx
	}
	app.state.db.Set(prefixKey(key), value)
	app.state.Size += 1

	tags := []cmn.KVPair{
		{Key: []byte("app.creator"), Value: []byte("Cosmoshi Netowoko")},
		{Key: []byte("app.key"), Value: key},
	}
	return types.ResponseDeliverTx{Code: code.CodeTypeOK, Tags: tags}
}
855683
func (s *ProjectsService) ListProjectCards(ctx context.Context, columnID int64, opt *ProjectCardListOptions) ([]*ProjectCard, *Response, error) {
	u := fmt.Sprintf("projects/columns/%v/cards", columnID)
	u, err := addOptions(u, opt)
	if err != nil {
		return nil, nil, err
	}

	req, err := s.client.NewRequest("GET", u, nil)
	if err != nil {
		return nil, nil, err
	}

	// TODO: remove custom Accept headers when APIs fully launch.
	req.Header.Set("Accept", mediaTypeProjectsPreview)

	cards := []*ProjectCard{}
	resp, err := s.client.Do(ctx, req, &cards)
	if err != nil {
		return nil, resp, err
	}

	return cards, resp, nil
}