text:
//
//  KTUser.m
//  keytechFoundation
//
//  Created by Thorsten Claus on 30.07.13.
//  Copyright (c) 2017 Claus-Software. All rights reserved.
//

#import "KTUser.h"
#import "KTManager.h"
#import "KTNotifications.h"

#import <RestKit/RestKit.h>

@implementation KTUser {
@private
    BOOL _isGroupListLoaded; // Is loaded
    BOOL _isGroupListLoading; // During al loading process
}

static KTUser* _currentUser;

@synthesize isLoaded = _isLoaded;
@synthesize isLoading = _isLoading;

@synthesize userEmail = _userEmail;

@synthesize userKey = _userKey;
@synthesize userLongName = _userLongName;
@synthesize userLanguage =_userLanguage;
@synthesize groupList = _groupList;

static RKObjectMapping* _mapping = nil; /** contains the mapping*/
static RKObjectManager *_usedManager;

-(instancetype)init {
    self = [super init];
    if (self) {

        _groupList = [[NSMutableArray alloc]init];

        _userLanguage = @"";
        _userEmail = @"";
        _isActive = NO;
        _isAdmin = NO;
        _isSuperuser = NO;
        _userLanguage = @"";
        _userLongName = @"";

    }
    return self;
}

+(RKObjectMapping*)mappingWithManager:(RKObjectManager*)manager {

    if (_usedManager !=manager){
        _usedManager = manager;

        _mapping = [RKObjectMapping mappingForClass:[KTUser class]];
        [_mapping addAttributeMappingsFromDictionary:@{@"IsActive":@"isActive",
                                                       @"IsAdmin":@"isAdmin",
                                                       @"IsSuperuser":@"isSuperuser",
                                                       @"KeyName":@"userKey",
                                                       @"Language":@"userLanguage",
                                                       @"LanguageID":@"userLanguageID",
                                                       @"LongName":@"userLongName",
                                                       @"eMail":@"userMail"
                                                       }];
        RKResponseDescriptor *userResponse = [RKResponseDescriptor responseDescriptorWithMapping:_mapping
                                                                                method:RKRequestMethodAny
                                                                                pathPattern:nil keyPath:@"MembersList"
                                                                                statusCodes:RKStatusCodeIndexSetForClass(RKStatusCodeClassSuccessful)];

        // Path Argument
        [manager.router.routeSet addRoute:[RKRoute
                                           routeWithClass:[KTUser class]
                                           pathPattern:@"user/:userKey"
                                           method:RKRequestMethodGET]] ;

        [_usedManager addResponseDescriptor:userResponse];
        // [_usedManager addResponseDescriptor:userResponseClientError];
    }

    return _mapping;
}

+(void)loadUserWithKey:(NSString*) username
               success:(void (^)(KTUser *user))success
               failure:(void (^)(NSError *error))failure {

    KTUser *user = [[KTUser alloc]init] ;
    user.userKey = username;

    [user reload:success failure:failure];
}

+(KTUser*)loadUserWithKey:(NSString*) username {
    KTUser *user = [[KTUser alloc]init] ;
    user.userKey = username;

    [user reload];

    return user;
}

// Starts reloading the user. The userkey is needed.
-(void)reload {
    if (!_isLoading) {

        [self reload:nil failure:nil];
        [self waitForData];
    }
}

-(void)reload:(void (^)(KTUser*))success
      failure:(void (^)(NSError*))failure {

    RKObjectManager *manager = [RKObjectManager sharedManager];
    [KTUser mappingWithManager:manager];

    __weak KTUser *userObject = self;

    _isLoaded = NO;
    _isLoading = YES;

    [manager getObject:userObject path:nil parameters:nil
               success:^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {
                   KTUser *user = mappingResult.firstObject;

                   userObject.userEmail =user.userEmail;
                   userObject.userLanguage = user.userLanguage;
                   userObject.userLongName = user.userLongName;
                   userObject.userLanguageID = user.userLanguageID;
                   userObject.isActive = user.isActive;

                   self->_isLoaded = YES;
                   self->_isLoading = NO;
                   if (success) {
                       success(self);
                   }

               } failure:^(RKObjectRequestOperation *operation, NSError *error) {
                   NSError *transcodedError = [KTManager translateErrorFromResponse:operation.HTTPRequestOperation.response error:error];

                   self->_latestLocalizedServerMessage = transcodedError.localizedDescription;

                   self->_isLoaded = NO;
                   self->_isLoading = NO;

                   if (failure) {
                       failure(transcodedError);
                   }
               }];
}

// Returns the unique indetifier key
-(NSString*)identifier {
    return _userKey;
}

-(void)refreshGroups {
    _isGroupListLoaded = NO;
    [_groupList removeAllObjects];
}

// Lazy loads the grouos list
-(NSMutableArray*)groupList{
    if (_isGroupListLoaded & !_isGroupListLoading){
        return _groupList;
    }else{
        _isGroupListLoading = YES;
        //TODO: Load Users groups
        return _groupList;
    }
}

-(void)loadFavoritesSuccess:(void (^)(NSArray <KTTargetLink*> *))success
                    failure:(void (^)(NSError *))failure{

    RKObjectManager *manager = [RKObjectManager sharedManager];
    [KTTargetLink mappingWithManager:manager];

    NSString *resourcePath = [NSString stringWithFormat:@"user/%@/favorites",self.userKey];

    [manager getObjectsAtPath:resourcePath parameters:nil
                      success:^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {

                          self.favorites = mappingResult.array;

                          if (success) {
                              success(mappingResult.array);
                          }

                      } failure:^(RKObjectRequestOperation *operation, NSError *error) {
                          //TODO: prepare the error
                          if (failure) {
                              failure(error);
                          }
                      }];
}

-(void)loadQueriesSuccess:(void (^)(NSArray <KTTargetLink*> *)) success
                  failure:(void (^)(NSError *)) failure {

    [self loadQueriesWithParameters:nil success:success failure:failure];
}

-(void)loadQueriesWithParameters:(NSDictionary*) parameters success:(void (^)(NSArray <KTTargetLink*> *)) success
                  failure:(void (^)(NSError *)) failure {

    RKObjectManager *manager = [RKObjectManager sharedManager];
    [KTTargetLink mappingWithManager:manager];

    NSString *resourcePath = [NSString stringWithFormat:@"user/%@/queries",self.userKey];

    [manager getObjectsAtPath:resourcePath parameters:parameters
                      success:^(RKObjectRequestOperation *operation, RKMappingResult *mappingResult) {

                          self.queries = mappingResult.array;

                          if (success) {
                              success(mappingResult.array);
                          }

                      } failure:^(RKObjectRequestOperation *operation, NSError *error) {
                          //TODO: prepaire the error
                          if (failure) {
                              failure(error);
                          }
                      }];
}

+(void)loadCurrentUser:(void (^)(KTUser *user)) success
               failure:(void (^)(NSError *error)) failure {

    [KTUser loadUserWithKey:[KTManager sharedManager].username
                    success:^(KTUser *user) {

                        _currentUser = user;

                        if ((success)) {
                            success(user);
                        }
                    } failure:^(NSError *error) {
                        if (failure) {
                            failure(error);
                        }
                    }];
}

+(instancetype)currentUser{
    return _currentUser;
}

-(void)waitForData{
    // Wait
#define POLL_INTERVAL 0.2 // 200ms
#define N_SEC_TO_POLL 30.0 // poll for 30s
#define MAX_POLL_COUNT N_SEC_TO_POLL / POLL_INTERVAL

    if (!_isLoading && !_isLoaded) {
        // Load was not triggered
        return;
    }

    NSUInteger pollCount = 0;
    while (_isLoading && (pollCount < MAX_POLL_COUNT)) {
        NSDate* untilDate = [NSDate dateWithTimeIntervalSinceNow:POLL_INTERVAL];
        [[NSRunLoop currentRunLoop] runUntilDate:untilDate];
        pollCount++;
    }

    if (pollCount== MAX_POLL_COUNT) {
        NSLog(@"Loading Error in KTUser!");
    }

}

-(NSString *)debugDescription {
    return self.userKey;
}

@end


text:
using System;
using System.Collections.Generic;
using Vostok.Commons.Collections;

namespace Vostok.Metrics
{
    public class MetricConfiguration : IMetricConfiguration
    {
        public IMetricEventReporter Reporter { get; set; }
        public ISet<string> ContextFieldsWhitelist { get; } = new ConcurrentSet<string>(StringComparer.Ordinal);
    }
}

redpajama_set_name: RedPajamaGithub


text:
@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    Singleton *single1 = [Singleton shareInstance];
    Singleton *single2 = [Singleton shareInstance];
    Singleton *single3 = [[Singleton alloc] init];
    Singleton *single4 = [Singleton new];

    NSLog(@"第一个对象的地址%p",single1);
    NSLog(@"第二个对象的地址%p",single2);
    NSLog(@"第三个对象的地址%p",single3);
    NSLog(@"第四个对象的地址%p",single4);
}

@end


text:
require 'test_helper'

class EmployeesControllerTest < ActionDispatch::IntegrationTest
  setup do
    @employee = employees(:one)
  end

  test "should get index" do
    get employees_url
    assert_response :success
  end

  test "should get new" do
    get new_employee_url
    assert_response :success
  end

  test "should create employee" do
    assert_difference('Employee.count') do
      post employees_url, params: { employee: { Name: @employee.Name, email: @employee.email, employee_code: @employee.employee_code, experience: @employee.experience, mobile_no: @employee.mobile_no } }
    end

    assert_redirected_to employee_url(Employee.last)
  end

  test "should show employee" do
    get employee_url(@employee)
    assert_response :success
  end

  test "should get edit" do
    get edit_employee_url(@employee)
    assert_response :success
  end

  test "should update employee" do
    patch employee_url(@employee), params: { employee: { Name: @employee.Name, email: @employee.email, employee_code: @employee.employee_code, experience: @employee.experience, mobile_no: @employee.mobile_no } }
    assert_redirected_to employee_url(@employee)
  end

  test "should destroy employee" do
    assert_difference('Employee.count', -1) do
      delete employee_url(@employee)
    end

    assert_redirected_to employees_url
  end
end


text:
class FilePath;

namespace base {

// Class for monitoring various system-related subsystems
// such as power management, network status, etc.
// TODO(mbelshe):  Add support beyond just power management.
class BASE_EXPORT SystemMonitor {
 public:
  // Normalized list of power events.
  enum PowerEvent {
    POWER_STATE_EVENT,  // The Power status of the system has changed.
    SUSPEND_EVENT,      // The system is being suspended.
    RESUME_EVENT        // The system is being resumed.
  };

  typedef unsigned int DeviceIdType;

  // Create SystemMonitor. Only one SystemMonitor instance per application
  // is allowed.
  SystemMonitor();
  ~SystemMonitor();

  // Get the application-wide SystemMonitor (if not present, returns NULL).
  static SystemMonitor* Get();

#if defined(OS_MACOSX)
  // Allocate system resources needed by the SystemMonitor class.
  //
  // This function must be called before instantiating an instance of the class
  // and before the Sandbox is initialized.
  static void AllocateSystemIOPorts();
#endif

  //
  // Power-related APIs
  //

  // Is the computer currently on battery power.
  // Can be called on any thread.
  bool BatteryPower() const {
    // Using a lock here is not necessary for just a bool.
    return battery_in_use_;
  }

  // Callbacks will be called on the thread which creates the SystemMonitor.
  // During the callback, Add/RemoveObserver will block until the callbacks
  // are finished. Observers should implement quick callback functions; if
  // lengthy operations are needed, the observer should take care to invoke
  // the operation on an appropriate thread.
  class BASE_EXPORT PowerObserver {
   public:
    // Notification of a change in power status of the computer, such
    // as from switching between battery and A/C power.
    virtual void OnPowerStateChange(bool on_battery_power) {}

    // Notification that the system is suspending.
    virtual void OnSuspend() {}

    // Notification that the system is resuming.
    virtual void OnResume() {}

   protected:
    virtual ~PowerObserver() {}
  };

  class BASE_EXPORT DevicesChangedObserver {
   public:
    // Notification that the devices connected to the system have changed.
    // This is only implemented on Windows currently.
    virtual void OnDevicesChanged() {}

    // When a media device is attached or detached, one of these two events
    // is triggered.
    // TODO(vandebo) Pass an appropriate device identifier or way to interact
    // with the devices instead of FilePath.
    virtual void OnMediaDeviceAttached(const DeviceIdType& id,
                                       const std::string& name,
                                       const FilePath& path) {}

    virtual void OnMediaDeviceDetached(const DeviceIdType& id) {}

   protected:
    virtual ~DevicesChangedObserver() {}
  };

  // Add a new observer.
  // Can be called from any thread.
  // Must not be called from within a notification callback.
  void AddPowerObserver(PowerObserver* obs);
  void AddDevicesChangedObserver(DevicesChangedObserver* obs);

  // Remove an existing observer.
  // Can be called from any thread.
  // Must not be called from within a notification callback.
  void RemovePowerObserver(PowerObserver* obs);
  void RemoveDevicesChangedObserver(DevicesChangedObserver* obs);

#if defined(OS_WIN)
  // Windows-specific handling of a WM_POWERBROADCAST message.
  // Embedders of this API should hook their top-level window
  // message loop and forward WM_POWERBROADCAST through this call.
  void ProcessWmPowerBroadcastMessage(int event_id);
#endif

  // Cross-platform handling of a power event.
  void ProcessPowerMessage(PowerEvent event_id);

  // Cross-platform handling of a device change event.
  void ProcessDevicesChanged();
  void ProcessMediaDeviceAttached(const DeviceIdType& id,
                                  const std::string& name,
                                  const FilePath& path);
  void ProcessMediaDeviceDetached(const DeviceIdType& id);

 private:
#if defined(OS_MACOSX)
  void PlatformInit();
  void PlatformDestroy();
#endif

  // Platform-specific method to check whether the system is currently
  // running on battery power.  Returns true if running on batteries,
  // false otherwise.
  bool IsBatteryPower();

  // Checks the battery status and notifies observers if the battery
  // status has changed.
  void BatteryCheck();

  // Functions to trigger notifications.
  void NotifyDevicesChanged();
  void NotifyMediaDeviceAttached(const DeviceIdType& id,
                                 const std::string& name,
                                 const FilePath& path);
  void NotifyMediaDeviceDetached(const DeviceIdType& id);
  void NotifyPowerStateChange();
  void NotifySuspend();
  void NotifyResume();

  scoped_refptr<ObserverListThreadSafe<PowerObserver> > power_observer_list_;
  scoped_refptr<ObserverListThreadSafe<DevicesChangedObserver> >
      devices_changed_observer_list_;
  bool battery_in_use_;
  bool suspended_;

#if defined(ENABLE_BATTERY_MONITORING)
  base::OneShotTimer<SystemMonitor> delayed_battery_check_;
#endif

  DISALLOW_COPY_AND_ASSIGN(SystemMonitor);
};

}  // namespace base

#endif  // BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_


text:
namespace obe::Time
{
    void Chronometer::start()
    {
        m_start = epoch();
        m_started = true;
    }

    bool Chronometer::started() const {
        return m_started;
    }
    void Chronometer::stop()
    {
        m_started = false;
    }

    void Chronometer::reset()
    {
        m_start = epoch();
    }

    TimeUnit Chronometer::getTime() const
    {
        if (m_started)
            return epoch() - m_start;
        return 0;
    }

    void Chronometer::setLimit(const TimeUnit limit)
    {
        m_limit = limit;
    }

    TimeUnit Chronometer::getLimit() const
    {
        return m_limit;
    }

    bool Chronometer::over() const
    {
        return m_started && this->getTime() > m_limit;
    }
} // namespace obe::Time


text:
"""
French-language mappings for language-dependent features of
reStructuredText.
"""

__docformat__ = 'reStructuredText'

directives = {
      u'attention': 'attention',
      u'pr\u00E9caution': 'caution',
      u'danger': 'danger',
      u'erreur': 'error',
      u'conseil': 'hint',
      u'important': 'important',
      u'note': 'note',
      u'astuce': 'tip',
      u'avertissement': 'warning',
      u'admonition': 'admonition',
      u'encadr\u00E9': 'sidebar',
      u'sujet': 'topic',
      u'bloc-textuel': 'line-block',
      u'bloc-interpr\u00E9t\u00E9': 'parsed-literal',
      u'code-interpr\u00E9t\u00E9': 'parsed-literal',
      u'intertitre': 'rubric',
      u'exergue': 'epigraph',
      u'\u00E9pigraphe': 'epigraph',
      u'chapeau': 'highlights',
      u'accroche': 'pull-quote',
      u'compound (translation required)': 'compound',
      u'container (translation required)': 'container',
      #u'questions': 'questions',
      #u'qr': 'questions',
      #u'faq': 'questions',
      u'tableau': 'table',
      u'csv-table (translation required)': 'csv-table',
      u'list-table (translation required)': 'list-table',
      u'm\u00E9ta': 'meta',
      'math (translation required)': 'math',
      #u'imagemap (translation required)': 'imagemap',
      u'image': 'image',
      u'figure': 'figure',
      u'inclure': 'include',
      u'brut': 'raw',
      u'remplacer': 'replace',
      u'remplace': 'replace',
      u'unicode': 'unicode',
      u'date': 'date',
      u'classe': 'class',
      u'role (translation required)': 'role',
      u'default-role (translation required)': 'default-role',
      u'titre (translation required)': 'title',
      u'sommaire': 'contents',
      u'table-des-mati\u00E8res': 'contents',
      u'sectnum': 'sectnum',
      u'section-num\u00E9rot\u00E9e': 'sectnum',
      u'liens': 'target-notes',
      u'header (translation required)': 'header',
      u'footer (translation required)': 'footer',
      #u'footnotes (translation required)': 'footnotes',
      #u'citations (translation required)': 'citations',
      }
"""French name to registered (in directives/__init__.py) directive name
mapping."""

roles = {
      u'abr\u00E9viation': 'abbreviation',
      u'acronyme': 'acronym',
      u'sigle': 'acronym',
      u'index': 'index',
      u'indice': 'subscript',
      u'ind': 'subscript',
      u'exposant': 'superscript',
      u'exp': 'superscript',
      u'titre-r\u00E9f\u00E9rence': 'title-reference',
      u'titre': 'title-reference',
      u'pep-r\u00E9f\u00E9rence': 'pep-reference',
      u'rfc-r\u00E9f\u00E9rence': 'rfc-reference',
      u'emphase': 'emphasis',
      u'fort': 'strong',
      u'litt\u00E9ral': 'literal',
    'math (translation required)': 'math',
      u'nomm\u00E9e-r\u00E9f\u00E9rence': 'named-reference',
      u'anonyme-r\u00E9f\u00E9rence': 'anonymous-reference',
      u'note-r\u00E9f\u00E9rence': 'footnote-reference',
      u'citation-r\u00E9f\u00E9rence': 'citation-reference',
      u'substitution-r\u00E9f\u00E9rence': 'substitution-reference',
      u'lien': 'target',
      u'uri-r\u00E9f\u00E9rence': 'uri-reference',
      u'brut': 'raw',}
"""Mapping of French role names to canonical role names for interpreted text.
"""


text:
<ion-side-menus enable-menu-with-back-views="false">
    <ion-side-menu-content>
        <ion-nav-bar class="bar-stable">
            <ion-nav-back-button>
                Înapoi
            </ion-nav-back-button>

            <ion-nav-buttons side="left">
                <button class="button button-icon button-clear ion-navicon" menu-toggle="left">
        </button>
            </ion-nav-buttons>
        </ion-nav-bar>
        <ion-nav-view name="menuContent"></ion-nav-view>
    </ion-side-menu-content>

    <ion-side-menu side="left">

        <ion-content>

Constantin Brâncuși

 Paris, Franța

            <ion-list>
                <ion-item class="" menu-close href="#/app/map">
                     Hartă
                </ion-item>
                <ion-item class="" menu-close href="#/app/news">
                     Știri
                </ion-item>
                <ion-item class="" menu-close href="#/app/settings">
                     Setări
                </ion-item>
            </ion-list>
        </ion-content>
    </ion-side-menu>
</ion-side-menus>


text:
PREFIX=/usr/local
VIMDIR=$(PREFIX)/share/vim
BINDIR=$(PREFIX)/bin
APPDATADIR=$(PREFIX)/share/appdata

VERSION=1.9.0
DATE=$(shell date +%Y%m%d)
COMMIT_COUNT=$(shell git log --oneline | wc -l)
ABBREV_HASH=$(shell git rev-parse --short=7 HEAD)

SNAPSHOTNAME=vim-latex-$(VERSION)-$(DATE).$(COMMIT_COUNT)-git$(ABBREV_HASH)

snapshot:
	git archive --prefix '$(SNAPSHOTNAME)/' HEAD | gzip > '$(SNAPSHOTNAME).tar.gz'

install:
	install -d '$(DESTDIR)$(VIMDIR)/doc'
	install -m 0644 doc/*.txt '$(DESTDIR)$(VIMDIR)/doc'

	install -d '$(DESTDIR)$(VIMDIR)'
	cp -R compiler ftplugin indent plugin '$(DESTDIR)$(VIMDIR)'
	chmod 0755 '$(DESTDIR)$(VIMDIR)/ftplugin/latex-suite/outline.py'

	install -d '$(DESTDIR)$(BINDIR)'
	install latextags ltags '$(DESTDIR)$(BINDIR)'

	install -d '$(DESTDIR)$(APPDATADIR)'
	install -m 644 vim-latex.metainfo.xml '$(DESTDIR)$(APPDATADIR)'

upload: snapshot
	scp '$(SNAPSHOTNAME).tar.gz' frs.sourceforge.net:/home/frs/project/v/vi/vim-latex/snapshots

.PHONY: install upload


text:
from django import template
register = template.Library()

@register.filter(name='count_professors')
def count_professors(instance, university):
    return instance.count(university)


text:
function makePoseGraph( nodes::Dict,
                        anchors::Array{Int,1},
                        route::Array{Int,1},
                        poses::Vector{Pose2D},
                        filename::String="posegraph.txt" )

    anchor_sets = Array{Int,1}[]
    push!(anchor_sets,anchors)

    filenames = String[]
    push!(filenames,filename)

    return makePoseGraph(nodes,anchor_sets,route,poses,filenames)
end

# Generate pose graphs from a single route and set of poses and loop-closures to multiple anchor sets
# Array of filenames should align with array of anchor_sets
function makePoseGraph( nodes::Dict,
                        anchor_sets::Array{Array{Int,1},1},
                        route::Array{Int,1},
                        poses::Vector{Pose2D},
                        filenames::Array{String,1} )

    odom_inf = diagm([5,5,50])
    loop_inf = diagm([50,50,100])
    odom_cov = inv(odom_inf)
    loop_cov = inv(loop_inf)

    odometry = getPoseOdometry(route,poses,odom_cov)
    meas = getMeasurements(route,poses,anchor_sets,odometry,loop_cov)

    for k = 1:length(anchor_sets)
        writeMeasurements(filenames[k],meas[k])
    end

    return nothing
end

function makePoseGraph( nodes::Dict,
                        anchor_sets::Array{Array{Int,1},1},
                        route::Array{Int,1},
                        poses::Vector{Pose2D},
                        odometry::Vector{BetweenFactor},
                        filenames::Array{String,1} )

    loop_inf = diagm([50,50,100])
    loop_cov = inv(loop_inf)

    meas = getMeasurements(route,poses,anchor_sets,odometry,loop_cov)

    for k = 1:length(anchor_sets)
        writeMeasurements(filenames[k],meas[k])
    end

    return nothing
end

function makePoseGraph( anchor_sets::Array{Array{Int,1},1},
                        route::Vector{Int},
                        poses::Vector{Pose2D},
                        odometry_factors::Vector{BetweenFactor},
                        loop_factors::Dict{(Int,Int),BetweenFactor},
                        prior_meas::Dict{Int,Meas2D},
                        prior_inf::Inf2D,
                        filenames::Vector{String} )

    meas = getMeasurements(route,poses,anchor_sets,odometry_factors,loop_factors,prior_meas,prior_inf)

    for k = 1:length(anchor_sets)
        writeMeasurements(filenames[k],meas[k])
    end

    return nothing
end


text:
import scala.collection.BuildFrom

trait Base[+A] extends Iterable[A] {
  def add[B >: A, That](that: Iterable[B])(implicit bf: BuildFrom[Base[A], B, That]): That = {
    val b = bf(this)
    b ++= this
    b ++= that
    b.result
  }

}

abstract class Derived[@specialized +A] extends Base[A] {
  override def add[B >: A, That](that: Iterable[B])(implicit bf: BuildFrom[Base[A], B, That]): That = {
    val b = bf(this)
    super.add[B, That](that)
  }
}


text:
package com.fangxu.dota2helper.util;

import android.content.res.Resources;
import android.support.design.widget.Snackbar;
import android.view.View;
import android.widget.TextView;

import com.fangxu.dota2helper.MyApp;
import com.fangxu.dota2helper.R;

/**
 * Created by dear33 on 2016/8/6.
 */
public class SnackbarUtil {
    public static void showSnack(View view, int msgId) {
        Resources resources = MyApp.getContext().getResources();
        Snackbar sb = Snackbar.make(view, resources.getString(msgId), Snackbar.LENGTH_SHORT);
        ((TextView) sb.getView().findViewById(R.id.snackbar_text)).setTextColor(resources.getColor(R.color.white));
        sb.getView().setBackgroundColor(resources.getColor(R.color.color_primary));
        sb.show();
    }
}


text:
package glaze.client.handlers;

import glaze.client.Response;

/**
 * Implementation of {@link ErrorHandler} that croaks
 * {@link ErrorResponseException}s.
 *
 */
public class CroakErrorHandler implements ErrorHandler
{

   private static CroakErrorHandler instance;

   public static synchronized ErrorHandler instance()
   {
      if (instance == null) {
         instance = new CroakErrorHandler();
      }
      return instance;
   }

   @Override
   public void onError(Response response)
   {
      throw new ErrorResponseException(response);
   }

}


text:
AdSavvy Plugin for WordPress

Please enter your unique AdSavvy IDs below.

NOTE: Your unique AdSavvy IDs will be found in your AdSavvy account, under Settings in the AdSavvy Console

<form action="options.php" method="POST">

	<?php settings_fields('adsavvy_setting') ?>
	<?php do_settings_sections( 'wp_adsavvy' ) ?>

	<input type="submit" value="Update AdSavvy Settings" />
</form>


text:
package org.alfasoftware.morf.upgrade.db;

import static org.alfasoftware.morf.metadata.SchemaUtils.column;
import static org.alfasoftware.morf.metadata.SchemaUtils.table;

import java.util.Collection;
import java.util.List;

import org.alfasoftware.morf.metadata.DataType;
import org.alfasoftware.morf.metadata.SchemaUtils.TableBuilder;
import org.alfasoftware.morf.metadata.Table;
import org.alfasoftware.morf.upgrade.TableContribution;
import org.alfasoftware.morf.upgrade.UpgradeStep;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;

/**
 * Tables required by Morf to manage upgrades.
 *
 * @author Copyright (c) Alfa Financial Software 2017
 */
public class DatabaseUpgradeTableContribution implements TableContribution {
  /** Name of the table containing information on the upgrade steps applied within the app's database. */
  public static final String UPGRADE_AUDIT_NAME = "UpgradeAudit";

  /** Name of the table containing information on the views deployed within the app's database. */
  public static final String DEPLOYED_VIEWS_NAME = "DeployedViews";

  /**
   * @return The Table descriptor of UpgradeAudit
   */
  public static Table upgradeAuditTable() {
    return table(UPGRADE_AUDIT_NAME)
        .columns(
          column("upgradeUUID", DataType.STRING, 100).primaryKey(),
          column("description", DataType.STRING, 200).nullable(),
          column("appliedTime", DataType.DECIMAL, 14).nullable()
        );
  }

  /**
   * @return The Table descriptor of DeployedViews
   */
  public static TableBuilder deployedViewsTable() {
    return table(DEPLOYED_VIEWS_NAME)
        .columns(
          column("name", DataType.STRING, 30).primaryKey(),
          column("hash", DataType.STRING, 64)
        );
  }

  /**
   * @see org.alfasoftware.morf.upgrade.TableContribution#tables()
   */
  @Override
  public Collection<Table> tables() {
    return ImmutableList.<Table>of(
      deployedViewsTable(),
      upgradeAuditTable()
    );
  }

  /**
   * @see org.alfasoftware.morf.upgrade.TableContribution#schemaUpgradeClassses()
   */
  @Override
  public Collection<Class<? extends UpgradeStep>> schemaUpgradeClassses() {
    List<Class<? extends UpgradeStep>> result = Lists.newLinkedList();

    result.addAll(org.alfasoftware.morf.upgrade.db.v5_1_20.UpgradeSteps.LIST);
    result.addAll(org.alfasoftware.morf.upgrade.db.v5_1_22.UpgradeSteps.LIST);
    result.addAll(org.alfasoftware.morf.upgrade.upgrade.v5_3_25.UpgradeSteps.LIST);

    return ImmutableList.copyOf(result);
  }
}


text:
The code have one very simple application that runs a calculation to demonstrate diferrent in use pointer or value.

below calculator created by pointer:

```
package pointers

type Calculator struct{
	Memory int
}

func (calculator *Calculator) Sum(value int) {
	calculator.Memory = calculator.Memory + 100
}

func (calculator *Calculator) GetMemory() int {
	return calculator.Memory
}

func NewCalculatorPointer(initValue int) *Calculator{
	return &Calculator{
		Memory:initValue,
	}
}

```

 it meens when we call method Sum and GetMemory, we reference same memory pointer and get same value from attribute Memory:

 pointer_test.go

 ```
 func TestSumPointer(t *testing.T) {
	calculator := pointers.NewCalculatorPointer(100)
    calculator.Sum(100)
    value := calculator.GetMemory()
    fmt.Printf("value " , value)
    if value != 200{
        t.Fatal("calculator don't sum value")
    }
}
 ```

 test ouput:

 ```
 ?   	github.com/leocbs/go-scratchpad	[no test files]
=== RUN   TestSumPointer
value %!(EXTRA int=200)--- PASS: TestSumPointer (0.00s)

 ```

 Now, when we created calculator and return without pointer (&), go copy value to another pointer and don't use same pointer:

 ```
 func NewCalculatorValue(initValue int) Calculator{
	return Calculator{
		Memory:initValue,
	}
}

func (calculator Calculator) SumNoPointer(value int) {
	calculator.Memory = calculator.Memory + 100
}

func (calculator Calculator) GetMemoryNoPointer() int {
	return calculator.Memory
}
 ```

 and when we get memory value, it's continue 100:

 pointer_test.go:

 ```
 func TestSumPerValue(t *testing.T) {
	calculator := pointers.NewCalculatorValue(100)
    calculator.SumNoPointer(100)
    value := calculator.GetMemoryNoPointer()
    fmt.Printf("value " , value)
    if value != 100{
        t.Fatal("calculator sum value")
    }
}
 ```

 test ouput:

 ```
 === RUN   TestSumPerValue
value %!(EXTRA int=100)--- PASS: TestSumPerValue (0.00s)
 ```

 all test output printing memory pointer value

```
=== RUN   TestSumPointer
memory pointer: %s 0xc8200124b8
memory pointer: %s 0xc8200124b8
value %!(EXTRA int=200)--- PASS: TestSumPointer (0.00s)
=== RUN   TestSumPerValue
memory pointer: %s 0xc820012558
memory pointer: %s 0xc8200125b0
value %!(EXTRA int=100)--- PASS: TestSumPerValue (0.00s)
```

 To run this test, just clone and `make run`

 Now that we already know pointer behavior, read this [this](http://stackoverflow.com/questions/23542989/pointers-vs-values-in-parameters-and-return-values) question in stack over flow to learn when user pointer or value


text:
"""Contains the logic for `aq add desk`."""

from aquilon.exceptions_ import ArgumentError
from aquilon.aqdb.model import Desk, Room, Building
from aquilon.worker.broker import BrokerCommand  # pylint: disable=W0611
from aquilon.worker.dbwrappers.location import add_location

class CommandAddDesk(BrokerCommand):

    required_parameters = ["desk"]

    def render(self, session, desk, room, building, fullname, comments,
               **arguments):
        if room:
            dbparent = Room.get_unique(session, room, compel=True)
        elif building:
            dbparent = Building.get_unique(session, building, compel=True)
        else:  # pragma: no cover
            raise ArgumentError("Please specify either --room or --building.")

        add_location(session, Desk, desk, dbparent, fullname=fullname,
                     comments=comments)

        session.flush()

        return


text:
// Ideally, we would rely on platform support for parsing a cookie, since
// this would save us from any potential inconsistency. However, exposing
// platform cookie parsing logic would require quite a bit of additional
// plumbing, and at least some platforms lack support for parsing Cookie,
// which is in a format slightly different from Set-Cookie and is normally
// only required on the server side.

/**
 * @constructor
 */
WebInspector.CookieParser = function()
{
}

WebInspector.CookieParser.prototype = {
    get cookies()
    {
        return this._cookies;
    },

    parseCookie: function(cookieHeader)
    {
        if (!this._initialize(cookieHeader))
            return;

        for (var kv = this._extractKeyValue(); kv; kv = this._extractKeyValue()) {
            if (kv.key.charAt(0) === "$" && this._lastCookie)
                this._lastCookie.addAttribute(kv.key.slice(1), kv.value);
            else if (kv.key.toLowerCase() !== "$version" && typeof kv.value === "string")
                this._addCookie(kv, WebInspector.Cookie.Type.Request);
            this._advanceAndCheckCookieDelimiter();
        }
        this._flushCookie();
        return this._cookies;
    },

    parseSetCookie: function(setCookieHeader)
    {
        if (!this._initialize(setCookieHeader))
            return;
        for (var kv = this._extractKeyValue(); kv; kv = this._extractKeyValue()) {
            if (this._lastCookie)
                this._lastCookie.addAttribute(kv.key, kv.value);
            else
                this._addCookie(kv, WebInspector.Cookie.Type.Response);
            if (this._advanceAndCheckCookieDelimiter())
                this._flushCookie();
        }
        this._flushCookie();
        return this._cookies;
    },

    _initialize: function(headerValue)
    {
        this._input = headerValue;
        if (typeof headerValue !== "string")
            return false;
        this._cookies = [];
        this._lastCookie = null;
        this._originalInputLength = this._input.length;
        return true;
    },

    _flushCookie: function()
    {
        if (this._lastCookie)
            this._lastCookie.size = this._originalInputLength - this._input.length - this._lastCookiePosition;
        this._lastCookie = null;
    },

    _extractKeyValue: function()
    {
        if (!this._input || !this._input.length)
            return null;
        // Note: RFCs offer an option for quoted values that may contain commas and semicolons.
        // Many browsers/platforms do not support this, however (see http://webkit.org/b/16699
        // and http://crbug.com/12361). The logic below matches latest versions of IE, Firefox,
        // Chrome and Safari on some old platforms. The latest version of Safari supports quoted
        // cookie values, though.
        var keyValueMatch = /^[ \t]*([^\s=;]+)[ \t]*(?:=[ \t]*([^;\n]*))?/.exec(this._input);
        if (!keyValueMatch) {
            console.log("Failed parsing cookie header before: " + this._input);
            return null;
        }

        var result = {
            key: keyValueMatch[1],
            value: keyValueMatch[2] && keyValueMatch[2].trim(),
            position: this._originalInputLength - this._input.length
        };
        this._input = this._input.slice(keyValueMatch[0].length);
        return result;
    },

    _advanceAndCheckCookieDelimiter: function()
    {
        var match = /^\s*[\n;]\s*/.exec(this._input);
        if (!match)
            return false;
        this._input = this._input.slice(match[0].length);
        return match[0].match("\n") !== null;
    },

    _addCookie: function(keyValue, type)
    {
        if (this._lastCookie)
            this._lastCookie.size = keyValue.position - this._lastCookiePosition;
        // Mozilla bug 169091: Mozilla, IE and Chrome treat single token (w/o "=") as
        // specifying a value for a cookie with empty name.
        this._lastCookie = keyValue.value ? new WebInspector.Cookie(keyValue.key, keyValue.value, type) :
            new WebInspector.Cookie("", keyValue.key, type);
        this._lastCookiePosition = keyValue.position;
        this._cookies.push(this._lastCookie);
    }
};

WebInspector.CookieParser.parseCookie = function(header)
{
    return (new WebInspector.CookieParser()).parseCookie(header);
}

WebInspector.CookieParser.parseSetCookie = function(header)
{
    return (new WebInspector.CookieParser()).parseSetCookie(header);
}

/**
 * @constructor
 */
WebInspector.Cookie = function(name, value, type)
{
    this.name = name;
    this.value = value;
    this.type = type;
    this._attributes = {};
}

WebInspector.Cookie.prototype = {
    get httpOnly()
    {
        return "httponly" in this._attributes;
    },

    get secure()
    {
        return "secure" in this._attributes;
    },

    get session()
    {
        // RFC 2965 suggests using Discard attribute to mark session cookies, but this does not seem to be widely used.
        // Check for absence of explicity max-age or expiry date instead.
        return  !("expries" in this._attributes || "max-age" in this._attributes);
    },

    get path()
    {
        return this._attributes.path;
    },

    get domain()
    {
        return this._attributes.domain;
    },

    expires: function(requestDate)
    {
        return this._attributes.expires ? new Date(this._attributes.expires) :
            (this._attributes["max-age"] ? new Date(requestDate.getTime() + 1000 * this._attributes["max-age"]) : null);
    },

    get attributes()
    {
        return this._attributes;
    },

    addAttribute: function(key, value)
    {
        this._attributes[key.toLowerCase()] = value;
    }
}

WebInspector.Cookie.Type = {
    Request: 0,
    Response: 1
};


text: <!DOCTYPE HTML>


text:
import { AfterContentInit, ElementRef, QueryList, Renderer2 } from '@angular/core';
import { MdLine } from '@angular/material/core';
import { CanDisableRipple } from '@angular/material/core';
/** @docs-private */
export declare class MdListBase {
}
export declare const _MdListMixinBase: (new (...args: any[]) => CanDisableRipple) & typeof MdListBase;
/** @docs-private */
export declare class MdListItemBase {
}
export declare const _MdListItemMixinBase: (new (...args: any[]) => CanDisableRipple) & typeof MdListItemBase;
/** Divider between items within a list. */
export declare class MdListDivider {
}
/** A Material Design list component. */
export declare class MdList extends _MdListMixinBase implements CanDisableRipple {
}
/**
 * Directive whose purpose is to add the mat- CSS styling to this selector.
 * @docs-private
 */
export declare class MdListCssMatStyler {
}
/**
 * Directive whose purpose is to add the mat- CSS styling to this selector.
 * @docs-private
 */
export declare class MdNavListCssMatStyler {
}
/**
 * Directive whose purpose is to add the mat- CSS styling to this selector.
 * @docs-private
 */
export declare class MdDividerCssMatStyler {
}
/**
 * Directive whose purpose is to add the mat- CSS styling to this selector.
 * @docs-private
 */
export declare class MdListAvatarCssMatStyler {
}
/**
 * Directive whose purpose is to add the mat- CSS styling to this selector.
 * @docs-private
 */
export declare class MdListIconCssMatStyler {
}
/**
 * Directive whose purpose is to add the mat- CSS styling to this selector.
 * @docs-private
 */
export declare class MdListSubheaderCssMatStyler {
}
/** An item within a Material Design list. */
export declare class MdListItem extends _MdListItemMixinBase implements AfterContentInit, CanDisableRipple {
    private _renderer;
    private _element;
    private _list;
    private _lineSetter;
    private _isNavList;
    _lines: QueryList<MdLine>;
    _hasAvatar: MdListAvatarCssMatStyler;
    constructor(_renderer: Renderer2, _element: ElementRef, _list: MdList, navList: MdNavListCssMatStyler);
    ngAfterContentInit(): void;
    /** Whether this list item should show a ripple effect when clicked.  */
    _isRippleDisabled(): boolean;
    _handleFocus(): void;
    _handleBlur(): void;
    /** Retrieves the DOM element of the component host. */
    _getHostElement(): HTMLElement;
}


text:
<!DOCTYPE html>

            Katana CLI Data Editor

<input style="color:rgb(214, 48, 48)" type="button" class='btn btn-default' value="Create New CLI Data File"
       ng-click="navigateToCreateTestDataFilePage()"/>

     {{base_dir}}

         >
         {{dir}}

		 Directories

                 Go Back

            {{folder}}

		 File Name

            {{file}}


text:
import { Injectable } from '@angular/core';
import { Http, Response, Headers, RequestOptions } from '@angular/http';
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/catch';

@Injectable()
export class AllServicesService {
	// // All the API URLs
	private blogUrl = 'http://localhost:5000/api/blog';
	private appUrl = 'http://localhost:5000/api/app';
	private dataUrl = 'http://localhost:5000/api/data';
	private miscUrl = 'http://localhost:5000/api/misc';
	private homeUrl = 'http://localhost:5000/api/recent';
	private searchResultsAndURL = 'http://localhost:5000/api/s_and?term=';
	private searchResultsOrURL = 'http://localhost:5000/api/s_or?term=';
	// private blogUrl = 'http://jasonvila.com:5000/api/blog';
	// private appUrl = 'http://jasonvila.com:5000/api/app';
	// private dataUrl = 'http://jasonvila.com:5000/api/data';
	// private miscUrl = 'http://jasonvila.com:5000/api/misc';
	// private homeUrl = 'http://jasonvila.com:5000/api/recent';
	// private testOutputUrl = 'api/test';
	// private searchResultsAndURL = 'http://jasonvila.com:5000/api/s_and?term=';
	// private searchResultsOrURL = 'http://jasonvila.com:5000/api/s_or?term=';

	constructor(private http: Http) {}

	getAllBlogs(): Observable<any>{
		return this.http.get(this.blogUrl)
								 .map(this.extractData)
								 .catch(this.handleError);
	}

	getBlog(id: number): Observable<any> {
	 	var singleBlogUrl = this.blogUrl + "/" + id;
	 	return this.http.get(singleBlogUrl)
	 			   .map(this.extractData)
	 			   .catch(this.handleError);
	}

	getAllApps(): Observable<any>{
		return this.http.get(this.appUrl)
								 .map(this.extractData)
								 .catch(this.handleError);
	}

	getApp(id: number): Observable<any> {
	 	var singleAppUrl = this.appUrl + "/" + id;
	 	return this.http.get(singleAppUrl)
	 			   .map(this.extractData)
	 			   .catch(this.handleError);
	}

	getAllData(): Observable<any>{
		return this.http.get(this.dataUrl)
								 .map(this.extractData)
								 .catch(this.handleError);
	}

	getData(id: number): Observable<any> {
	 	var singleDataUrl = this.dataUrl + "/" + id;
	 	return this.http.get(singleDataUrl)
	 			   .map(this.extractData)
	 			   .catch(this.handleError);
	}

	getAllMisc(): Observable<any>{
		return this.http.get(this.miscUrl)
								 .map(this.extractData)
								 .catch(this.handleError);
	}

	getMisc(id: number): Observable<any> {
	 	var singleMiscUrl = this.miscUrl + "/" + id;
	 	return this.http.get(singleMiscUrl)
	 			   .map(this.extractData)
	 			   .catch(this.handleError);
	}

	getAllHome(): Observable<any>{
		return this.http.get(this.homeUrl)
								 .map(this.extractData)
								 .catch(this.handleError);
	}

	// getTestOutput(): Observable<any> {
	// 	return this.http.get(this.testOutputUrl)
	// 			   .map(this.extractTestData)
	// 			   .catch(this.handleError);
	// }

	getAllSearchResults(str: string, searchType : string): Observable<any> {
	 	var replaced : string;
	 	if(str != null){
	 		replaced = str.replace('+','%20');
	 	}
	 	var searchURL : string;
	 	if(searchType === "AND"){
	 		searchURL = this.searchResultsAndURL + replaced;
	 		console.log("searchUrl: " + searchURL)
	 		return this.http.get(searchURL)
	 				   .map(this.extractData)
	 				   .catch(this.handleError);
	 	}
	 	else{
	 		searchURL = this.searchResultsOrURL + replaced;
	 		return this.http.get(searchURL)
	 					   .map(this.extractData)
	 					   .catch(this.handleError);
	 	}
	}

	private extractData(res: Response) {
	 	let body = res.json();
	 	return body.objects || body || {};
	}

	// private extractTestData(res: Response) {
	// 	return res.text();
	// }

	private handleError (error: Response | any) {
	 	let errMsg: string;
	     if (error instanceof Response) {
	       const body = error.json() || '';
	       const err = body.error || JSON.stringify(body);
	       errMsg = `${error.status} - ${error.statusText || ''} ${err}`;
	     } else {
	       errMsg = error.message ? error.message : error.toString();
	     }
	     console.error(errMsg);
	     return Observable.throw(errMsg);
	 }
}


text:
<!DOCTYPE html>

	<title>Shaders Library</title>

0

	<canvas id="renderCanvas"></canvas>


text:
import * as Router from 'koa-router'
import { Observable } from 'rxjs/Rx'
import { projectCtrl } from './project/project.ctrl'
import { interfaceCtrl } from './project/interface.ctrl'
import { memberCtrl } from './team/member.ctrl'
import { groupCtrl } from './team/group.ctrl'

let router = new Router({
  prefix: '/api'
})

const handle = (ctx: any, ob: Observable<any>): Promise<void> => ob.catch((e: any) => {
  ctx.body = {
    errCode: 110,
    errMsg: e.message || '操作失败'
  }
  console.error(e)
  return Observable.of()
})
  .do((res: any) => ctx.body = Object.assign({
    errCode: 0
  }, res))
  .toPromise()

router
// 项目
  .get('/project', (ctx:any) => handle(ctx, projectCtrl.get()))
  .get('/project/:id', (ctx:any) => handle(ctx, projectCtrl.getById(ctx.params.id)))
  .post('/project', (ctx:any) => handle(ctx, projectCtrl.post(ctx.request.body)))
  .put('/project/:id', (ctx:any) => handle(ctx, projectCtrl.put(ctx.params.id, ctx.request.body)))
  .del('/project/:id', (ctx:any) => handle(ctx, projectCtrl.delete(ctx.params.id)))
  // 接口
  .get('/project/:pid/api', (ctx:any) => handle(ctx, interfaceCtrl.get(ctx.params.pid)))
  .get('/project/:pid/api/:id', (ctx:any) => handle(ctx, interfaceCtrl.getById(ctx.params.pid, ctx.params.id)))
  .get('/project/:pid/api/:id/version', (ctx:any) => handle(ctx, interfaceCtrl.getVersionById(ctx.params.iid)))
  .post('/project/:pid', (ctx:any) => handle(ctx, interfaceCtrl.post(ctx.params.id, ctx.request.body)))
  .put('/project/:pid/api/:id', (ctx:any) => handle(ctx, interfaceCtrl.put(ctx.params.pid, ctx.params.id, ctx.request.body)))
  .del('/project/:pid/api/:id', (ctx:any) => handle(ctx, interfaceCtrl.delete(ctx.param.pid, ctx.params.id)))
// 成员
  .get('/group', (ctx:any) => handle(ctx, groupCtrl.get()))
  .get('/role', (ctx:any) => handle(ctx, groupCtrl.getRole()))
  .get('/member', (ctx:any) => handle(ctx, memberCtrl.get()))
  .post('/member', (ctx:any) => handle(ctx, memberCtrl.post(ctx.request.body)))
  .post('/user/login', (ctx:any) => handle(ctx, memberCtrl.login(ctx.request.body.user, ctx.request.body.password)))

export default router.routes()


text:
package org.androidsummit.eventapp.model;

import com.parse.ParseClassName;
import com.parse.ParseObject;

import java.util.Date;

/**
 * Represents MySummitSession
 *
 */
@ParseClassName("MySummitSession")
public class MySummitSession extends ParseObject {

    private final String TAG = MySummitSession.class.getSimpleName();

    public static final String START_TIME = "MySummitSessionStartTime";

    public static final String SESSION_ID = "MySummitSessionId";

    public static final String SESSION = "MySummitSessionColumn";

    public MySummitSession() {
        //Required default constructor
    }

    public MySummitSession(Date startTime, SummitSession summitSession) {
        put(SESSION, summitSession);
        put(START_TIME, startTime);
        put(SESSION_ID, summitSession.getObjectId());
    }

    public SummitSession getSummitSession() {
        return (SummitSession) get(SESSION);
    }

    public void setSummitSession(SummitSession summitSession) {
        put(SESSION, summitSession);
        put(SESSION_ID, summitSession.getObjectId());
    }

    public Date getStartTime() {
        return (Date) get(START_TIME);
    }

    public void setStartTime(Date startTime) {
        put(START_TIME, startTime);
    }

    public String getSessionId() {
        return (String) get(SESSION_ID);
    }
}


text:
require File.join( File.dirname(__FILE__), '..', 'flix4r.rb' )

target_file = File.join(File.dirname(__FILE__), 'actors.xml')
list = File.new(target_file, 'w')
list.puts Netflix::Request.new(:url => 'http://api.netflix.com/catalog/titles/movies/60024073/cast').send