text:
/*
 * Rich text editor form field control (WYSIWYG)
 *
 * Data attributes:
 * - data-control="richeditor" - enables the rich editor plugin
 *
 * JavaScript API:
 * $('textarea').richEditor()
 *
 * Dependancies:
 * - Redactor Editor (redactor.js)
 */
+function ($) { "use strict";
    var Base = $.oc.foundation.base,
        BaseProto = Base.prototype

    // RICHEDITOR CLASS DEFINITION
    // ============================

    var RichEditor = function(element, options) {
        this.options     = options
        this.$el         = $(element)
        this.$textarea   = this.$el.find('>textarea:first')
        this.$form       = this.$el.closest('form')
        this.$dataLocker = null
        this.$editor     = null
        this.redactor    = null

        $.oc.foundation.controlUtils.markDisposable(element)

        Base.call(this)

        this.init()
    }

    RichEditor.prototype = Object.create(BaseProto)
    RichEditor.prototype.constructor = RichEditor

    RichEditor.DEFAULTS = {
        dataLocker: null,
        linksHandler: null,
        stylesheet: null,
        fullpage: false
    }

    RichEditor.prototype.init = function() {
        var self = this;

        this.$el.one('dispose-control', this.proxy(this.dispose))

        /*
         * Sync all changes to a data locker, since fullscreen mode
         * will pull the textarea outside of the form element.
         */
        if (this.options.dataLocker) {
            this.$dataLocker = $(this.options.dataLocker)
            this.$textarea.val(this.$dataLocker.val())
        }

        /*
         * Textarea must have an identifier
         */
        if (!this.$textarea.attr('id')) {
            this.$textarea.attr('id', 'element-' + Math.random().toString(36).substring(7))
        }

        /*
         * Initialize Redactor editor
         */
        var redactorOptions = {
            imageEditable: true,
            imageResizable: true,
            buttonSource: true,
            removeDataAttr: false,
            toolbarFixed: false,
            syncBeforeCallback: this.proxy(this.onSyncBefore),
            focusCallback: this.proxy(this.onFocus),
            blurCallback: this.proxy(this.onBlur),
            keydownCallback: this.proxy(this.onKeydown),
            enterCallback: this.proxy(this.onEnter),
            changeCallback: this.proxy(this.onChange),
            pageLinksHandler: this.options.linksHandler,
            initCallback: function() { self.build(this) }
        }

        if (this.options.fullpage) {
            redactorOptions.fullpage = true
        }

        redactorOptions.plugins = ['fullscreen', 'figure', 'table', 'pagelinks', 'mediamanager']
        redactorOptions.buttons = ['html', 'formatting', 'bold', 'italic', 'alignment', 'unorderedlist', 'orderedlist', 'link', 'horizontalrule'],

        this.$textarea.redactor(redactorOptions)

        this.redactor = this.$textarea.redactor('core.getObject')
        this.$editor = this.redactor.$editor
    }

    RichEditor.prototype.dispose = function() {
        this.unregisterHandlers()

        // Release clickedElement reference inside redactor.js
        $(document).trigger('mousedown')

        this.redactor.core.destroy()

        // The figure plugin keeps references to the editor,
        // DOM elements and event handlers. It was hacked and
        // extended with the destroy() method.
        if (this.redactor.figure) {
            this.redactor.figure.destroy()
            this.redactor.figure = null
        }

        this.$el.removeData('oc.richEditor')

        this.options = null
        this.$el = null
        this.$textarea = null
        this.$form = null
        this.$dataLocker = null
        this.$editor = null

        this.redactor.$textarea = null
        this.redactor.$element = null

        this.redactor = null

        BaseProto.dispose.call(this)
    }

    RichEditor.prototype.unregisterHandlers = function() {
        $(window).off('resize', this.proxy(this.updateLayout))
        $(window).off('oc.updateUi', this.proxy(this.updateLayout))
        this.$el.off('dispose-control', this.proxy(this.dispose))
    }

    RichEditor.prototype.build = function(redactor) {
        this.updateLayout()

        $(window).on('resize', this.proxy(this.updateLayout))
        $(window).on('oc.updateUi', this.proxy(this.updateLayout))

        this.$textarea.trigger('init.oc.richeditor', [this.$el])

        this.initUiBlocks()

        var self = this
        redactor.default = {
            onShow: function($figure, $toolbar) {
                self.onShowFigureToolbar($figure, $toolbar)
            }
        }
    }

    RichEditor.prototype.updateLayout = function() {
        var $editor = $('.redactor-editor', this.$el),
            $codeEditor = $('textarea', this.$el),
            $toolbar = $('.redactor-toolbar', this.$el)

        if (!$editor.length)
            return

        if (this.$el.hasClass('stretch')) {
            var height = $toolbar.outerHeight(true)
            $editor.css('top', height+1)
            $codeEditor.css('top', height)
        }
    }

    RichEditor.prototype.sanityCheckContent = function() {
        // First and last elements should always be paragraphs, lists or pre
        var safeElements = 'p, h1, h2, h3, h4, h5, pre, figure, ol, ul';

        if (!this.$editor.children(':last-child').is(safeElements)) {
            this.$editor.append('

')
        }

        if (!this.$editor.children(':first-child').is(safeElements)) {
            this.$editor.prepend('

')
        }

        this.$textarea.trigger('sanitize.oc.richeditor', [this.$editor])
    }

    RichEditor.prototype.syncBefore = function(html) {
        var container = {
            html: html
        }

        this.$textarea.trigger('syncBefore.oc.richeditor', [container])

        var $domTree = $('
'+container.html+'
')

        // This code removes Redactor-specific attributes and tags from the code.
        // It seems to be a known problem with Redactor, try googling for
        // "data-redactor-tag" or "redactor-invisible-space" (with quotes)
        $('*', $domTree).removeAttr('data-redactor-tag')

        $domTree.find('span[data-redactor-class="redactor-invisible-space"]').each(function(){
            $(this).children().insertBefore(this)
            $(this).remove()
        })

        $domTree.find('span.redactor-invisible-space').each(function(){
            $(this).children().insertBefore(this)
            $(this).remove()
        })

        $domTree.find('[data-video], [data-audio]').each(function(){
            $(this).removeAttr('contenteditable data-ui-block tabindex')
        })

        $domTree.find('div.oc-figure-controls').remove()

        return $domTree.html()
    }

    RichEditor.prototype.onShowFigureToolbar = function($figure, $toolbar) {
        // Deal with the case when the toolbar top has negative
        // value
        var toolbarTop = $figure.position().top - $toolbar.height() - 10

        $toolbar.toggleClass('bottom', toolbarTop < 0)
    }

    /*
     * Inserts non-editable block (used for snippets, audio and video)
     */
    RichEditor.prototype.insertUiBlock = function($node) {
        var current = this.redactor.selection.getCurrent(),
            inserted = false

        if (current === false)
            this.redactor.focus.setStart()

        current = this.redactor.selection.getCurrent()

        if (current !== false) {
            // If the block is inserted into a paragraph, insert it after the paragraph.
            var $paragraph = $(current).closest('p')
            if ($paragraph.length > 0) {
                this.redactor.caret.setAfter($paragraph.get(0))

                // If the paragraph is empty, remove it.
                if ($.trim($paragraph.text()).length == 0)
                    $paragraph.remove()
            }
            else {
                // If block is inserted into another UI block, insert it after the existing block.
                var $closestBlock = $(current).closest('[data-ui-block]')
                if ($closestBlock.length > 0) {
                    $node.insertBefore($closestBlock.get(0))
                    inserted = true
                }
            }
        }

        if (!inserted)
            this.redactor.insert.node($node)

        this.redactor.code.sync()

        $node.focus()
    }

    RichEditor.prototype.initUiBlocks = function() {
        $('.redactor-editor [data-video], .redactor-editor [data-audio]', this.$el).each(function() {
            $(this).attr({
                'data-ui-block': true,
                'tabindex': '0'
            })
            this.contentEditable = false
        })
    }

    RichEditor.prototype.handleUiBlocksKeydown = function(ev) {
        if (this.$textarea === undefined)
            return

        if (ev.target && $(ev.target).attr('data-ui-block') !== undefined) {
            this.uiBlockKeyDown(ev, ev.target)

            ev.preventDefault()
            return
        }

        switch (ev.which) {
            case 38:
                // Up arrow
                var block = this.redactor.selection.getBlock()
                if (block)
                    this.handleUiBlockCaretIn($(block).prev())
            break
            case 40:
                // Down arrow
                var block = this.redactor.selection.getBlock()
                if (block)
                    this.handleUiBlockCaretIn($(block).next())
            break
        }
    }

    RichEditor.prototype.handleUiBlockCaretIn = function($block) {
        if ($block.attr('data-ui-block') !== undefined) {
            $block.focus()
            this.redactor.selection.remove()

            return true
        }

        return false
    }

    RichEditor.prototype.uiBlockKeyDown = function(ev, block) {
        if (ev.which == 40 || ev.which == 38 || ev.which == 13 || ev.which == 8) {
            switch (ev.which) {
                case 40:
                    // Down arrow
                    this.focusUiBlockOrText($(block).next(), true)
                break
                case 38:
                    // Up arrow
                    this.focusUiBlockOrText($(block).prev(), false)
                break
                case 13:
                    // Enter key
                    var $paragraph = $('

')
                    $paragraph.insertAfter(block)
                    this.redactor.caret.setStart($paragraph.get(0))
                break
                case 8:
                    // Backspace key
                    var $nextFocus = $(block).next(),
                        gotoStart = true

                    if ($nextFocus.length == 0) {
                        $nextFocus = $(block).prev()
                        gotoStart = false
                    }

                    this.focusUiBlockOrText($nextFocus, gotoStart)

                    $(block).remove()
                break
            }
        }
    }

    RichEditor.prototype.focusUiBlockOrText = function($block, gotoStart) {
        if ($block.length > 0) {
            if (!this.handleUiBlockCaretIn($block, this.redactor)) {
                if (gotoStart)
                    this.redactor.caret.setStart($block.get(0))
                else
                    this.redactor.caret.setEnd($block.get(0))
            }
        }
    }

    // EVENT HANDLERS
    // ============================

    RichEditor.prototype.onSyncBefore = function(html) {
        return this.syncBefore(html)
    }

    RichEditor.prototype.onFocus = function() {
        this.$el.addClass('editor-focus')
    }

    RichEditor.prototype.onBlur = function() {
        this.$el.removeClass('editor-focus')
    }

    RichEditor.prototype.onKeydown = function(ev) {
        this.$textarea.trigger('keydown.oc.richeditor', [ev, this.$editor, this.$textarea])

        if (ev.isDefaultPrevented())
            return false

        this.handleUiBlocksKeydown(ev)

        if (ev.isDefaultPrevented())
            return false
    }

    RichEditor.prototype.onEnter = function(ev) {
        this.$textarea.trigger('enter.oc.richeditor', [ev, this.$editor, this.$textarea])

        if (ev.isDefaultPrevented())
            return false

        this.handleUiBlocksKeydown(ev)

        if (ev.isDefaultPrevented())
            return false
    }

    RichEditor.prototype.onChange = function(ev) {
        this.sanityCheckContent()
        this.$editor.trigger('mutate')
        this.$form.trigger('change')

        if (this.$dataLocker)
            this.$dataLocker.val(this.syncBefore(this.$editor.html()))
    }

    // RICHEDITOR PLUGIN DEFINITION
    // ============================

    var old = $.fn.richEditor

    $.fn.richEditor = function (option) {
        var args = arguments;

        return this.each(function () {
            var $this   = $(this)
            var data    = $this.data('oc.richEditor')
            var options = $.extend({}, RichEditor.DEFAULTS, $this.data(), typeof option == 'object' && option)
            if (!data) $this.data('oc.richEditor', (data = new RichEditor(this, options)))

            if (typeof option == 'string') {
                var methodArgs = [];
                for (var i=1; i<args.length; i++)
                    methodArgs.push(args[i])

                data[option].apply(data, methodArgs)
            }
        })
    }

    $.fn.richEditor.Constructor = RichEditor

    // RICHEDITOR NO CONFLICT
    // =================

    $.fn.richEditor.noConflict = function () {
        $.fn.richEditor = old
        return this
    }

    // RICHEDITOR DATA-API
    // ===============
    $(document).render(function () {
        $('[data-control="richeditor"]').richEditor()
    })

}(window.jQuery);


text:
using System.Net.Http;
using System.Threading.Tasks;
using MailChimp.Api.Net.Domain.TemplateFolders;

namespace MailChimp.Api.Net.Services.TemplateFolders
{
  // =====================================================
  // AUTHOR      : Keith Fimreite, Enkode LLC
  // PURPOSE     : Organize your templates using folders
  // =====================================================

  public class MailChimpTemplateFolders
  {
    private MCTemplateFolderOverview mcTemplateFolderOverview;

    public MailChimpTemplateFolders()
    {
      mcTemplateFolderOverview = new MCTemplateFolderOverview();
    }

    /// <summary>
    /// Create a new template folder
    /// <param name="folderName">The name of the folder</param>
    /// </summary>
    public async Task<dynamic> AddTemplateFolderAsync(string folderName)
    {
      return await mcTemplateFolderOverview.AddTemplateFolderAsync(folderName);
    }

    /// <summary>
    /// Update a campaign folder
    /// <param name="name">Name to associate with the folder.</param>
    /// <param name="folder_id">Unique id for the list</param>
    /// </summary>
    public async Task<dynamic> UpdateTemplateFolderAsync(string name, string folder_id)
    {
      return await mcTemplateFolderOverview.UpdateTemplateFolderAsync(name, folder_id);
    }

    /// <summary>
    /// Get all template folders
    /// <param name="offset">The number of records from a collection to skip. Iterating over large collections with this parameter can be slow</param>
    /// <param name="count">The number of records to return.</param>
    /// </summary>
    public async Task<RootTemplateFolder> GetAllTemplateFoldersAsync(int offset = 0, int count = 10)
    {
      return await mcTemplateFolderOverview.GetAllTemplateFoldersAsync(offset = 0, count = 10);
    }

    /// <summary>
    /// Get a specific template folder
    /// <param name="folder_id">Unique id for the template folder</param>
    /// </summary>
    public async Task<TemplateFolder> GetTemplateFolderAsync(string folder_id)
    {
      return await mcTemplateFolderOverview.GetTemplateFolderAsync(folder_id);
    }

    /// <summary>
    /// Delete a template folder
    /// <param name="folder_id">Unique id for the template folder</param>
    /// </summary>
    public async Task<HttpResponseMessage> DeleteTemplateFolderAsync(string folder_id)
    {
      return await mcTemplateFolderOverview.DeleteTemplateFolderAsync(folder_id);
    }

  }
}

redpajama_set_name: RedPajamaGithub


text:
//
// Diese Datei wurde mit der JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802 generiert
// Siehe http://java.sun.com/xml/jaxb
// Änderungen an dieser Datei gehen bei einer Neukompilierung des Quellschemas verloren.
// Generiert: 2016.07.29 um 11:26:52 AM CEST
//

package org.osgi.xmlns.scr.v1_1;

import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java-Klasse für Tjava-types.
 *
 *
Das folgende Schemafragment gibt den erwarteten Content an, der in dieser Klasse enthalten ist.
 *

 *

 * <simpleType name="Tjava-types">
 *   <restriction base="{http://www.w3.org/2001/XMLSchema}string">
 *     <enumeration value="String"/>
 *     <enumeration value="Long"/>
 *     <enumeration value="Double"/>
 *     <enumeration value="Float"/>
 *     <enumeration value="Integer"/>
 *     <enumeration value="Byte"/>
 *     <enumeration value="Character"/>
 *     <enumeration value="Boolean"/>
 *     <enumeration value="Short"/>
 *   </restriction>
 * </simpleType>
 *

 *
 */
@XmlType(name = "Tjava-types")
@XmlEnum
public enum TjavaTypes {

    @XmlEnumValue("String")
    STRING("String"),
    @XmlEnumValue("Long")
    LONG("Long"),
    @XmlEnumValue("Double")
    DOUBLE("Double"),
    @XmlEnumValue("Float")
    FLOAT("Float"),
    @XmlEnumValue("Integer")
    INTEGER("Integer"),
    @XmlEnumValue("Byte")
    BYTE("Byte"),
    @XmlEnumValue("Character")
    CHARACTER("Character"),
    @XmlEnumValue("Boolean")
    BOOLEAN("Boolean"),
    @XmlEnumValue("Short")
    SHORT("Short");
    private final String value;

    TjavaTypes(String v) {
        value = v;
    }

    public String value() {
        return value;
    }

    public static TjavaTypes fromValue(String v) {
        for (TjavaTypes c: TjavaTypes.values()) {
            if (c.value.equals(v)) {
                return c;
            }
        }
        throw new IllegalArgumentException(v);
    }

}


text:
const assert = require('assert-plus');
const date = require('../../date');
const RegistrationEnum = require('../../enum/registrationEnum').RegistrationEnum;
const mapHelper = require('./../../mapHelper');

const REGISTRATION_STATUS_MAP_FIELD = 'registration.status';
const REGISTRATION_FIRST_DATE_MAP_FIELD = 'registration.firstDate';

const resolve = function resolve(map, options) {
  assert.object(map, 'map');
  assert.object(options, 'options');

  const status = mapHelper.getMapValue(map, REGISTRATION_STATUS_MAP_FIELD);
  let firstAt = mapHelper.getMapValue(map, REGISTRATION_FIRST_DATE_MAP_FIELD);

  if (!firstAt) {
    firstAt = null;
  }

  const registrationStatuses = options.get('resolver.variant.registrationStatus');
  const registrationStatus = RegistrationEnum.Status.getStatus(status, registrationStatuses);

  mapHelper.updateMapValue(map, REGISTRATION_STATUS_MAP_FIELD, registrationStatus);
  mapHelper.updateMapValue(map, REGISTRATION_FIRST_DATE_MAP_FIELD, date.parseIsoString(firstAt));
};

module.exports = {
  resolve: resolve,
  REGISTRATION_STATUS_MAP_FIELD: REGISTRATION_STATUS_MAP_FIELD,
  REGISTRATION_FIRST_DATE_MAP_FIELD: REGISTRATION_FIRST_DATE_MAP_FIELD
};


text:
//
//  BNCPreferenceHelper.m
//  Branch-SDK
//
//  Created by Alex Austin on 6/6/14.
//  Copyright (c) 2014 Branch Metrics. All rights reserved.
//

#import "BNCPreferenceHelper.h"
#import "BNCEncodingUtils.h"
#import "BNCConfig.h"
#import "Branch.h"
#import "BNCLog.h"
#import "BranchConstants.h"
#import "NSString+Branch.h"

static const NSTimeInterval DEFAULT_TIMEOUT = 5.5;
static const NSTimeInterval DEFAULT_RETRY_INTERVAL = 0;
static const NSInteger DEFAULT_RETRY_COUNT = 3;

static NSString * const BRANCH_PREFS_FILE = @"BNCPreferences";

static NSString * const BRANCH_PREFS_KEY_APP_VERSION = @"bnc_app_version";
static NSString * const BRANCH_PREFS_KEY_LAST_RUN_BRANCH_KEY = @"bnc_last_run_branch_key";
static NSString * const BRANCH_PREFS_KEY_LAST_STRONG_MATCH_DATE = @"bnc_strong_match_created_date";
static NSString * const BRANCH_PREFS_KEY_DEVICE_FINGERPRINT_ID = @"bnc_device_fingerprint_id";
static NSString * const BRANCH_PREFS_KEY_SESSION_ID = @"bnc_session_id";
static NSString * const BRANCH_PREFS_KEY_IDENTITY_ID = @"bnc_identity_id";
static NSString * const BRANCH_PREFS_KEY_IDENTITY = @"bnc_identity";
static NSString * const BRANCH_PREFS_KEY_CHECKED_FACEBOOK_APP_LINKS = @"bnc_checked_fb_app_links";
static NSString * const BRANCH_PREFS_KEY_CHECKED_APPLE_SEARCH_ADS = @"bnc_checked_apple_search_ads";
static NSString * const BRANCH_PREFS_KEY_APPLE_SEARCH_ADS_INFO = @"bnc_apple_search_ads_info";
static NSString * const BRANCH_PREFS_KEY_LINK_CLICK_IDENTIFIER = @"bnc_link_click_identifier";
static NSString * const BRANCH_PREFS_KEY_SPOTLIGHT_IDENTIFIER = @"bnc_spotlight_identifier";
static NSString * const BRANCH_PREFS_KEY_UNIVERSAL_LINK_URL = @"bnc_universal_link_url";
static NSString * const BRANCH_PREFS_KEY_SESSION_PARAMS = @"bnc_session_params";
static NSString * const BRANCH_PREFS_KEY_INSTALL_PARAMS = @"bnc_install_params";
static NSString * const BRANCH_PREFS_KEY_USER_URL = @"bnc_user_url";
static NSString * const BRANCH_PREFS_KEY_BRANCH_UNIVERSAL_LINK_DOMAINS = @"branch_universal_link_domains";

static NSString * const BRANCH_PREFS_KEY_CREDITS = @"bnc_credits";
static NSString * const BRANCH_PREFS_KEY_CREDIT_BASE = @"bnc_credit_base_";

static NSString * const BRANCH_PREFS_KEY_BRANCH_VIEW_USAGE_CNT = @"bnc_branch_view_usage_cnt_";
static NSString * const BRANCH_PREFS_KEY_ANALYTICAL_DATA = @"bnc_branch_analytical_data";
static NSString * const BRANCH_PREFS_KEY_ANALYTICS_MANIFEST = @"bnc_branch_analytics_manifest";

@interface BNCPreferenceHelper () {
    NSOperationQueue *_persistPrefsQueue;
    NSString         *_lastSystemBuildVersion;
    NSString         *_browserUserAgentString;
    NSString         *_branchAPIURL;
    NSString         *_referringURL;
}

@property (strong, nonatomic) NSMutableDictionary *persistenceDict;
@property (strong, nonatomic) NSMutableDictionary *creditsDictionary;
@property (strong, nonatomic) NSMutableDictionary *requestMetadataDictionary;
@property (strong, nonatomic) NSMutableDictionary *instrumentationDictionary;
@end

@implementation BNCPreferenceHelper

@synthesize
            lastRunBranchKey = _lastRunBranchKey,
            appVersion = _appVersion,
            deviceFingerprintID = _deviceFingerprintID,
            sessionID = _sessionID,
            spotlightIdentifier = _spotlightIdentifier,
            identityID = _identityID,
            linkClickIdentifier = _linkClickIdentifier,
            userUrl = _userUrl,
            userIdentity = _userIdentity,
            sessionParams = _sessionParams,
            installParams = _installParams,
            universalLinkUrl = _universalLinkUrl,
            externalIntentURI = _externalIntentURI,
            isDebug = _isDebug,
            retryCount = _retryCount,
            retryInterval = _retryInterval,
            timeout = _timeout,
            lastStrongMatchDate = _lastStrongMatchDate,
            checkedFacebookAppLinks = _checkedFacebookAppLinks,
            checkedAppleSearchAdAttribution = _checkedAppleSearchAdAttribution,
            appleSearchAdDetails = _appleSearchAdDetails,
            requestMetadataDictionary = _requestMetadataDictionary,
            instrumentationDictionary = _instrumentationDictionary;

+ (BNCPreferenceHelper *)preferenceHelper {
    static BNCPreferenceHelper *preferenceHelper;
    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{
        preferenceHelper = [[BNCPreferenceHelper alloc] init];
    });

    return preferenceHelper;
}

- (id)init {
    self = [super init];
    if (!self) return self;

    _timeout = DEFAULT_TIMEOUT;
    _retryCount = DEFAULT_RETRY_COUNT;
    _retryInterval = DEFAULT_RETRY_INTERVAL;
    _isDebug = NO;
    _persistPrefsQueue = [[NSOperationQueue alloc] init];
    _persistPrefsQueue.maxConcurrentOperationCount = 1;

    self.branchBlacklistURL = @"https://cdn.branch.io";

    return self;
}

+ (BNCPreferenceHelper *)getInstance {
    static BNCPreferenceHelper *preferenceHelper;
    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{
        preferenceHelper = [[BNCPreferenceHelper alloc] init];
    });

    return preferenceHelper;
}

- (void) synchronize {
    [_persistPrefsQueue waitUntilAllOperationsAreFinished];
}

- (void) dealloc {
    [self synchronize];
}

#pragma mark - API methods

- (void) setBranchAPIURL:(NSString*)branchAPIURL_ {
    @synchronized (self) {
        _branchAPIURL = [branchAPIURL_ copy];
    }
}

- (NSString*) branchAPIURL {
    @synchronized (self) {
        if (!_branchAPIURL) {
            _branchAPIURL = [BNC_API_BASE_URL copy];
        }
        return _branchAPIURL;
    }
}

- (NSString *)getAPIBaseURL {
    @synchronized (self) {
        return [NSString stringWithFormat:@"%@/%@/", self.branchAPIURL, BNC_API_VERSION];
    }
}

- (NSString *)getAPIURL:(NSString *) endpoint {
    return [[self getAPIBaseURL] stringByAppendingString:endpoint];
}

- (NSString *)getEndpointFromURL:(NSString *)url {
    NSString *APIBase = self.branchAPIURL;
    if ([url hasPrefix:APIBase]) {
        NSUInteger index = APIBase.length;
        return [url substringFromIndex:index];
    }
    return @"";
}

#pragma mark - Preference Storage

- (NSString *)lastRunBranchKey {
    if (!_lastRunBranchKey) {
        _lastRunBranchKey = [self readStringFromDefaults:BRANCH_PREFS_KEY_LAST_RUN_BRANCH_KEY];
    }
    return _lastRunBranchKey;
}

- (void)setLastRunBranchKey:(NSString *)lastRunBranchKey {
    if (![_lastRunBranchKey isEqualToString:lastRunBranchKey]) {
        _lastRunBranchKey = lastRunBranchKey;
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_LAST_RUN_BRANCH_KEY value:lastRunBranchKey];
    }
}

- (NSDate *)lastStrongMatchDate {
    if (!_lastStrongMatchDate) {
        _lastStrongMatchDate = (NSDate *)[self readObjectFromDefaults:BRANCH_PREFS_KEY_LAST_STRONG_MATCH_DATE];
    }
    return _lastStrongMatchDate;
}

- (void)setLastStrongMatchDate:(NSDate *)lastStrongMatchDate {
    if (lastStrongMatchDate == nil || ![_lastStrongMatchDate isEqualToDate:lastStrongMatchDate]) {
        _lastStrongMatchDate = lastStrongMatchDate;
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_LAST_STRONG_MATCH_DATE value:lastStrongMatchDate];
    }
}

- (NSString *)appVersion {
    if (!_appVersion) {
        _appVersion = [self readStringFromDefaults:BRANCH_PREFS_KEY_APP_VERSION];
    }
    return _appVersion;
}

- (void)setAppVersion:(NSString *)appVersion {
    if (![_appVersion isEqualToString:appVersion]) {
        _appVersion = appVersion;
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_APP_VERSION value:appVersion];
    }
}

- (NSString *)deviceFingerprintID {
    if (!_deviceFingerprintID) {
        _deviceFingerprintID = [self readStringFromDefaults:BRANCH_PREFS_KEY_DEVICE_FINGERPRINT_ID];
    }

    return _deviceFingerprintID;
}

- (void)setDeviceFingerprintID:(NSString *)deviceFingerprintID {
    if (deviceFingerprintID == nil || ![_deviceFingerprintID isEqualToString:deviceFingerprintID]) {
        _deviceFingerprintID = deviceFingerprintID;
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_DEVICE_FINGERPRINT_ID value:deviceFingerprintID];
    }
}

- (NSString *)sessionID {
    if (!_sessionID) {
        _sessionID = [self readStringFromDefaults:BRANCH_PREFS_KEY_SESSION_ID];
    }

    return _sessionID;
}

- (void)setSessionID:(NSString *)sessionID {
    if (sessionID == nil || ![_sessionID isEqualToString:sessionID]) {
        _sessionID = sessionID;
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_SESSION_ID value:sessionID];
    }
}

- (NSString *)identityID {
    return [self readStringFromDefaults:BRANCH_PREFS_KEY_IDENTITY_ID];
}

- (void)setIdentityID:(NSString *)identityID {
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_IDENTITY_ID value:identityID];
}

- (NSString *)userIdentity {
    return [self readStringFromDefaults:BRANCH_PREFS_KEY_IDENTITY];
}

- (void)setUserIdentity:(NSString *)userIdentity {
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_IDENTITY value:userIdentity];
}

- (NSString *)linkClickIdentifier {
    return [self readStringFromDefaults:BRANCH_PREFS_KEY_LINK_CLICK_IDENTIFIER];
}

- (void)setLinkClickIdentifier:(NSString *)linkClickIdentifier {
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_LINK_CLICK_IDENTIFIER value:linkClickIdentifier];
}

- (NSString *)spotlightIdentifier {
    return [self readStringFromDefaults:BRANCH_PREFS_KEY_SPOTLIGHT_IDENTIFIER];
}

- (void)setSpotlightIdentifier:(NSString *)spotlightIdentifier {
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_SPOTLIGHT_IDENTIFIER value:spotlightIdentifier];
}

- (NSString *)externalIntentURI {
    @synchronized(self) {
        if (!_externalIntentURI) {
            _externalIntentURI = [self readStringFromDefaults:BRANCH_REQUEST_KEY_EXTERNAL_INTENT_URI];
        }
        return _externalIntentURI;
    }
}

- (void)setExternalIntentURI:(NSString *)externalIntentURI {
    @synchronized(self) {
        if (externalIntentURI == nil || ![_externalIntentURI isEqualToString:externalIntentURI]) {
            _externalIntentURI = externalIntentURI;
            [self writeObjectToDefaults:BRANCH_REQUEST_KEY_EXTERNAL_INTENT_URI value:externalIntentURI];
        }
    }
}

- (NSString*) referringURL {
    @synchronized (self) {
        if (!_referringURL) _referringURL = [self readStringFromDefaults:@"referringURL"];
        return _referringURL;
    }
}

- (void) setReferringURL:(NSString *)referringURL {
    @synchronized (self) {
        _referringURL = [referringURL copy];
        [self writeObjectToDefaults:@"referringURL" value:_referringURL];
    }
}

- (NSString *)universalLinkUrl {
    return [self readStringFromDefaults:BRANCH_PREFS_KEY_UNIVERSAL_LINK_URL];
}

- (void)setUniversalLinkUrl:(NSString *)universalLinkUrl {
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_UNIVERSAL_LINK_URL value:universalLinkUrl];
}

- (NSString *)sessionParams {
    @synchronized (self) {
        if (!_sessionParams) {
            _sessionParams = [self readStringFromDefaults:BRANCH_PREFS_KEY_SESSION_PARAMS];
        }
        return _sessionParams;
    }
}

- (void)setSessionParams:(NSString *)sessionParams {
    @synchronized (self) {
        if (sessionParams == nil || ![_sessionParams isEqualToString:sessionParams]) {
            _sessionParams = sessionParams;
            [self writeObjectToDefaults:BRANCH_PREFS_KEY_SESSION_PARAMS value:sessionParams];
        }
    }
}

- (NSString *)installParams {
    @synchronized(self) {
        if (!_installParams) {
            id installParamsFromCache = [self readStringFromDefaults:BRANCH_PREFS_KEY_INSTALL_PARAMS];
            if ([installParamsFromCache isKindOfClass:[NSString class]]) {
                _installParams = [self readStringFromDefaults:BRANCH_PREFS_KEY_INSTALL_PARAMS];
            }
            else if ([installParamsFromCache isKindOfClass:[NSDictionary class]]) {
                [self writeObjectToDefaults:BRANCH_PREFS_KEY_INSTALL_PARAMS value:nil];
            }
        }
        return _installParams;
    }
}

- (void)setInstallParams:(NSString *)installParams {
    @synchronized(self) {
        if ([installParams isKindOfClass:[NSDictionary class]]) {
            _installParams = [BNCEncodingUtils encodeDictionaryToJsonString:(NSDictionary *)installParams];
            [self writeObjectToDefaults:BRANCH_PREFS_KEY_INSTALL_PARAMS value:_installParams];
            return;
        }
        if (installParams == nil || ![_installParams isEqualToString:installParams]) {
            _installParams = installParams;
            [self writeObjectToDefaults:BRANCH_PREFS_KEY_INSTALL_PARAMS value:installParams];
        }
    }
}

- (void) setAppleSearchAdDetails:(NSDictionary*)details {
    if (details == nil || [details isKindOfClass:[NSDictionary class]]) {
        _appleSearchAdDetails = details;
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_APPLE_SEARCH_ADS_INFO value:details];
    }
}

- (NSDictionary*) appleSearchAdDetails {
    if (!_appleSearchAdDetails) {
        _appleSearchAdDetails = (NSDictionary *) [self readObjectFromDefaults:BRANCH_PREFS_KEY_APPLE_SEARCH_ADS_INFO];
    }
    return [_appleSearchAdDetails isKindOfClass:[NSDictionary class]] ? _appleSearchAdDetails : nil;
}

- (void) setAppleSearchAdNeedsSend:(BOOL)appleSearchAdNeedsSend {
    [self writeBoolToDefaults:@"_appleSearchAdNeedsSend" value:appleSearchAdNeedsSend];
}

- (BOOL) appleSearchAdNeedsSend {
    return [self readBoolFromDefaults:@"_appleSearchAdNeedsSend"];
}

- (NSString*) lastSystemBuildVersion {
    if (!_lastSystemBuildVersion) {
        _lastSystemBuildVersion = [self readStringFromDefaults:@"_lastSystemBuildVersion"];
    }
    return _lastSystemBuildVersion;
}

- (void) setLastSystemBuildVersion:(NSString *)lastSystemBuildVersion {
    if (![_lastSystemBuildVersion isEqualToString:lastSystemBuildVersion]) {
        _lastSystemBuildVersion = lastSystemBuildVersion;
        [self writeObjectToDefaults:@"_lastSystemBuildVersion" value:_lastSystemBuildVersion];
    }
}

- (NSString*) browserUserAgentString {
    if (!_browserUserAgentString) {
        _browserUserAgentString = [self readStringFromDefaults:@"_browserUserAgentString"];
    }
    return _browserUserAgentString;
}

- (void) setBrowserUserAgentString:(NSString *)browserUserAgentString {
    if (![_browserUserAgentString isEqualToString:browserUserAgentString]) {
        _browserUserAgentString = browserUserAgentString;
        [self writeObjectToDefaults:@"_browserUserAgentString" value:_browserUserAgentString];
    }
}

- (NSString *)userUrl {
    if (!_userUrl) {
        _userUrl = [self readStringFromDefaults:BRANCH_PREFS_KEY_USER_URL];
    }

    return _userUrl;
}

- (void)setUserUrl:(NSString *)userUrl {
    if (![_userUrl isEqualToString:userUrl]) {
        _userUrl = userUrl;
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_USER_URL value:userUrl];
    }
}

- (NSMutableString*) sanitizedMutableBaseURL:(NSString*)baseUrl_ {
    NSMutableString *baseUrl = [baseUrl_ mutableCopy];
    if (self.trackingDisabled) {
        NSString *id_string = [NSString stringWithFormat:@"%%24identity_id=%@", self.identityID];
        NSRange range = [baseUrl rangeOfString:id_string];
        if (range.location != NSNotFound) [baseUrl replaceCharactersInRange:range withString:@""];
    } else
    if ([baseUrl hasSuffix:@"&"] || [baseUrl hasSuffix:@"?"]) {
    } else
    if ([baseUrl bnc_containsString:@"?"]) {
        [baseUrl appendString:@"&"];
    }
    else {
        [baseUrl appendString:@"?"];
    }
    return baseUrl;
}

- (BOOL)checkedAppleSearchAdAttribution {
    _checkedAppleSearchAdAttribution = [self readBoolFromDefaults:BRANCH_PREFS_KEY_CHECKED_APPLE_SEARCH_ADS];
    return _checkedAppleSearchAdAttribution;
}

- (void)setCheckedAppleSearchAdAttribution:(BOOL)checked {
    _checkedAppleSearchAdAttribution = checked;
    [self writeBoolToDefaults:BRANCH_PREFS_KEY_CHECKED_APPLE_SEARCH_ADS value:checked];
}

- (BOOL)checkedFacebookAppLinks {
    _checkedFacebookAppLinks = [self readBoolFromDefaults:BRANCH_PREFS_KEY_CHECKED_FACEBOOK_APP_LINKS];
    return _checkedFacebookAppLinks;
}

- (void)setCheckedFacebookAppLinks:(BOOL)checked {
    _checkedFacebookAppLinks = checked;
    [self writeBoolToDefaults:BRANCH_PREFS_KEY_CHECKED_FACEBOOK_APP_LINKS value:checked];
}

- (void)clearUserCreditsAndCounts {
    self.creditsDictionary = [[NSMutableDictionary alloc] init];
}

- (id)getBranchUniversalLinkDomains {
    return [[[NSBundle mainBundle] infoDictionary] objectForKey:BRANCH_PREFS_KEY_BRANCH_UNIVERSAL_LINK_DOMAINS];
}

- (NSMutableDictionary *)requestMetadataDictionary {
    if (!_requestMetadataDictionary) {
        _requestMetadataDictionary = [NSMutableDictionary dictionary];
    }
    return _requestMetadataDictionary;
}

- (void)setRequestMetadataKey:(NSString *)key value:(NSObject *)value {
    if (!key) {
        return;
    }
    if ([self.requestMetadataDictionary objectForKey:key] && !value) {
        [self.requestMetadataDictionary removeObjectForKey:key];
    }
    else if (value) {
        [self.requestMetadataDictionary setObject:value forKey:key];
    }
}

- (NSMutableDictionary *)instrumentationDictionary {
    @synchronized (self) {
        if (!_instrumentationDictionary) {
            _instrumentationDictionary = [NSMutableDictionary dictionary];
        }
        return _instrumentationDictionary;
    }
}

- (void)addInstrumentationDictionaryKey:(NSString *)key value:(NSString *)value {
    @synchronized (self) {
        if (key && value) {
            [self.instrumentationDictionary setObject:value forKey:key];
        }
    }
}

- (void)clearInstrumentationDictionary {
    @synchronized (self) {
        [_instrumentationDictionary removeAllObjects];
    }
}

- (BOOL) limitFacebookTracking {
    @synchronized (self) {
        return [self readBoolFromDefaults:@"_limitFacebookTracking"];
    }
}

- (void) setLimitFacebookTracking:(BOOL)limitFacebookTracking {
    @synchronized (self) {
        [self writeBoolToDefaults:@"_limitFacebookTracking" value:limitFacebookTracking];
    }
}

- (NSDate*) previousAppBuildDate {
    @synchronized (self) {
        NSDate *date = (NSDate*) [self readObjectFromDefaults:@"_previousAppBuildDate"];
        if ([date isKindOfClass:[NSDate class]]) return date;
        return nil;
    }
}

- (void) setPreviousAppBuildDate:(NSDate*)date {
    @synchronized (self) {
        if (date == nil || [date isKindOfClass:[NSDate class]])
            [self writeObjectToDefaults:@"_previousAppBuildDate" value:date];
    }
}

- (NSArray<NSString*>*) URLBlackList {
    @synchronized(self) {
        id a = [self readObjectFromDefaults:@"URLBlackList"];
        if ([a isKindOfClass:NSArray.class]) return a;
        return nil;
    }
}

- (void) setURLBlackList:(NSArray<NSString *> *)URLBlackList {
    @synchronized(self) {
        [self writeObjectToDefaults:@"URLBlackList" value:URLBlackList];
    }
}

- (NSInteger) URLBlackListVersion {
    @synchronized(self) {
        return [self readIntegerFromDefaults:@"URLBlackListVersion"];
    }
}

- (void) setURLBlackListVersion:(NSInteger)URLBlackListVersion {
    @synchronized(self) {
        [self writeIntegerToDefaults:@"URLBlackListVersion" value:URLBlackListVersion];
    }
}

- (BOOL) blacklistURLOpen {
    @synchronized(self) {
        return [self readBoolFromDefaults:@"blacklistURLOpen"];
    }
}

- (void) setBlacklistURLOpen:(BOOL)value {
    @synchronized(self) {
        [self writeBoolToDefaults:@"blacklistURLOpen" value:value];
    }
}

- (BOOL) trackingDisabled {
    @synchronized(self) {
        NSNumber *b = (id) [self readObjectFromDefaults:@"trackingDisabled"];
        if ([b isKindOfClass:NSNumber.class]) return [b boolValue];
        return false;
    }
}

- (void) setTrackingDisabled:(BOOL)disabled {
    @synchronized(self) {
        NSNumber *b = [NSNumber numberWithBool:disabled];
        [self writeObjectToDefaults:@"trackingDisabled" value:b];
        if (disabled) [self clearTrackingInformation];
    }
}

- (void) clearTrackingInformation {
    @synchronized(self) {
        /* Don't clear these:
        self.deviceFingerprintID = nil;
        self.userIdentity = nil;
        self.identityID = nil;
        */
        self.sessionID = nil;
        self.linkClickIdentifier = nil;
        self.spotlightIdentifier = nil;
        self.referringURL = nil;
        self.universalLinkUrl = nil;
        self.installParams = nil;
        self.appleSearchAdDetails = nil;
        self.appleSearchAdNeedsSend = NO;
        self.sessionParams = nil;
        self.externalIntentURI = nil;
        self.savedAnalyticsData = nil;
        self.previousAppBuildDate = nil;
        self.requestMetadataDictionary = nil;
        self.lastStrongMatchDate = nil;
    }
}

#pragma mark - Credit Storage

- (NSMutableDictionary *)creditsDictionary {
    if (!_creditsDictionary) {
        _creditsDictionary = [[self readObjectFromDefaults:BRANCH_PREFS_KEY_CREDITS] mutableCopy];

        if (!_creditsDictionary) {
            _creditsDictionary = [[NSMutableDictionary alloc] init];
        }
    }

    return _creditsDictionary;
}

- (void)setCreditCount:(NSInteger)count {
    [self setCreditCount:count forBucket:@"default"];
}

- (void)setCreditCount:(NSInteger)count forBucket:(NSString *)bucket {
    self.creditsDictionary[[BRANCH_PREFS_KEY_CREDIT_BASE stringByAppendingString:bucket]] = @(count);

    [self writeObjectToDefaults:BRANCH_PREFS_KEY_CREDITS value:self.creditsDictionary];
}

- (void)removeCreditCountForBucket:(NSString *)bucket {
    NSMutableDictionary *dictToWrite = self.creditsDictionary;
    [dictToWrite removeObjectForKey:[BRANCH_PREFS_KEY_CREDIT_BASE stringByAppendingString:bucket]];

    [self writeObjectToDefaults:BRANCH_PREFS_KEY_CREDITS value:self.creditsDictionary];
}

- (NSDictionary *)getCreditDictionary {
    NSMutableDictionary *returnDictionary = [[NSMutableDictionary alloc] init];
    for(NSString *key in self.creditsDictionary) {
        NSString *cleanKey = [key stringByReplacingOccurrencesOfString:BRANCH_PREFS_KEY_CREDIT_BASE
                                                                                withString:@""];
        returnDictionary[cleanKey] = self.creditsDictionary[key];
    }
    return returnDictionary;
}

- (NSInteger)getCreditCount {
    return [self getCreditCountForBucket:@"default"];
}

- (NSInteger)getCreditCountForBucket:(NSString *)bucket {
    return [self.creditsDictionary[[BRANCH_PREFS_KEY_CREDIT_BASE stringByAppendingString:bucket]] integerValue];
}

- (void)clearUserCredits {
    self.creditsDictionary = [[NSMutableDictionary alloc] init];
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_CREDITS value:self.creditsDictionary];
}

#pragma mark - Count Storage

- (void)saveBranchAnalyticsData:(NSDictionary *)analyticsData {
    if (_sessionID) {
        if (!_savedAnalyticsData) {
            _savedAnalyticsData = [self getBranchAnalyticsData];
        }
        NSMutableArray *viewDataArray = [_savedAnalyticsData objectForKey:_sessionID];
        if (!viewDataArray) {
            viewDataArray = [[NSMutableArray alloc] init];
            [_savedAnalyticsData setObject:viewDataArray forKey:_sessionID];
        }
        [viewDataArray addObject:analyticsData];
        [self writeObjectToDefaults:BRANCH_PREFS_KEY_ANALYTICAL_DATA value:_savedAnalyticsData];
    }
}

- (void)clearBranchAnalyticsData {
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_ANALYTICAL_DATA value:nil];
    _savedAnalyticsData = nil;
}

- (NSMutableDictionary *)getBranchAnalyticsData {
    NSMutableDictionary *analyticsDataObj = _savedAnalyticsData;
    if (!analyticsDataObj) {
        analyticsDataObj = (NSMutableDictionary *)[self readObjectFromDefaults:BRANCH_PREFS_KEY_ANALYTICAL_DATA];
        if (!analyticsDataObj) {
            analyticsDataObj = [[NSMutableDictionary alloc] init];
        }
    }
    return analyticsDataObj;
}

- (void)saveContentAnalyticsManifest:(NSDictionary *)cdManifest {
    [self writeObjectToDefaults:BRANCH_PREFS_KEY_ANALYTICS_MANIFEST value:cdManifest];
}

- (NSDictionary *)getContentAnalyticsManifest {
    return (NSDictionary *)[self readObjectFromDefaults:BRANCH_PREFS_KEY_ANALYTICS_MANIFEST];
}

#pragma mark - Writing To Persistence

- (void)writeIntegerToDefaults:(NSString *)key value:(NSInteger)value {
    [self writeObjectToDefaults:key value:@(value)];
}

- (void)writeBoolToDefaults:(NSString *)key value:(BOOL)value {
    [self writeObjectToDefaults:key value:@(value)];
}

- (void)writeObjectToDefaults:(NSString *)key value:(NSObject *)value {
    @synchronized (self) {
        if (value) {
            self.persistenceDict[key] = value;
        }
        else {
            [self.persistenceDict removeObjectForKey:key];
        }
        [self persistPrefsToDisk];
    }
}

- (void)persistPrefsToDisk {
    @synchronized (self) {
        if (!self.persistenceDict) return;
        NSData *data = nil;
        @try {
            data = [NSKeyedArchiver archivedDataWithRootObject:self.persistenceDict];
        }
        @catch (id exception) {
            data = nil;
            BNCLogWarning(@"Exception creating preferences data: %@.", exception);
        }
        if (!data) {
            BNCLogWarning(@"Can't create preferences data.");
            return;
        }
        NSURL *prefsURL = [self.class.URLForPrefsFile copy];
        NSBlockOperation *newPersistOp = [NSBlockOperation blockOperationWithBlock:^ {
            NSError *error = nil;
            [data writeToURL:prefsURL options:NSDataWritingAtomic error:&error];
            if (error) {
                BNCLogWarning(@"Failed to persist preferences: %@.", error);
            }
        }];
        [_persistPrefsQueue addOperation:newPersistOp];
    }
}

+ (void) clearAll {
    NSURL *prefsURL = [self.URLForPrefsFile copy];
    if (prefsURL) [[NSFileManager defaultManager] removeItemAtURL:prefsURL error:nil];
}

#pragma mark - Reading From Persistence

- (NSMutableDictionary *)persistenceDict {
    @synchronized(self) {
        if (!_persistenceDict) {
            NSDictionary *persistenceDict = nil;
            @try {
                NSError *error = nil;
                NSData *data = [NSData dataWithContentsOfURL:self.class.URLForPrefsFile
                    options:0 error:&error];
                if (!error && data)
                    persistenceDict = [NSKeyedUnarchiver unarchiveObjectWithData:data];
            }
            @catch (NSException*) {
                BNCLogWarning(@"Failed to load preferences from storage.");
            }

            if ([persistenceDict isKindOfClass:[NSDictionary class]])
                _persistenceDict = [persistenceDict mutableCopy];
            else
                _persistenceDict = [[NSMutableDictionary alloc] init];
        }
        return _persistenceDict;
    }
}

- (NSObject *)readObjectFromDefaults:(NSString *)key {
    @synchronized(self) {
        NSObject *obj = self.persistenceDict[key];
        return obj;
    }
}

- (NSString *)readStringFromDefaults:(NSString *)key {
    @synchronized(self) {
        id str = self.persistenceDict[key];
        if ([str isKindOfClass:[NSNumber class]]) {
            str = [str stringValue];
        }
        return str;
    }
}

- (BOOL)readBoolFromDefaults:(NSString *)key {
    @synchronized(self) {
        BOOL boo = [self.persistenceDict[key] boolValue];
        return boo;
    }
}

- (NSInteger)readIntegerFromDefaults:(NSString *)key {
    @synchronized(self) {
        NSNumber *number = self.persistenceDict[key];
        if (number != nil) {
            return [number integerValue];
        }
        return NSNotFound;
    }
}

#pragma mark - Preferences File URL

+ (NSString *)prefsFile_deprecated {
    NSString * path =
        [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)
            firstObject]
                stringByAppendingPathComponent:BRANCH_PREFS_FILE];
    return path;
}

+ (NSURL* _Nonnull) URLForPrefsFile {
    NSURL *URL = BNCURLForBranchDirectory();
    URL = [URL URLByAppendingPathComponent:BRANCH_PREFS_FILE isDirectory:NO];
    return URL;
}

+ (void) moveOldPrefsFile {
    NSString* oldPath = self.prefsFile_deprecated;
    NSURL *oldURL = (oldPath) ? [NSURL fileURLWithPath:self.prefsFile_deprecated] : nil;
    NSURL *newURL = [self URLForPrefsFile];

    if (!oldURL || !newURL) { return; }

    NSError *error = nil;
    [[NSFileManager defaultManager]
        moveItemAtURL:oldURL
        toURL:newURL
        error:&error];

    if (error && error.code != NSFileNoSuchFileError) {
        if (error.code == NSFileWriteFileExistsError) {
            [[NSFileManager defaultManager]
                removeItemAtURL:oldURL
                error:&error];
        } else {
            BNCLogError(@"Can't move prefs file: %@.", error);
        }
    }
}

+ (void) initialize {
    if (self == [BNCPreferenceHelper self]) {
        [self moveOldPrefsFile];
    }
}

@end

#pragma mark - BNCURLForBranchDirectory

NSURL* _Null_unspecified BNCCreateDirectoryForBranchURLWithSearchPath_Unthreaded(NSSearchPathDirectory directory) {
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSArray *URLs = [fileManager URLsForDirectory:directory inDomains:NSUserDomainMask | NSLocalDomainMask];

    for (NSURL *URL in URLs) {
        NSError *error = nil;
        NSURL *branchURL = [[NSURL alloc] initWithString:@"io.branch" relativeToURL:URL];
        BOOL success =
            [fileManager
                createDirectoryAtURL:branchURL
                withIntermediateDirectories:YES
                attributes:nil
                error:&error];
        if (success) {
            return branchURL;
        } else  {
            NSLog(@"[branch.io] Info: CreateBranchURL failed: %@ URL: %@.", error, branchURL);
        }
    }
    return nil;
}

NSURL* _Nonnull BNCURLForBranchDirectory_Unthreaded() {
    NSArray *kSearchDirectories = @[
        @(NSApplicationSupportDirectory),
        @(NSLibraryDirectory),
        @(NSCachesDirectory),
        @(NSDocumentDirectory),
    ];

    for (NSNumber *directory in kSearchDirectories) {
        NSSearchPathDirectory directoryValue = [directory unsignedLongValue];
        NSURL *URL = BNCCreateDirectoryForBranchURLWithSearchPath_Unthreaded(directoryValue);
        if (URL) return URL;
    }

    //  Worst case backup plan:
    NSString *path = [@"~/Library/io.branch" stringByExpandingTildeInPath];
    NSURL *branchURL = [NSURL fileURLWithPath:path isDirectory:YES];
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSError *error = nil;
    BOOL success =
        [fileManager
            createDirectoryAtURL:branchURL
            withIntermediateDirectories:YES
            attributes:nil
            error:&error];
    if (!success) {
        NSLog(@"[io.branch] Error: Worst case CreateBranchURL error was: %@ URL: %@.", error, branchURL);
    }
    return branchURL;
}

NSURL* _Nonnull BNCURLForBranchDirectory() {
    static NSURL *urlForBranchDirectory = nil;
    static dispatch_once_t onceToken = 0;
    dispatch_once(&onceToken, ^ {
        urlForBranchDirectory = BNCURLForBranchDirectory_Unthreaded();
    });
    return urlForBranchDirectory;
}


text:
import { Component, OnInit, OnDestroy, ViewContainerRef } from '@angular/core';
import { ActivatedRoute } from '@angular/router';
import { PollsService } from '../../core/polls.service';
import { AuthService } from '../../core/auth.service';
import { ToastsManager } from 'ng2-toastr/ng2-toastr';

@Component({
  selector: 'app-polls',
  templateUrl: './pollsList.component.html',
  styleUrls: ['./pollsList.component.scss']
})
export class PollsListComponent implements OnInit, OnDestroy {

  userId;
  pollList;
  subscription;

  constructor(private route: ActivatedRoute,
              private polls: PollsService,
              private toastr: ToastsManager,
              private auth: AuthService,
              private vcr: ViewContainerRef) {
    this.toastr.setRootViewContainerRef(vcr);
  }

  ngOnInit() {
    this.subscription = this.route.params.subscribe((params) => {
      this.userId = params['id'];
      this.polls.list().subscribe((polls) => {
        if (this.userId) {
          this.pollList = polls.filter(poll => {
            return poll.createdBy._id === this.userId;
          });
        } else {
          this.pollList = polls;
        }
      }, (error) => {
        this.toastr.error(error);
      });
    });
  }

  isLoggedIn() {
    return this.auth.isLoggedIn();
  }

  ngOnDestroy() {
    this.subscription.unsubscribe();
  }

}


text:
.form-primario,
.form-branco {
  display: block;
  width: 100%;
  padding: 12px 12px;
  font-size: 14px;
  line-height: 1.42857143;
  color: #999 !important;
  background-color: #f8f8f8;
  background-image: none;
  border: 1px solid transparent;
  border-radius: 0;
  -webkit-transition: all .3s;
  -moz-transition: all .3s;
  transition: all .3s;
}

.form-branco {
  color: #444;
  background-color: #FFF;
  font-size: 16px;
}

.form-primario:focus,
.form-branco:focus {
  outline: 0;
  border: 1px solid #f2f2f2;
}

textarea.form-primario,
textarea.form-branco {
  height: auto;
  resize: none;
}

.m-icon {
  display: inline-block;
  position: relative;
  font-size: 24px;
  vertical-align: middle;
}

.b-icon {
  display: inline-block;
  position: relative;
  font-size: 22px;
  vertical-align: middle;
  top: 0px;
}

/* BOTÃO BÁSICO */
.botao {
  font-size: 14px !important;
  display: inline-block !important;
  color: #444 !important;
  padding: 15px 38px !important;
  background-color: transparent !important;
  text-decoration: none !important;
  box-sizing: border-box !important;
  border: 0px !important;
  cursor: pointer !important;
  outline: 0 !important;
  margin: 2.5px !important;
  -webkit-transition: all .3s !important;
  -moz-transition: all .3s !important;
  transition: all .3s !important;
  vertical-align: middle !important;
  -webkit-touch-callout: none !important;
  -webkit-user-select: none !important;
  -khtml-user-select: none !important;
  -moz-user-select: none !important;
  -ms-user-select: none !important;
  user-select: none !important;
  border-radius: 0 !important;
}

.botao:hover {
  background-image: -webkit-linear-gradient(to bottom, rgba(0, 0, 0, .15) 0%, rgba(0, 0, 0, .15) 47%, rgba(0, 0, 0, .15) 100%);
  background-image: linear-gradient(to bottom, rgba(0, 0, 0, .15) 0%, rgba(0, 0, 0, .15) 47%, rgba(0, 0, 0, .15) 100%);
}

/* BOTAO-CORES */
.bt-default {
  color: #464646;
  background-color: #FFF;
  border: 1px solid #ccc;
}

.bt-primario {
  color: #fff !important;
  background-color: #414141;
}

.bt-sucesso {
  color: #fff;
  background-color: #009835;
}

.bt-erro {
  color: #fff;
  background-color: #CC0000;
}

.bt-info {
  color: #fff;
  background-color: #5bc0de;
}

.bt-alerta {
  color: #fff;
  background-color: #F28E00;
}

.bt-handson {
  color: #fff !important;
  background-color: #d40f50 !important;
}


text:
package annis.sqlgen;

import annis.service.objects.SaltURIGroupSet;
import annis.CommonHelper;
import annis.model.QueryNode;
import annis.ql.parser.QueryData;
import annis.service.objects.SaltURIGroup;
import java.net.URI;
import java.util.List;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.StringUtils;

import static annis.sqlgen.AbstractSqlGenerator.TABSTOP;
import static annis.sqlgen.TableAccessStrategy.CORPUS_TABLE;
import static annis.sqlgen.TableAccessStrategy.NODE_TABLE;

import static annis.sqlgen.SqlConstraints.sqlString;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Map;

/**
 * Generates a WITH clause sql statement for a list of salt ids.
 *
 * Salt ids are simple URI and are defined like this:
 *
 * <p>{@code salt:/corp1/corp2/doc1}</p>.
 *
 * The leading / of the URI is a must, // would cause an error, because
 * authorities are currently not supported.
 *
 * @author Benjamin Weißenfels <b.pixeldrama@gmail.com>
 * @author Thomas Krause <thomas.krause@alumni.hu-berlin.de>
 */
public class GraphWithClauseGenerator extends CommonAnnotateWithClauseGenerator
{
  private String singleMatchClause(int matchNumber, List<URI> saltURIs,
    TableAccessStrategy tas, AnnotateQueryData annotateQueryData,
    List<Long> corpusList, int numOfNodes,
    String indent)
  {
    String indent2 = indent + TABSTOP;
    StringBuilder sb = new StringBuilder();

    // SELECT
    sb.append(indent).append("SELECT\n");
    sb.append(indent2).append(matchNumber).append(" AS n, \n").append(indent2);

    for (int i = 1; i <= numOfNodes; i++)
    {
      // factsN.id AS idN
      sb.append(tas.tableName(NODE_TABLE)).append(i).append(".")
        .append(tas.columnName(NODE_TABLE, "id")).append(" AS ")
        .append("id").append(i).append(", ");

      sb.append(tas.tableName(NODE_TABLE)).append(i).append(".")
        .append(tas.columnName(NODE_TABLE, "text_ref")).append(" AS ")
        .append("text").append(i).append(", ");

      sb.append(tas.tableName(NODE_TABLE)).append(i).append(".")
        .append(tas.columnName(NODE_TABLE, "left_token"));

      if(annotateQueryData.getSegmentationLayer() == null)
      {
        sb.append(" - ").append(annotateQueryData.getLeft());
      }
      sb.append(" AS ").append("min").append(i).append(", ");

      sb.append(tas.tableName(NODE_TABLE)).append(i).append(".")
        .append(tas.columnName(NODE_TABLE, "right_token"));
      if(annotateQueryData.getSegmentationLayer() == null)
      {
        sb.append(" + ").append(annotateQueryData.getRight());
      }
      sb.append(" AS ").append("max").append(i).append(", ");

      sb.append(tas.tableName(NODE_TABLE)).append(i).append(".")
        .append(tas.columnName(NODE_TABLE, "corpus_ref"))
        .append(" AS ").append("corpus").append(i).append(", ");

      sb.append(tas.tableName(NODE_TABLE)).append(i).append(".")
        .append(tas.columnName(NODE_TABLE, "node_name"))
        .append(" AS ").append("name").append(i);

      if (i == numOfNodes)
      {
        sb.append("\n");
      }
      else
      {
        sb.append(", \n").append(indent2);
      }
    }

    // FROM
    sb.append(indent).append("FROM\n");
    for (int i = 1; i <= numOfNodes; i++)
    {
      sb.append(indent2)
        .append(tas.tableName(NODE_TABLE)).append(" AS ")
        .append(tas.tableName(NODE_TABLE)).append(i).append(", ")
        .append(tas.tableName(CORPUS_TABLE)).append(" AS ")
        .append(tas.tableName(CORPUS_TABLE)).append(i);

      if (i == numOfNodes)
      {
        sb.append("\n");
      }
      else
      {
        sb.append(",\n").append(indent2);
      }

    }

    // WHERE
    sb.append(indent).append("WHERE\n");
    for (int i = 1; i <= numOfNodes; i++)
    {
      URI uri = saltURIs.get(i - 1);

      // check for corpus/document by it's path
      sb.append(indent2)
        .append(tas.tableName(CORPUS_TABLE)).append(i).append(".path_name = ")
        .append(generatePathName(uri)).append(" AND\n");

      // join the found corpus/document to the facts table
      sb.append(indent2)
        .append(tas.tableName(NODE_TABLE)).append(i).append(".corpus_ref = ")
        .append(tas.tableName(CORPUS_TABLE)).append(i).append(".id AND\n");

      // filter the node with the right name
      sb.append(indent2)
        .append(tas.tableName(NODE_TABLE)).append(i).append(".node_name = ")
        .append("'").append(uri.getFragment()).append("'").append(" AND\n");

      // use the toplevel partioning
      sb.append(indent2)
        .append(tas.tableName(NODE_TABLE)).append(i).append(".toplevel_corpus IN ( ")
        .append(StringUtils.join(corpusList, ",")).append(") ");

      if (i < numOfNodes)
      {
        sb.append("AND\n");
      }
      else
      {
        sb.append("\n");
      }
    }

    // LIMIT to one row
    sb.append(indent).append("LIMIT 1\n");

    return sb.toString();
  }

  @Override
  protected String getMatchesWithClause(QueryData queryData,
    List<QueryNode> alternative, String indent)
  {
    TableAccessStrategy tas = createTableAccessStrategy();

    StringBuilder sb = new StringBuilder();

    String indent2 = indent + TABSTOP;

    List<AnnotateQueryData> extensions =
      queryData.getExtensions(AnnotateQueryData.class);
    AnnotateQueryData annotateQueryData = extensions.isEmpty()
      ? new AnnotateQueryData(5, 5) : extensions.get(0);

    List<SaltURIGroupSet> listOfSaltURIs = queryData.getExtensions(SaltURIGroupSet.class);
    // only work with the first element
    Validate.isTrue(!listOfSaltURIs.isEmpty());

    SaltURIGroupSet saltURIs = listOfSaltURIs.get(0);

    sb.append(indent).append("matches AS\n");
    sb.append(indent).append("(\n");

    LinkedList<String> clauses = new LinkedList<String>();

    for(Map.Entry<Integer, SaltURIGroup> e : saltURIs.getGroups().entrySet())
    {
      clauses.add(
        indent2 + "(\n"+
        singleMatchClause(e.getKey(), e.getValue().getUris(), tas, annotateQueryData,
          queryData.getCorpusList(),alternative.size(), indent2 + TABSTOP)
        + indent2 + ")\n"
      );
    }

    String seperator =indent2 + "UNION ALL\n";
    sb.append(StringUtils.join(clauses, seperator));

    // end WITH inner select
    sb.append(indent).append(")");

    return sb.toString();
  }

  private String generatePathName(URI uri)
  {
    StringBuilder sb = new StringBuilder();

    List<String> path = CommonHelper.getCorpusPath(uri);
    Collections.reverse(path);

    sb.append("{");
    sb.append(StringUtils.join(path, ", "));
    sb.append("}");

    return  sqlString(sb.toString());
  }
}


text:
/*Problem 7. Calculate N! / (K! * (N-K)!)

In combinatorics, the number of ways to choose k different members out of a group of n different elements
(also known as the number of combinations) is calculated by the following formula: formula For example,
there are 2598960 ways to withdraw 5 cards out of a standard deck of 52 cards.
Your task is to write a program that calculates n! / (k! * (n-k)!) for given n and k (1 < k < n < 100). Try to use only two loops.
 */

using System;
using System.Numerics;

namespace _07.CalculateCombinations
{
    class Program
    {
        static void Main()
        {
            Console.Write("n = ");
            int n = int.Parse(Console.ReadLine());
            Console.Write("k = ");
            int k = int.Parse(Console.ReadLine());
            BigInteger result = 1;

            if (n < 100 && n > k && k > 1)
            {
                //Use the properties of factoriel to simplify the expression n!/k!
                //As n > k we have: [ n.(n-1)...(k).(k-1)...1 ] / [k.(k-1)...1] <=> n.(n-1)...(k+1)
                for (int i = (k + 1); i <= n; i++)
                {
                    result = result * i;
                }
                //Divide the above result by (n-k)!
                for (int j = 1; j <= (n - k); j++)
                {
                    result = result / j;
                }
                Console.WriteLine("Result: {0}", result);
            }
            else
                Console.WriteLine("Try different input");

        }
    }
}


text:
<!DOCTYPE html>

		<meta charset="utf-8">
		<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">

		<base href="https://esote.net/" target="_blank">

		<link rel="stylesheet" href="css/bootstrap.css">
		<link rel="stylesheet" href="css/custom.css">
		<link rel="shortcut icon" href="favicon.ico" type="image/x-icon">

		<title>Esote – Classical Cryptography/Backwards Cipher</title>

				Esote

Classical Cryptography

Backwards Cipher

Backwards Cipher

GitHub »

						Backwards-cipher.cpp

Backwards-cipher.cpp

Prints a string backwards.

Code includes two alternative methods for printing a string backwards that have been commented out.

Code

#include <iostream>

int main() {
	std::string plaintext;
	std::getline(std::cin, plaintext);

	for(int i = plaintext.length() - 1; i >= 0; --i){
		std::cout << plaintext[i];
	}

	/* Alternatively

	std::getline(std::cin, plaintext);
	std::reverse(std::begin(plaintext), std::end(plaintext));
	std::cout << plaintext << '\n';

	*/

	/* Alternatively

	for(auto it = plaintext.rbegin(); it != plaintext.rend(); ++it){
		std::cout << *it;
	}

	*/

	std::cout << '\n';
	return 0;
}

Example output

Hello world!
!dlrow olleH

'Tis but a scratch!
!hctarcs a tub siT'


text:
@class OCSSPrimitiveValue;
@class OCSSStyleDeclaration;

@interface OCXProperty : NSObject

@property (nonatomic) NSString *propertyName;
@property (nonatomic, readonly) OCSSPrimitiveValue *value;
@property (readonly) NSString *cssText;
@property (weak) OCSSStyleDeclaration *parentStyleDeclaration;

@end


text:
<?xml version="1.0" encoding="UTF-8"?>

<rootTag>
  <Award>
    <AwardTitle>I-Corps: Quantitative phase imaging solutions for materials and life sciences</AwardTitle>
    <AwardEffectiveDate>03/15/2012</AwardEffectiveDate>
    <AwardExpirationDate>08/31/2012</AwardExpirationDate>
    <AwardAmount>50000</AwardAmount>
    <AwardInstrument>
      <Value>Standard Grant</Value>
    </AwardInstrument>
    <Organization>
      07070000
      <Directorate>
        <LongName>Directorate For Engineering</LongName>
      </Directorate>
      <Division>
        <LongName>Div Of Industrial Innovation & Partnersh</LongName>
      </Division>
    </Organization>
    <ProgramOfficer>
      <SignBlockName>Errol Arkilic</SignBlockName>
    </ProgramOfficer>
    <AbstractNarration>This Innovation Corps project will focus on extending the boundaries of quantitative phase imaging (QPI) developed by the PI to high-impact applications including neuroscience, cancer imaging, and cell membrane biophysics. The PI/team intend to build an "alpha unit" prototype of the QPI technology. <br/><br/>If successfulu, the proposed technology has the potential to provide affordable, fast and accurate instruments for the medical community; and to offer improved quality setups for industry. The main features the proposed technology provides are: noninvasive, label-free, quantitative, nanoscale, and 3D imaging.</AbstractNarration>
    <MinAmdLetterDate>03/13/2012</MinAmdLetterDate>
    <MaxAmdLetterDate>03/13/2012</MaxAmdLetterDate>
    <ARRAAmount/>
    <AwardID>1237243</AwardID>
    <Investigator>
      <FirstName>Gabriel</FirstName>
      <LastName>Popescu</LastName>
      <EmailAddress>gpopescu@illinois.edu</EmailAddress>
      <StartDate>03/13/2012</StartDate>
      <EndDate/>
      <RoleCode>Principal Investigator</RoleCode>
    </Investigator>
    <Institution>
      <Name>University of Illinois at Urbana-Champaign</Name>
      <CityName>CHAMPAIGN</CityName>
      <ZipCode>618207473</ZipCode>
      <PhoneNumber>2173332187</PhoneNumber>
      <StreetAddress>SUITE A</StreetAddress>
      <CountryName>United States</CountryName>
      <StateName>Illinois</StateName>
      <StateCode>IL</StateCode>
    </Institution>
    <ProgramElement>
      8023
      <Text>I-Corps</Text>
    </ProgramElement>
  </Award>
</rootTag>


text:
.. _NEP34:

===========================================================
NEP 34 — Disallow inferring ``dtype=object`` from sequences
===========================================================

:Author: Matti Picus
:Status: Final
:Type: Standards Track
:Created: 2019-10-10
:Resolution: https://mail.python.org/pipermail/numpy-discussion/2019-October/080200.html

Abstract
--------

When users create arrays with sequences-of-sequences, they sometimes err in
matching the lengths of the nested sequences_, commonly called "ragged
arrays".  Here we will refer to them as ragged nested sequences. Creating such
arrays via ``np.array([<ragged_nested_sequence>])`` with no ``dtype`` keyword
argument will today default to an ``object``-dtype array. Change the behaviour to
raise a ``ValueError`` instead.

Motivation and Scope
--------------------

Users who specify lists-of-lists when creating a `numpy.ndarray` via
``np.array`` may mistakenly pass in lists of different lengths. Currently we
accept this input and automatically create an array with ``dtype=object``. This
can be confusing, since it is rarely what is desired. Changing the automatic
dtype detection to never return ``object`` for ragged nested sequences (defined as a
recursive sequence of sequences, where not all the sequences on the same
level have the same length) will force users who actually wish to create
``object`` arrays to specify that explicitly. Note that ``lists``, ``tuples``,
and ``nd.ndarrays`` are all sequences [0]_. See for instance `issue 5303`_.

Usage and Impact
----------------

After this change, array creation with ragged nested sequences must explicitly
define a dtype:

    >>> np.array([[1, 2], [1]])
    ValueError: cannot guess the desired dtype from the input

    >>> np.array([[1, 2], [1]], dtype=object)
    # succeeds, with no change from current behaviour

The deprecation will affect any call that internally calls ``np.asarray``.  For
instance, the ``assert_equal`` family of functions calls ``np.asarray``, so
users will have to change code like::

    np.assert_equal(a, [[1, 2], 3])

to::

    np.assert_equal(a, np.array([[1, 2], 3], dtype=object))

Detailed description
--------------------

To explicitly set the shape of the object array, since it is sometimes hard to
determine what shape is desired, one could use:

    >>> arr = np.empty(correct_shape, dtype=object)
    >>> arr[...] = values

We will also reject mixed sequences of non-sequence and sequence, for instance
all of these will be rejected:

    >>> arr = np.array([np.arange(10), [10]])
    >>> arr = np.array([[range(3), range(3), range(3)], [range(3), 0, 0]])

Related Work
------------

`PR 14341`_ tried to raise an error when ragged nested sequences were specified
with a numeric dtype ``np.array, [[1], [2, 3]], dtype=int)`` but failed due to
false-positives, for instance ``np.array([1, np.array([5])], dtype=int)``.

.. _`PR 14341`: https://github.com/numpy/numpy/pull/14341

Implementation
--------------

The code to be changed is inside ``PyArray_GetArrayParamsFromObject`` and the
internal ``discover_dimensions`` function. The first implementation in `PR
14794`_ caused a number of downstream library failures and was reverted before
the release of 1.18. Subsequently downstream libraries fixed the places they
were using ragged arrays. The reimplementation became `PR 15119`_ which was
merged for the 1.19 release.

Backward compatibility
----------------------

Anyone depending on creating object arrays from ragged nested sequences will
need to modify their code. There will be a deprecation period during which the
current behaviour will emit a ``DeprecationWarning``.

Alternatives
------------

- We could continue with the current situation.

- It was also suggested to add a kwarg ``depth`` to array creation, or perhaps
  to add another array creation API function ``ragged_array_object``. The goal
  was to eliminate the ambiguity in creating an object array from ``array([[1,
  2], [1]], dtype=object)``: should the returned array have a shape of
  ``(1,)``, or ``(2,)``? This NEP does not deal with that issue, and only
  deprecates the use of ``array`` with no ``dtype=object`` for ragged nested
  sequences. Users of ragged nested sequences may face another deprecation
  cycle in the future. Rationale: we expect that there are very few users who
  intend to use ragged arrays like that, this was never intended as a use case
  of NumPy arrays. Users are likely better off with `another library`_ or just
  using list of lists.

- It was also suggested to deprecate all automatic creation of ``object``-dtype
  arrays, which would require adding an explicit ``dtype=object`` for something
  like ``np.array([Decimal(10), Decimal(10)])``. This too is out of scope for
  the current NEP. Rationale: it's harder to asses the impact of this larger
  change, we're not sure how many users this may impact.

Discussion
----------

Comments to `issue 5303`_ indicate this is unintended behaviour as far back as
2014. Suggestions to change it have been made in the ensuing years, but none
have stuck. The WIP implementation in `PR 14794`_ seems to point to the
viability of this approach.

References and Footnotes
------------------------

.. _`issue 5303`: https://github.com/numpy/numpy/issues/5303
.. _sequences: https://docs.python.org/3.7/glossary.html#term-sequence
.. _`PR 14794`: https://github.com/numpy/numpy/pull/14794
.. _`PR 15119`: https://github.com/numpy/numpy/pull/15119
.. _`another library`: https://github.com/scikit-hep/awkward-array

.. [0] ``np.ndarrays`` are not recursed into, rather their shape is used
   directly. This will not emit warnings::

      ragged = np.array([[1], [1, 2, 3]], dtype=object)
      np.array([ragged, ragged]) # no dtype needed

Copyright
---------

This document has been placed in the public domain.


text:
source "$UNO_HOME"/bin/impl/util.sh

[[ -n $LOGS_DIR ]] && rm -f "$LOGS_DIR"/setup/*.{out,err}
echo "Beginning setup (detailed logs in $LOGS_DIR/setup)..."
save_console_fd

case "$1" in
  accumulo|fluo)
    setup_component "$1" "$2"
    ;;
  hadoop|zookeeper|fluo-yarn)
    setup_component "$1"
    ;;
  *)
    echo "Usage: uno setup <component> [--no-deps]"
    echo -e "\nPossible components:\n"
    echo "    accumulo   Sets up Apache Accumulo and its dependencies (Hadoop & ZooKeeper)"
    echo "    hadoop     Sets up Apache Hadoop"
    echo "    fluo       Sets up Apache Fluo and its dependencies (Accumulo, Hadoop, & ZooKeeper)"
    echo "    fluo-yarn  Sets up Apache Fluo YARN and its dependencies (Fluo, Accumulo, Hadoop, & ZooKeeper)"
    echo -e "    zookeeper  Sets up Apache ZooKeeper\n"
    echo "Options:"
    echo "    --no-deps  Dependencies will be setup unless this option is specified. Only works for fluo & accumulo components."
    exit 1
    ;;
esac

if [[ "$?" == 0 ]]; then
  echo "Setup complete."
else
  echo "Setup failed!"
  false
fi


text:
Atomic-Reactor has a proper Python API. You can use it in your scripts or
services without invoking a shell:

```python
from atomic_reactor.api import build_image_in_privileged_container

response = build_image_in_privileged_container(
    "privileged-buildroot",
    source={
        'provider': 'git',
        'uri': 'https://github.com/TomasTomecek/docker-hello-world.git',
    },
    image="atomic-reactor-test-image",
)
```

## Source

The `source` argument to API functions specifies how to obtain the source code
that should be put in the image.

- `provider`
  - `git`
  - `path`
- `uri`
  - If `provider` is `git`, `uri` is a Git repo URI
  - If `provider` is `path`, `uri` is path in format `file:///abs/path`
- `dockerfile_path` (optional): Path to Dockerfile inside a directory obtained
  from URI; `./` is default
- `provider_params` (optional):
  - If `provider` is `git`, `provider_params` can contain key `git_commit` (git
    commit to put inside the image)
  - There are no params for `path` as of now

For example:

```python
git_source = {
    'provider': 'git',
    'uri': 'https://github.com/foo/bar.git',
    'dockerfile_path': 'spam/spam/',
    'provider_params': {'git_commit': 'abcdefg'}
}

path_params = {
    'provider': 'path',
    'uri': 'file:///path/to/directory',
    'dockerfile_path': 'foo/',
}
```

## Module 'api'

Copyright (c) 2015 Red Hat, Inc
All rights reserved.

This software may be modified and distributed under the terms
of the BSD license. See the LICENSE file for details.

Python API for atomic-reactor. This is the official way of interacting with
atomic-reactor.

### 'api' Functions

```python
build_image_here(source, image,
                 parent_registry=None,
                 target_registries=None,
                 parent_registry_insecure=False,
                 target_registries_insecure=False,
                 dont_pull_base_image=False,
                 **kwargs):
```

```text
    build image from provided dockerfile (specified by `source`) in current environment

    :param source: dict, where/how to get source code to put in image
    :param image: str, tag for built image ([registry/]image_name[:tag])
    :param parent_registry: str, registry to pull base image from
    :param target_registries: list of str, list of registries to push image to (might change in future)
    :param parent_registry_insecure: bool, allow connecting to parent registry over plain http
    :param target_registries_insecure: bool, allow connecting to target registries over plain http
    :param dont_pull_base_image: bool, don't pull or update base image specified in dockerfile

    :return: BuildResults
```

```python
build_image_in_privileged_container(build_image, source, image,
                                    parent_registry=None,
                                    target_registries=None,
                                    push_buildroot_to=None,
                                    parent_registry_insecure=False,
                                    target_registries_insecure=False,
                                    dont_pull_base_image=False,
                                    **kwargs)
```

```text
    build image from provided dockerfile (specified by `source`) in privileged container by
    running another docker instance inside the container

    :param build_image: str, image where target image should be built
    :param source: dict, where/how to get source code to put in image
    :param image: str, tag for built image ([registry/]image_name[:tag])
    :param parent_registry: str, registry to pull base image from
    :param target_registries: list of str, list of registries to push image to (might change in future)
    :param push_buildroot_to: str, repository where buildroot should be pushed
    :param parent_registry_insecure: bool, allow connecting to parent registry over plain http
    :param target_registries_insecure: bool, allow connecting to target registries over plain http
    :param dont_pull_base_image: bool, don't pull or update base image specified in dockerfile

    :return: BuildResults
```

```python
build_image_using_hosts_docker(build_image, source, image,
                               parent_registry=None,
                               target_registries=None,
                               push_buildroot_to=None,
                               parent_registry_insecure=False,
                               target_registries_insecure=False,
                               dont_pull_base_image=False,
                               **kwargs)
```

```text
    build image from provided dockerfile (specified by `source`) in privileged container
    using docker from host

    :param build_image: str, image where target image should be built
    :param source: dict, where/how to get source code to put in image
    :param image: str, tag for built image ([registry/]image_name[:tag])
    :param parent_registry: str, registry to pull base image from
    :param target_registries: list of str, list of registries to push image to (might change in future)
    :param push_buildroot_to: str, repository where buildroot should be pushed
    :param parent_registry_insecure: bool, allow connecting to parent registry over plain http
    :param target_registries_insecure: bool, allow connecting to target registries over plain http
    :param dont_pull_base_image: bool, don't pull or update base image specified in dockerfile

    :return: BuildResults
```

## Module 'core'

### 'core' Classes

#### DockerTasker class

##### DockerTasker Instance variables

- d
- last_logs
  - `logs from last operation`

##### DockerTasker Methods

```python
__init__(self,
         base_url=None,
         timeout=120,
         **kwargs)
```

```text
    Constructor

    :param base_url: str, docker connection URL
    :param timeout: int, timeout for docker client
```

```python
build_image_from_git(self, url, image,
                     git_path=None,
                     git_commit=None,
                     copy_dockerfile_to=None,
                     stream=False,
                     use_cache=False)
```

```text
    build image from provided url and tag it

    this operation is asynchronous and you should consume returned generator in order to wait
    for build to finish

    :param url: str
    :param image: ImageName, name of the resulting image
    :param git_path: str, path to dockerfile within gitrepo
    :param copy_dockerfile_to: str, copy dockerfile to provided path
    :param stream: bool, True returns generator, False returns str
    :param use_cache: bool, True if you want to use cache
    :return: generator
```

```python
build_image_from_path(self, path, image,
                      stream=False,
                      use_cache=False,
                      remove_im=True)
```

```text
    build image from provided path and tag it

    this operation is asynchronous and you should consume returned generator in
        order to wait
    for build to finish

    :param path: str
    :param image: ImageName, name of the resulting image
    :param stream: bool, True returns generator, False returns str
    :param use_cache: bool, True if you want to use cache
    :param remove_im: bool, remove intermediate containers produced during docker build
    :return: generator
```

```python
commit_container(self, container_id,
                 image=None
                 message=None)
```

```text
    create image from provided container

    :param container_id: str
    :param image: ImageName
    :param message: str
    :return: image_id
```

```python
get_image_info_by_image_id(self, image_id)
```

```text
    using `docker images`, provide information about an image

    :param image_id: str, hash of image to get info
    :return: str or None
```

```python
get_image_info_by_image_name(self, image,
                             exact_tag=True)
```

```text
    using `docker images`, provide information about an image

    :param image: ImageName, name of image
    :param exact_tag: bool, if false then return info for all images of the
                        given name regardless what their tag is
    :return: list of dicts
```

```python
get_info(self)
```

```text
    get info about used docker environment

    :return: dict, json output of `docker info`
```

```python
get_version(self)
```

```text
    get version of used docker environment

    :return: dict, json output of `docker version`
```

```python
image_exists(self, image_id)
```

```text
    does provided image exists?

    :param image_id: str or ImageName
    :return: True if exists, False if not
```

```python
inspect_image(self, image_id)
```

```text
    return detailed metadata about provided image (see 'man docker-inspect')

    :param image_id: str or ImageName, id or name of the image
    :return: dict
```

```python
login(self, registry, docker_secret_path)
```

```text
    login to docker registry

    :param registry: registry name
    :param docker_secret_path: path to docker config directory
```

```python
logs(self, container_id,
     stderr=True,
     stream=True)
```

```text
    acquire output (stdout, stderr) from provided container

    :param container_id: str
    :param stderr: True, False
    :param stream: if True, return as generator
    :return: either generator, or list of strings
```

```python
pull_image(self, image,
           insecure=False)
```

```text
    pull provided image from registry

    :param image_name: ImageName, image to pull
    :param insecure: bool, allow connecting to registry over plain http
    :return: str, image (reg.om/img:v1)
```

```python
push_image(self, image,
           insecure=False)
```

```text
    push provided image to registry

    :param image: ImageName
    :param insecure: bool, allow connecting to registry over plain http
    :return: str, logs from push
```

```python
remove_container(self, container_id,
                 force=False)
```

```text
    Remove provided container from filesystem

    :param container_id: str
    :param force: bool, remove forcefully?
    :return: None
```

```python
remove_image(self, image_id,
             force=False,
             noprune=False)
```

```text
    Remove provided image from filesystem

    :param image_id: str or ImageName
    :param noprune: bool, keep untagged parents?
    :param force: bool, force remove -- just trash it no matter what
    :return: None
```

```python
run(self, image,
    command=None,
    create_kwargs=None,
    start_kwargs=None)
```

```text
    Create container from provided image and start it

    For more info, see documentation of REST API calls:
        - containers/{}/start
        - container/create

    :param image: ImageName or string, name or id of the image
    :param command: str
    :param create_kwargs: dict, kwargs for docker.create_container
    :param start_kwargs: dict, kwargs for docker.start
    :return: str, container id
```

```python
tag_and_push_image(self, image, target_image,
                   insecure=False,
                   force=False,
                   dockercfg=None)
```

```text
    tag provided image and push it to registry

    :param image: str or ImageName, image id or name
    :param target_image: ImageName, img
    :param insecure: bool, allow connecting to registry over plain http
    :param force: bool, force the tag?
    :param dockercfg: path to docker config
    :return: str, image (reg.com/img:v1)
```

```python
tag_image(self, image, target_image,
          force=False)
```

```text
    tag provided image with specified image_name, registry and tag

    :param image: str or ImageName, image to tag
    :param target_image: ImageName, new name for the image
    :param force: bool, force tag the image?
    :return: str, image (reg.om/img:v1)
```

```python
wait(self, container_id)
```

```text
    wait for container to finish the job (may run infinitely)

    :param container_id: str
    :return: int, exit code
```

## Module 'inner'

### 'inner' Classes

#### DockerBuildWorkflow class

This class defines a workflow for building images

1. Pull image from registry
1. Tag it properly if needed
1. Obtain source
1. Build image
1. Tag it
1. Push it to the registry

##### DockerBuildWorkflow instance variables

- autorebuild_canceled
- base_image_inspect
- build_result
- build_process_failed
  - `Has any aspect of the build process failed?`
- builder
- built_image_inspect
- exit_plugins_conf
- exported_image_sequence
- files
- image
- kwargs
- plugin_failed
- plugin_files
- plugins_durations
- plugins_errors
- plugins_timestamps
- postbuild_plugins_conf
- prebuild_plugins_conf
- prepublish_plugins_conf
- pulled_base_images
- source
- tag_conf

##### DockerBuildWorkflow methods

```python
__init__(self, source, image,
         prebuild_plugins=None,
         prepublish_plugins=None,
         postbuild_plugins=None,
         exit_plugins=None,
         plugin_files=None,
         kwargs)
```

```text
    Constructor

    :param source: dict, where/how to get source code to put in image
    :param image: str, tag for built image ([registry/]image_name[:tag])
    :param prebuild_plugins: dict, arguments for pre-build plugins
    :param prepublish_plugins: dict, arguments for test-build plugins
    :param postbuild_plugins: dict, arguments for post-build plugins
    :param plugin_files: list of str, load plugins also from these files
```

```python
build_docker_image(self)
```

```text
    build docker image

    :return: BuildResults
```

## Module 'build'

### 'build' Classes

#### InsideBuilder class

This is expected to run within container

##### InsideBuilder instance variables

- base_image_id
- built_image_info
- image
- image_id
- last_logs
  - `logs from last operation`
- source
- tasker

##### InsideBuilder methods

```python
__init__(self, source, image, kwargs)
```

```text
    Constructor
```

```python
build(self)
```

```text
    build image inside current environment;
    it's expected this may run within (privileged) docker container

    :return: image string (e.g. fedora-python:34)
```

```python
get_base_image_info(self)
```

```text
    query docker about base image

    :return dict
```

```python
get_built_image_info(self)
```

```text
    query docker about built image

    :return dict
```

```python
inspect_base_image(self)
```

```text
    inspect base image

    :return: dict
```

```python
inspect_built_image(self)
```

```text
    inspect built image

    :return: dict
```

```python
set_base_image(self, base_image)
```


text:
<?php

/* FOSUserBundle:Registration:register.html.twig */
class __TwigTemplate_a45bc8fcc3ed2272b500c1ab7c849a26ac822ba88450b29667a0b3de338a1aee extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = $this->env->loadTemplate("LayoutBundle:Backend:security.html.twig");

        $this->blocks = array(
            'security_content' => array($this, 'block_security_content'),
        );
    }

    protected function doGetParent(array $context)
    {
        return "LayoutBundle:Backend:security.html.twig";
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        $this->parent->display($context, array_merge($this->blocks, $blocks));
    }

    // line 3
    public function block_security_content($context, array $blocks = array())
    {
        // line 4
        echo "
    <form class=\"form-vertical login-form\" action=\"";
        // line 5
        echo $this->env->getExtension('routing')->getPath("fos_user_registration_register");
        echo "\" ";
        echo $this->env->getExtension('form')->renderer->searchAndRenderBlock((isset($context["form"]) ? $context["form"] : $this->getContext($context, "form")), 'enctype');
        echo " method=\"post\">

Create New account

            ";
        // line 9
        echo $this->env->getExtension('form')->renderer->searchAndRenderBlock((isset($context["form"]) ? $context["form"] : $this->getContext($context, "form")), 'widget');
        echo "

            <button type=\"submit\" id=\"_submit\" name=\"_submit\" class=\"btn green pull-left\">
                Create
            </button>

                Already have an account ?
                env->getExtension('routing')->getPath("fos_user_security_login");
        echo "\" id=\"register-btn\" >Login

    </form>
";
    }

    public function getTemplateName()
    {
        return "FOSUserBundle:Registration:register.html.twig";
    }

    public function isTraitable()
    {
        return false;
    }

    public function getDebugInfo()
    {
        return array (  56 => 19,  43 => 9,  34 => 5,  31 => 4,  28 => 3,);
    }
}


text:
package com.digitalpetri.opcua.stack.core.types.builtin;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

import com.digitalpetri.opcua.stack.core.types.builtin.unsigned.UShort;
import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;

import static com.digitalpetri.opcua.stack.core.types.builtin.unsigned.Unsigned.ushort;

/**
 * This Built-in DataType contains a qualified name. It is, for example, used as BrowseName.
 */
public final class QualifiedName {

    public static final QualifiedName NULL_VALUE = new QualifiedName(ushort(0), null);

    private final UShort namespaceIndex;
    private final String name;

    /**
     * The name part of the QualifiedName is restricted to 512 characters.
     *
     * @param namespaceIndex index that identifies the namespace that defines the name. This index is the index of that
     *                       namespace in the local Server's NamespaceArray.
     * @param name           the text portion of the QualifiedName.
     */
    public QualifiedName(int namespaceIndex, @Nullable String name) {
        this(ushort(namespaceIndex), name);
    }

    /**
     * The name part of the QualifiedName is restricted to 512 characters.
     *
     * @param namespaceIndex index that identifies the namespace that defines the name. This index is the index of that
     *                       namespace in the local Server's NamespaceArray.
     * @param name           the text portion of the QualifiedName.
     */
    public QualifiedName(@Nonnull UShort namespaceIndex, @Nullable String name) {
        Preconditions.checkNotNull(namespaceIndex);
        Preconditions.checkArgument(name == null || name.length() <= 512, "name");

        this.namespaceIndex = namespaceIndex;
        this.name = name;
    }

    public UShort getNamespaceIndex() {
        return namespaceIndex;
    }

    @Nullable
    public String getName() {
        return name;
    }

    public boolean isNull() {
        return name == null;
    }

    public boolean isNotNull() {
        return !isNull();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        QualifiedName that = (QualifiedName) o;

        return !(name != null ? !name.equals(that.name) : that.name != null) &&
                namespaceIndex.equals(that.namespaceIndex);
    }

    @Override
    public int hashCode() {
        int result = namespaceIndex.hashCode();
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("name", name)
                .add("namespaceIndex", namespaceIndex)
                .toString();
    }

    public String toParseableString() {
        return String.format("%s:%s", namespaceIndex.intValue(), name);
    }

    public static QualifiedName parse(String s) {
        String[] ss = s.split(":");

        int namespaceIndex = 0;
        String name = s;

        if (ss.length > 1) {
            try {
                namespaceIndex = Short.parseShort(ss[0]);
            } catch (NumberFormatException ignored) {
                namespaceIndex = 0;
            }
            name = ss[1];
        }

        return new QualifiedName(ushort(namespaceIndex), name);
    }

}


text:
#import <Foundation/Foundation.h>
#import "PBObject.h"

/**
* Location Intelligence APIs
* Incorporate our extensive geodata into everyday applications, business processes and workflows.
*
* OpenAPI spec version: 8.5.0
*
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

@protocol PBAHJmailingAddress
@end

@interface PBAHJmailingAddress : PBObject

@property(nonatomic) NSString* formattedAddress;

@property(nonatomic) NSString* mainAddressLine;

@property(nonatomic) NSString* addressLastLine;

@property(nonatomic) NSString* placeName;

@property(nonatomic) NSString* areaName1;

@property(nonatomic) NSString* areaName2;

@property(nonatomic) NSString* areaName3;

@property(nonatomic) NSString* areaName4;

@property(nonatomic) NSString* postCode;

@property(nonatomic) NSString* postCodeExt;

@property(nonatomic) NSString* country;

@property(nonatomic) NSString* addressNumber;

@property(nonatomic) NSString* streetName;

@property(nonatomic) NSString* unitType;

@property(nonatomic) NSString* unitValue;

@end


text:
var express = require('express');
var router = express.Router();
var request = require('request');

var urls = [];

router.get('/', function(req, res, next) {
  res.render('shorten', {urls: urls})
});

router.post('/', function(req, res, next){
    var url = req.body.url;

    if (!url){
        res.render('shorten', {urls: urls});
    }
    else{
        if (url.indexOf("http") != 0){
            url = "http://" + url;
        }
        request.post({url:'http://gofurl.herokuapp.com', form:{url: url}}, function(error, response, body){

            if (error) res.render('shorten', {urls: urls, error: error});
            else {
                try {
                    var jsonObj = JSON.parse(body);

                    urls.push({url: jsonObj.url, hash: jsonObj.hash});

                    res.render('shorten', {urls: urls})
                }
                catch (e){
                    res.render('shorten', {urls: urls, error: e})
                }
            }
        })
    }
});

module.exports = router;


text:
import {runClickBenchmark, verifyNoBrowserErrors} from 'angular2/src/testing/perf_util';

describe('ng2 tree benchmark', function() {

  var URL = 'benchmarks/src/tree/tree_benchmark.html';

  afterEach(verifyNoBrowserErrors);

  it('should log the ng stats', function(done) {
    runClickBenchmark({
      url: URL,
      buttons: ['#ng2DestroyDom', '#ng2CreateDom'],
      id: 'ng2.tree.create.plain',
      params: [{name: 'depth', value: 9, scale: 'log2'}]
    }).then(done, done.fail);
  });

  it('should log the ng stats (update)', function(done) {
    runClickBenchmark({
      url: URL,
      buttons: ['#ng2CreateDom'],
      id: 'ng2.tree.update',
      params: [{name: 'depth', value: 9, scale: 'log2'}]
    }).then(done, done.fail);
  });

  it('should log the baseline stats', function(done) {
    runClickBenchmark({
      url: URL,
      buttons: ['#baselineDestroyDom', '#baselineCreateDom'],
      id: 'baseline.tree.create',
      params: [{name: 'depth', value: 9, scale: 'log2'}]
    }).then(done, done.fail);
  });

  it('should log the baseline stats (update)', function(done) {
    runClickBenchmark({
      url: URL,
      buttons: ['#baselineCreateDom'],
      id: 'baseline.tree.update',
      params: [{name: 'depth', value: 9, scale: 'log2'}]
    }).then(done, done.fail);
  });

});


text:
title: Potilastietojen import
intro: Siirrä potilas- ja yritysasiakastietoja ulkopuolisesta järjestelmästä Acute-järjestelmään.
layout: post
date: 2017-06-23
thumbnail: folder_into.png
img:
logo: vitec/vitec_logo.png
categories: tiedonsiirrot
tags: vitec
---
Acuten Import mahdollistaa potilastietojen ja yritysasiakkaiden perustietojen tuonnin ulkopuolisesta järjestelmästä  Acute-järjestelmään. Palvelua käytetään yleensä tilanteissa, joissa työterveyshuollon potilaita siirtyy toiselta palveluntarjoajalta tai vanhasta tietojärjestelmästä siirrytään Acute-järjestelmän käyttöön.

#### Importissa siirtyvät tiedot

- Asiakkaiden perustiedot.
- Asiakkaiden työsuhdetiedot.
- Asiakkaan kertomustiedot (käytettävissä arkisto/lukutyökalussa).
- Yritysten perustiedot.
- Yritysten kertomustiedot  (käytettävissä arkisto/lukutyökalussa).

#### PALVELUN HYÖDYT

- Potilastiedot saadaan tuotua järjestelmään yhtenä massana.
- Vanhat potilastiedot ovat tarkasteltavissa Acuten kertomuksessa.
- Yritysasiakkaiden perustiedot ovat käytettävissä järjestelmässä.
- Yritysasiakkaiden kertomustiedot ovat käytettävissä.
- Asiakkaiden mahdolliset työsuhteet on kytketty valmiiksi oikeaan organisaatioon.

### Ota yhteyttä

Kysy lisää tai pyydä yksityiskohtainen kuvaus tästä Acuten lisäpalvelusta:
[myynti.acute@vitecsoftware.com](mailto://myynti.acute@vitecsoftware.com) tai
puhelimella [03 3395 0910](tel://+358333950910).