************
private
***********
508383
function prepareEPUBDataForIndexing(metaData) {

    if (!metaData.spineItems.length)
        return;

    var data = [];

    const arrayOfPromises = metaData.spineItems.map(spineItem => {
        return helper.getContent(spineItem.href)
            .then(body => { return cheerio.load(body); })
    });

    return Promise.all(arrayOfPromises)
        .then((arrayOf$) => {

            arrayOf$.forEach(($, i) => {
                const doc = {};
                $("title").each((i, e) => {
                    doc.title = trim($(e).text());
                });
                $("body").each((i, e) => {
                    doc.body = trim($(e).text());
                });
                setMetaData(doc, metaData, metaData.spineItems[i]);
                data.push(doc);
            });
            return data;
        })
        .catch(err => {
            winston.log('error', 'prepareEPUBDataForIndexing: ' + err);
        });
}
645327
private static boolean memberOfEnclosing(Symbol owner, VisitorState state, Symbol sym) {
    if (sym == null || !sym.hasOuterInstance()) {
      return false;
    }
    for (ClassSymbol encl = owner.owner.enclClass();
        encl != null;
        encl = encl.owner != null ? encl.owner.enclClass() : null) {
      if (sym.isMemberOf(encl, state.getTypes())) {
        return true;
      }
    }
    return false;
  }
526590
def private_const_set(name, const)
      unless role_const_defined?(name)
        const = const_set(name, const)
        private_constant name.to_sym
      end
      const
    end
701563
function onHidden() {
    bus.sounds.forEach(sound => {
        if (sound.playing) {
            sound.pause();
            pageHiddenPaused.push(sound);
        }
    });
}
384682
function (node) {
        var parent = node._parent;
        while(parent) {
            if (parent === this) {
                return true;
            }
            parent = parent._parent;
        }
        return false;
    }
1153262
def is_private(self):
        
        return (self in IPv6Network('::1/128') or
                self in IPv6Network('::/128') or
                self in IPv6Network('::ffff:0:0/96') or
                self in IPv6Network('100::/64') or
                self in IPv6Network('2001::/23') or
                self in IPv6Network('2001:2::/48') or
                self in IPv6Network('2001:db8::/32') or
                self in IPv6Network('2001:10::/28') or
                self in IPv6Network('fc00::/7') or
                self in IPv6Network('fe80::/10'))
491538
function(privateKey, cb = null){
        if(isFunction(cb)){
            try {
                return cb(null, ethUtils.privateToPublic(privateKey))
            }
            catch(err){
                return cb(err)
            }
        } else {
            try {
                return ethUtils.privateToPublic(privateKey)
            }
            catch(err){
                return err
            }
        }
    }
1214244
def is_private(self):
        
        private_10 = IPv4Network('10.0.0.0/8')
        private_172 = IPv4Network('172.16.0.0/12')
        private_192 = IPv4Network('192.168.0.0/16')
        return (self in private_10 or
                self in private_172 or
                self in private_192)
217864
def private_messenger():
    
    while __websocket_server_running__:
        pipein = open(PRIVATE_PIPE, 'r')
        line = pipein.readline().replace('\n', '').replace('\r', '')
        if line != '':
            message = json.loads(line)
            WebSocketHandler.send_private_message(user_id=message['user_id'],
                                                  message=message)
            print line
            
            remaining_lines = pipein.read()
            pipein.close()
            pipeout = open(PRIVATE_PIPE, 'w')
            pipeout.write(remaining_lines)
            pipeout.close()
        else:
            pipein.close()
        
        time.sleep(0.05)
131730
function Tineye (public, private) {
    var self = this;

    // Defaults
    self.public     = public;
    self.private    = private;
    self.defaults   = {
        base:       'http://api.tineye.com/rest',
        throttle:   2000,
        method:     'get',
        json:       {}
    };

    // Run in sandbox mode if no public/private keys are provided
    // https://api.tineye.com/documentation/sandbox
    if (typeof public === 'undefined' && typeof private === 'undefined') {
        self.public         = 'LCkn,2K7osVwkX95K4Oy';
        self.private        = '6mm60lsCNIB,FwOWjJqA80QZHh9BMwc-ber4u=t^';
        self.defaults.base  = 'http://api.tineye.com/sandbox';
    }

    /**
     * Register the tineye API with cork.
     */
    cork.register('tineye', self.defaults);

    /**
     * Request "signer".
     *
     * @param {Object} Request arguments.
     *
     * @return {Object}
     */
    self.sign = function (args) {
        _.extend(args, self.defaults);

        var epoch   = getEpoch();
        var nonce   = getNonce();

        var concat  = self.private;                     // Private key
        concat      += args.method.toUpperCase();       // HTTP method
        concat      += '';                              // Content-type
        concat      += '';                              // Uploaded image name
        concat      += epoch;                           // Date
        concat      += nonce;                           // Nonce
        concat      += self.defaults.base + args.uri;   // Request url

        // Query string params
        if (typeof args.qs !== 'undefined') {
            var append = encodeURIComponent(args.qs.image_url);
            concat += 'image_url=' + append;
        }

        // Return object to be appended to the query string
        return {
            'api_key':  self.public,
            'api_sig':  hmac(concat, self.private),
            'nonce':    nonce,
            'date':     epoch
        };
    };

    /**
     * Request adapter.
     *
     * @param {Object} HTTP request arguments
     *
     * @return {Object}
     */
    self.request = function (args, callback) {
        // Generate signature & request body
        var signature   = self.sign(args);
        var qs          = args.qs || Object.create(null);
        var body        = _.extend(args, {
            qs: signature
        });

        if (typeof qs.image_url !== 'undefined') {
            body.uri += '?image_url=' + encodeURIComponent(qs.image_url);
        }

        // Init request
        cork.request('tineye', body, callback);
    };
}
422735
def get_private_name(self, f):
        
        f = self.__swagger_rename__[f] if f in self.__swagger_rename__.keys() else f
        return '_' + self.__class__.__name__ + '__' + f
239457
public void setPrivateIpAddresses(java.util.Collection<NetworkInterfacePrivateIpAddress> privateIpAddresses) {
        if (privateIpAddresses == null) {
            this.privateIpAddresses = null;
            return;
        }

        this.privateIpAddresses = new com.amazonaws.internal.SdkInternalList<NetworkInterfacePrivateIpAddress>(privateIpAddresses);
    }
57966
function (key) {
        let _that = this[PRIVATE];

        key = KEYMAP[key.toUpperCase()];
        if (key < _that.pressed.length && key != null) {
            _that.pressed[key] = true;
        }
    }
275997
def make_definition(this, &blk)
      is_private = private?(this)
      is_protected = protected?(this)
      alias_target(this).send(:define_method, name, &blk)
      make_private(this) if is_private
      make_protected(this) if is_protected
    end
960502
public void onConversationHidden(Peer peer) {
        if (visiblePeer != null && visiblePeer.equals(peer)) {
            this.visiblePeer = null;
        }
    }
121222
@UnstableApi
    public final void setPrivateKeyMethod(OpenSslPrivateKeyMethod method) {
        ObjectUtil.checkNotNull(method, "method");
        Lock writerLock = ctxLock.writeLock();
        writerLock.lock();
        try {
            SSLContext.setPrivateKeyMethod(ctx, new PrivateKeyMethod(engineMap, method));
        } finally {
            writerLock.unlock();
        }
    }
4608
function isPrivateBrowsingMode () {
  try {
    localStorage.setItem(TEST_KEY, '1')
    localStorage.removeItem(TEST_KEY)
    return false
  } catch (error) {
    return true
  }
}