Helper method to add card storage enable flag.

@param cardStorageEnable
@return HppRequest
197742
public HppRequest addCardStorageEnable(boolean cardStorageEnable) {
		this.cardStorageEnable = cardStorageEnable ? Flag.TRUE.getFlag() : Flag.FALSE.getFlag();
		return this;
	}
760242
public function setPaycell($card_id, $is_open = true)
    {
        $url = "https://api.weixin.qq.com/card/paycell/set?access_token=ACCESS_TOKEN";
        $this->registerApi($url, __FUNCTION__, func_get_args());
        return $this->httpPostForJson($url, ['card_id' => $card_id, 'is_open' => $is_open]);
    }
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);
}
565943
function vCard() {

  if( !(this instanceof vCard) )
    return new vCard()

  /** @type {String} Version number */
  this.version = vCard.versions[ vCard.versions.length - 1 ]
  /** @type {Object} Card data */
  this.data = {}

}
1199401
public void addAvailableLoad(AvailableLoad availableLoad, @Nonnull ValueNumber[] value) {
        Objects.requireNonNull(value);
        getUpdateableAvailableLoadMap().put(availableLoad, value);

        for (ValueNumber v : value) {
            getUpdateablePreviouslyKnownAs().put(v, availableLoad);
            if (RLE_DEBUG) {
                System.out.println("Adding available load of " + availableLoad + " for " + v + " to "
                        + System.identityHashCode(this));
            }
        }
    }
1254633
function (pack, card) {
    if (cardPacks[pack] && cardPacks[pack].cards[card]) {
      return cardPacks[pack].cards[card];
    }
  }
1354217
public function card($card)
    {
        if ($card instanceof Card) {
            $this->card = $card;

            return $this;
        }

        if ($card instanceof Closure) {
            $card($new = new Card());
            $this->card = $new;

            return $this;
        }

        throw new InvalidArgumentException(
            'Invalid Card type. Expected '.Card::class.' or '.Closure::class.'.'
        );
    }
417993
def ActivateCard(self, card):
        """"""
        if not hasattr(card, 'connection'):
            card.connection = card.createConnection()
            if None != self.parent.apdutracerpanel:
                card.connection.addObserver(self.parent.apdutracerpanel)
            card.connection.connect()
        self.dialogpanel.OnActivateCard(card)
924101
public Postcard withParcelableArrayList(@Nullable String key, @Nullable ArrayList<? extends Parcelable> value) {
        mBundle.putParcelableArrayList(key, value);
        return this;
    }
346557
public static <K,V> Storage<K,V> createHashtableStorage(){
		return new Storage<K,V>(new MapStorageWrapper<K, V>(new HashMap<K, V>()));
	}
211660
public void populatePrefixTable() {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(TRACE, "populatePrefixTable");
        }

        // Create the storage.
        prefixTable = new HashMap<Class,String>();

        // Populate with the supported (non-null) data types.
        prefixTable.put(Boolean.class, PREFIX_BOOLEAN);
        prefixTable.put(Integer.class, PREFIX_INT);
        prefixTable.put(Byte.class, PREFIX_BYTE);
        prefixTable.put(Short.class, PREFIX_SHORT);
        prefixTable.put(String.class, PREFIX_STRING);
        prefixTable.put(Float.class, PREFIX_FLOAT);
        prefixTable.put(Double.class, PREFIX_DOUBLE);
        prefixTable.put(Long.class, PREFIX_LONG);
        prefixTable.put(StringArrayWrapper.class, PREFIX_ROUTING_PATH);

        
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(TRACE, "populatePrefixTable");
        }

    }
313022
public static <K,V> Storage<K,V> createConcurrentHashMapStorage(String name){
		return new Storage<K,V>(name, new MapStorageWrapper<K, V>(new ConcurrentHashMap<K, V>()));
	}
130454
public HppRequest addDccEnable(boolean dccEnable) {
		this.dccEnable = dccEnable ? Flag.TRUE.getFlag() : Flag.FALSE.getFlag();
		return this;
	}
488422
public ResponseBuilder withSimpleCard(String cardTitle, String cardText) {
        this.card = SimpleCard.builder()
                .withContent(cardText)
                .withTitle(cardTitle)
                .build();
        return this;
    }
705214
protected function addStorageFiles()
    {
        $items = $this->package->getStorageServices();
        foreach ($items as $service => $resources) {
            if (is_string($resources)) {
                $resources = explode(',', $resources);
            }
            foreach ($resources as $resourceName => $resource) {
                // If reachable flag is present and service is not reachable then skip it.
                if ($resourceName === static::REACHABLE_FLAG && $resource === false) {
                    continue;
                }

                if (Session::checkServicePermission(
                    Verbs::GET, $service, $resource, Session::getRequestor(), false
                )) {
                    /** @type FileServiceInterface $storage */
                    $storage = ServiceManager::getService($service);
                    if (!$storage) {
                        throw new InternalServerErrorException("Can not find storage service $service.");
                    }

                    if ($storage->folderExists($resource)) {
                        $zippedResource = $this->getStorageFolderZip($storage, $resource);
                        if ($zippedResource !== false) {
                            $newFileName = $service . '/' . rtrim($resource, '/') . '/' . md5($resource) . '.zip';
                            $this->package->zipFile($zippedResource, $newFileName);
                            $this->destructible[] = $zippedResource;
                        }
                    } elseif ($storage->fileExists($resource)) {
                        $content = $storage->getFileContent($resource, null, false);
                        $this->package->zipContent($service . '/' . $resource, $content);
                    }
                }
            }
        }
    }
629807
public void doLoad(final Card card) {
        if (mAsyncLoader == null) {
            return;
        }
        if (!card.loading && !card.loaded) {
            card.loading = true;
            mAsyncLoader.loadData(card, new AsyncLoader.LoadedCallback() {
                @Override
                public void finish() {
                    card.loading = false;
                    card.loaded = true;
                }

                @Override
                public void finish(List<BaseCell> cells) {
                    finish();
                    card.addCells(cells);
                    card.notifyDataChange();
                }

                public void fail(boolean loaded) {
                    card.loading = false;
                    card.loaded = loaded;
                }
            });
        }
    }
996516
public function execute()
    {
        parent::execute();

        $addValueSvc = new HpsGiftCardService($this->service->servicesConfig());
        if ($this->token != null && ($this->token instanceof HpsTokenData)) {
            if ($this->card == null) {
                $this->card = new HpsGiftCard();
            }
            $this->card->tokenValue = $this->token->tokenValue;
        }
        return $addValueSvc->addValue(
            $this->amount,
            $this->currency,
            $this->card
        );
    }