text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;
using Inkton.Nest.Model;
using Inkton.Nester.ViewModels;
using Inkton.Nester.Helpers;

namespace Inkton.Nester.Views
{
    public partial class AppAuditView : View
    {
        public AppAuditView(AppViewModel appViewModel)
        {
            InitializeComponent();

            AppViewModel = appViewModel;

            SetActivityMonotoring(ServiceActive,
                new List<Xamarin.Forms.View> {
                    ButtonCancel,
                    ButtonQuery
                });

            _activityIndicator = ServiceActive;

            ButtonQuery.Clicked += ButtonQuery_Clicked;
            ButtonCancel.Clicked += ButtonCancel_ClickedAsync;

            ResetTimeFilter();

            QueryAsync();
        }

        private void ResetTimeFilter()
        {
            AnalyzeDateUTC.Date = DateTime.Now.ToUniversalTime();
            StartTime.Time = new TimeSpan(0, 0, 0);
            EndTime.Time = new TimeSpan(23, 59, 59);

            AppViewModel.DeploymentViewModel.AppAudits.Clear();
        }

        private async void QueryAsync()
        {
            IsServiceActive = true;

            try
            {
                AppViewModel.DeploymentViewModel.AppAudits.Clear();

                if (TimeSpan.Compare(StartTime.Time, EndTime.Time) >= 0)
                {
                    await ErrorHandler.ExceptionAsync(this, "Start time must be earler than the end time");
                    return;
                }

                DateTime analyzeDateUTC = AnalyzeDateUTC.Date;

                // 2018-04-14T06:27:01+00:00
                Dictionary<string, string> filter = new Dictionary<string, string>();
                filter.Add("from", string.Format(
                    "{0:0000}-{1:00}-{2:00}T{3:00}:{4:00}:{5:00}",
                        analyzeDateUTC.Year, analyzeDateUTC.Month, analyzeDateUTC.Day,
                        StartTime.Time.Hours, StartTime.Time.Minutes, StartTime.Time.Seconds
                    ));
                filter.Add("to", string.Format(
                    "{0:0000}-{1:00}-{2:00}T{3:00}:{4:00}:{5:00}",
                        analyzeDateUTC.Year, analyzeDateUTC.Month, analyzeDateUTC.Day,
                        EndTime.Time.Hours, EndTime.Time.Minutes, EndTime.Time.Seconds
                    ));

                await AppViewModel.DeploymentViewModel.QueryAppAuditsAsync(filter);
            }
            catch (Exception ex)
            {
                await ErrorHandler.ExceptionAsync(this, ex);
            }

            IsServiceActive = false;
        }

        private void ButtonQuery_Clicked(object sender, EventArgs e)
        {
            QueryAsync();
        }

        public override void UpdateBindings()
        {
            base.UpdateBindings();

            BindingContext = AppViewModel.DeploymentViewModel;
        }

        private async void ButtonCancel_ClickedAsync(object sender, EventArgs e)
        {
            IsServiceActive = true;
            await MainView.UnstackViewAsync();
            IsServiceActive = false;
        }
    }
}


text:
using Sniper.Http;
using Sniper.TargetProcess.Routes;
using Xunit;

namespace Sniper.Tests.CRUD.Update.Common.GlobalSettings
{
    public class UpdateGlobalSettingsTests
    {
        [Fact]
        public void GlobalSettingsThrowsError()
        {
            var client = new TargetProcessClient
            {
                ApiSiteInfo = new ApiSiteInfo(TargetProcessRoutes.Route.GlobalSettings)
            };
            var globalSettings = new Sniper.Common.GlobalSettings
            {
            };
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
import {msg} from './modules/example';
import {getUsers, deleteUser} from './api/exampleApi';

document.addEventListener('DOMContentLoaded', () => {
  document.querySelector('#exampleMsg').innerHTML = msg;

  let usersContent = '';
  getUsers().then((users) => {
    users.forEach((user) => {
      usersContent += `

        Delete
        ${user.id}
        ${user.firstName}
        ${user.lastName}
        ${user.email}

`;
    });

    document.querySelector('#exampleData').innerHTML = usersContent;

    const deleteLinks = document.querySelectorAll('.deleteUser');

    Array.from(deleteLinks, (link) => {
      link.onclick = function(event) {
        const element = event.target;
        event.preventDefault();
        deleteUser(element.attributes['data-id'].value);
        const row = element.parentNode.parentNode;
        row.parentNode.removeChild(row);
      }
    });
  });
});


text:
<!--TOC-->

- [Learning Python](#learning-python)
  - [Howto](#howto)
  - [Prerequisites](#prerequisites)
  - [Preparing](#preparing)

<!--TOC-->

It is not really meant to be used as is, but it provides a good layout for an
in-person training, with a trainer who's experienced with Python.

## Howto

- Share your screen with a Python REPL
- Use the handout as a layout for the training.
- Get interactivity by asking questions! "❓ Question to ask orally"

## Prerequisites

This course was written for experienced developers.

## Preparing

- Read https://docs.python.org/3/tutorial/introduction.html
- Install Python 3.9 or 3.8


text:
import * as core from '../../core';
const SharedTicker = core.ticker.shared;

const CANVAS_START_SIZE = 16;
const DEFAULT_UPLOADS_PER_FRAME = 4;

/**
 * The prepare manager provides functionality to upload content to the GPU
 * This cannot be done directly for Canvas like in WebGL, but the effect can be achieved by drawing
 * textures to an offline canvas.
 * This draw call will force the texture to be moved onto the GPU.
 *
 * @class
 * @memberof PIXI
 */
export default class CanvasPrepare
{
    /**
     * @param {PIXI.CanvasRenderer} renderer - A reference to the current renderer
     */
    constructor(renderer)
    {
        /**
         * Reference to the renderer.
         * @type {PIXI.CanvasRenderer}
         * @private
         */
        this.renderer = renderer;

        /**
        * An offline canvas to render textures to
        * @type {HTMLCanvasElement}
        * @private
        */
        this.canvas = document.createElement('canvas');
        this.canvas.width = CANVAS_START_SIZE;
        this.canvas.height = CANVAS_START_SIZE;

        /**
         * The context to the canvas
        * @type {CanvasRenderingContext2D}
        * @private
        */
        this.ctx = this.canvas.getContext('2d');

        /**
         * Collection of items to uploads at once.
         * @type {Array<*>}
         * @private
         */
        this.queue = [];

        /**
         * Collection of additional hooks for finding assets.
         * @type {Array<Function>}
         * @private
         */
        this.addHooks = [];

        /**
         * Collection of additional hooks for processing assets.
         * @type {Array<Function>}
         * @private
         */
        this.uploadHooks = [];

        /**
         * Callback to call after completed.
         * @type {Array<Function>}
         * @private
         */
        this.completes = [];

        /**
         * If prepare is ticking (running).
         * @type {boolean}
         * @private
         */
        this.ticking = false;

        // Add textures to upload
        this.register(findBaseTextures, uploadBaseTextures);
    }

    /**
     * Upload all the textures and graphics to the GPU.
     *
     * @param {Function|PIXI.DisplayObject|PIXI.Container} item - Either
     *        the container or display object to search for items to upload or
     *        the callback function, if items have been added using `prepare.add`.
     * @param {Function} [done] - Optional callback when all queued uploads have completed
     */
    upload(item, done)
    {
        if (typeof item === 'function')
        {
            done = item;
            item = null;
        }

        // If a display object, search for items
        // that we could upload
        if (item)
        {
            this.add(item);
        }

        // Get the items for upload from the display
        if (this.queue.length)
        {
            this.numLeft = CanvasPrepare.UPLOADS_PER_FRAME;

            if (done)
            {
                this.completes.push(done);
            }

            if (!this.ticking)
            {
                this.ticking = true;
                SharedTicker.add(this.tick, this);
            }
        }
        else if (done)
        {
            done();
        }
    }

    /**
     * Handle tick update
     *
     * @private
     */
    tick()
    {
        // Upload the graphics
        while (this.queue.length && this.numLeft > 0)
        {
            const item = this.queue[0];
            let uploaded = false;

            for (let i = 0, len = this.uploadHooks.length; i < len; i++)
            {
                if (this.uploadHooks[i](this, item))
                {
                    this.numLeft--;
                    this.queue.shift();
                    uploaded = true;
                    break;
                }
            }

            if (!uploaded)
            {
                this.queue.shift();
            }
        }

        // We're finished
        if (this.queue.length)
        {
            this.numLeft = CanvasPrepare.UPLOADS_PER_FRAME;
        }
        else
        {
            this.ticking = false;

            SharedTicker.remove(this.tick, this);

            const completes = this.completes.slice(0);

            this.completes.length = 0;

            for (let i = 0, len = completes.length; i < len; i++)
            {
                completes[i]();
            }
        }
    }

    /**
     * Adds hooks for finding and uploading items.
     *
     * @param {Function} [addHook] - Function call that takes two parameters: `item:*, queue:Array`
              function must return `true` if it was able to add item to the queue.
     * @param {Function} [uploadHook] - Function call that takes two parameters: `prepare:CanvasPrepare, item:*` and
     *        function must return `true` if it was able to handle upload of item.
     * @return {PIXI.CanvasPrepare} Instance of plugin for chaining.
     */
    register(addHook, uploadHook)
    {
        if (addHook)
        {
            this.addHooks.push(addHook);
        }

        if (uploadHook)
        {
            this.uploadHooks.push(uploadHook);
        }

        return this;
    }

    /**
     * Manually add an item to the uploading queue.
     *
     * @param {PIXI.DisplayObject|PIXI.Container|*} item - Object to add to the queue
     * @return {PIXI.CanvasPrepare} Instance of plugin for chaining.
     */
    add(item)
    {
        // Add additional hooks for finding elements on special
        // types of objects that
        for (let i = 0, len = this.addHooks.length; i < len; i++)
        {
            if (this.addHooks[i](item, this.queue))
            {
                break;
            }
        }

        // Get childen recursively
        if (item instanceof core.Container)
        {
            for (let i = item.children.length - 1; i >= 0; i--)
            {
                this.add(item.children[i]);
            }
        }

        return this;
    }

    /**
     * Destroys the plugin, don't use after this.
     *
     */
    destroy()
    {
        if (this.ticking)
        {
            SharedTicker.remove(this.tick, this);
        }
        this.ticking = false;
        this.addHooks = null;
        this.uploadHooks = null;
        this.renderer = null;
        this.completes = null;
        this.queue = null;
        this.ctx = null;
        this.canvas = null;
    }

}

/**
 * The number of graphics or textures to upload to the GPU.
 *
 * @static
 * @type {number}
 * @default 4
 */
CanvasPrepare.UPLOADS_PER_FRAME = DEFAULT_UPLOADS_PER_FRAME;

/**
 * Built-in hook to upload PIXI.Texture objects to the GPU.
 *
 * @private
 * @param {*} prepare - Instance of CanvasPrepare
 * @param {*} item - Item to check
 * @return {boolean} If item was uploaded.
 */
function uploadBaseTextures(prepare, item)
{
    if (item instanceof core.BaseTexture)
    {
        const image = item.source;

        // Sometimes images (like atlas images) report a size of zero, causing errors on windows phone.
        // So if the width or height is equal to zero then use the canvas size
        // Otherwise use whatever is smaller, the image dimensions or the canvas dimensions.
        const imageWidth = image.width === 0 ? prepare.canvas.width : Math.min(prepare.canvas.width, image.width);
        const imageHeight = image.height === 0 ? prepare.canvas.height : Math.min(prepare.canvas.height, image.height);

        // Only a small subsections is required to be drawn to have the whole texture uploaded to the GPU
        // A smaller draw can be faster.
        prepare.ctx.drawImage(image, 0, 0, imageWidth, imageHeight, 0, 0, prepare.canvas.width, prepare.canvas.height);

        return true;
    }

    return false;
}

/**
 * Built-in hook to find textures from Sprites.
 *
 * @private
 * @param {PIXI.DisplayObject} item  -Display object to check
 * @param {Array<*>} queue - Collection of items to upload
 * @return {boolean} if a PIXI.Texture object was found.
 */
function findBaseTextures(item, queue)
{
    // Objects with textures, like Sprites/Text
    if (item instanceof core.BaseTexture)
    {
        if (queue.indexOf(item) === -1)
        {
            queue.push(item);
        }

        return true;
    }
    else if (item._texture && item._texture instanceof core.Texture)
    {
        const texture = item._texture.baseTexture;

        if (queue.indexOf(texture) === -1)
        {
            queue.push(texture);
        }

        return true;
    }

    return false;
}

core.CanvasRenderer.registerPlugin('prepare', CanvasPrepare);


text:
package com.bronti.teamcity.mergeConflictCheckerPlugin;

/**
 * Created by bronti on 15.11.16.
 */

public enum MergeConflictCheckerMyOption {

    FIRST, SECOND;

    public String getValue() {
        return this.name();
    }

}


text:
<!DOCTYPE html>
<html>
<head>
    <title>Click</title>
</head>
<body style="height: 1500px;">
<input type="button" id="input" style="position: absolute; margin-left: 100px; margin-top: 100px;"/>
</body>
</html>


text:
package com.rgcase.playground

import org.scalatest.{Matchers, PropSpec}
import org.scalatest.prop._

class CheckSpec
  extends PropSpec
  with GeneratorDrivenPropertyChecks
  with Matchers {

  property ("Addition and multiplication are related") {
    forAll { (x: Int) =>
      whenever(x > 0) {
        x * 2 should be(x + x)
      }
    }
  }

}


text:
#import <Foundation/Foundation.h>

////////////////////////////////////////////////////////////////////
// File includes:
#import "EAGLView.h"
#import "CameraCalibration.hpp"
#import "BGRAVideoFrame.h"

@interface SimpleVisualizationController : NSObject
{
  EAGLView * m_glview;
  GLuint m_backgroundTextureId;
  std::vector<Transformation> m_transformations;
  CameraCalibration m_calibration;
  CGSize m_frameSize;
}

-(id) initWithGLView:(EAGLView*)view calibration:(CameraCalibration) calibration frameSize:(CGSize) size;

-(void) drawFrame;
-(void) updateBackground:(BGRAVideoFrame) frame;
-(void) setTransformationList:(const std::vector<Transformation>&) transformations;

@end


text:
from app import db

# Define a base model for other database tables to inherit
class Base(db.Model):

    __abstract__  = True

    id            = db.Column(db.Integer, primary_key=True)
    date_created  = db.Column(db.DateTime,  default=db.func.current_timestamp())
    date_modified = db.Column(db.DateTime,  default=db.func.current_timestamp(),
                                           onupdate=db.func.current_timestamp())

# Define a Task model
class Task(Base):

    __tablename__ = 'task'

    # Task description
    description    = db.Column(db.String(192),  nullable=False)
    # Task complete
    complete       = db.Column(db.Boolean,  nullable=False)

    # New instance instantiation procedure
    def __init__(self, description):

        self.description = description
        self.complete = False

    def __repr__(self):
        return '<Task Id: %r, Description: %r, Complete: %r>' % (self.id, self.description, self.complete)

    def toJSON(self):
        return {
            'id': self.id,
            'description': self.description,
            'complete': self.complete
        }


text:
using System;
using System.ComponentModel.DataAnnotations.Schema;
using Linq2Csv.DataAnnotations;

namespace UM4RS.Context.Time {
    [Table("Time")]
    public class Time : ModelEntity<Time>, IBaseEntity
    {
        [NonExportable]
        public int Id { get; set; }
        public DateTime? TimeStamp{get; set;}
		public DateTime? TimeInterval{get; set;}
		public DayOfWeek DayOfWeek{get; set;}
		public DayType DayType{get; set;}
        public TimeOfDay TimeOfDay { get; set; }
        public Season Season { get; set; }
	}

}


text:
<?php
/* @var $this EquipsController */
/* @var $model Equips */
/* @var $form CActiveForm */
?>

<?php $form=$this->beginWidget('CActiveForm', array(
	'action'=>Yii::app()->createUrl($this->route),
	'method'=>'get',
)); ?>

		<?php echo $form->label($model,'Name'); ?>
		<?php echo $form->textField($model,'Name',array('size'=>20,'maxlength'=>20)); ?>

		<?php echo $form->label($model,'CostHour'); ?>
		<?php echo $form->textField($model,'CostHour'); ?>

		<?php echo CHtml::submitButton('Search'); ?>

<?php $this->endWidget(); ?>


text:
package rabbit.filter;

import java.io.IOException;
import java.io.Reader;
import java.nio.channels.SocketChannel;
import java.util.List;
import rabbit.util.IPAccess;
import rabbit.util.SProperties;

/** This interface holds the method needed to do socket based access filtering.
 *
 * @author Robert Olofsson
 */
public interface IPAccessFilter {

    /** Filter based on a socket.
     * @param s the Socket to check.
     * @return true if the Socket should be allowed, false otherwise.
     */
    boolean doIPFiltering (SocketChannel s);

    /** Setup this filter.
     * @param properties the SProperties to get the settings from.
     */
    void setup (SProperties properties);

    /** Get the list of allowed ips
     * @return the list of allowed accesses
     */
    public List<IPAccess> getAllowList ();

    /** Get the list of denied ips
     * @return the list of denied accesses
     */
    public List<IPAccess> getDenyList ();

    /** Loads in the accessess allowed from the given Reader
     * @param r the Reader were data is available
     * @throws IOException if loading fails
     */
    public void loadAccess (Reader r) throws IOException;
}


text:
React components that implement Google's Material Design.

## Installation

Install the package in your project directory with:

```sh
// with npm
npm install @material-ui/core

// with yarn
yarn add @material-ui/core
```

## Documentation

[The documentation](https://material-ui.com/)


text:
CKEDITOR.plugins.setLang('wordcount', 'en', {
    WordCount: 'Words:',
    CharCount: 'Characters:',
    CharCountWithHTML: 'Characters (with HTML):',
    Paragraphs: 'Paragraphs:',
    pasteWarning: 'Content can not be pasted because it is above the allowed limit',
    Selected: 'Selected: ',
    title: 'Statistics'
});


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
	xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_height="match_parent"
	xmlns:app="http://schemas.android.com/apk/res-auto"
	android:layout_width="match_parent">

	<View
		android:layout_width="match_parent"
		android:layout_height="25dp"
		android:background="#90000000"
		android:elevation="4dp"
		android:id="@+id/playermainViewStatusBar"/>

	<ImageView
		android:layout_height="match_parent"
		android:layout_width="match_parent"
		android:id="@+id/playermainImageViewBack"/>

	<android.support.v7.widget.Toolbar
		android:id="@+id/toolbar"
		android:layout_below="@id/playermainViewStatusBar"
		android:minHeight="?attr/actionBarSize"
		android:layout_width="match_parent"
		android:layout_height="wrap_content"
		app:titleTextColor="@android:color/white"
		android:background="#90000000">

	</android.support.v7.widget.Toolbar>

	<RelativeLayout
		android:layout_height="160dp"
		android:layout_width="match_parent"
		android:layout_alignParentBottom="true"
		android:background="#90000000"
		android:id="@+id/playermainRelativeLayout2">

		<ImageView
			android:layout_height="35dp"
			android:layout_width="35dp"
			android:layout_alignParentRight="true"
			android:layout_margin="5dp"
			android:id="@+id/playermainImageMore"
			android:src="@drawable/ic_heart_outline"
			android:padding="5dp"/>

		<ImageView
			android:layout_height="35dp"
			android:layout_width="35dp"
			android:layout_margin="5dp"
			android:id="@+id/playermainImageViewAdd"
			android:src="@drawable/ic_close"
			android:padding="5dp"/>

		<TextView
			android:layout_height="wrap_content"
			android:text="Medium Text"
			android:textAppearance="?android:attr/textAppearanceMedium"
			android:layout_width="wrap_content"
			android:layout_centerHorizontal="true"
			android:id="@+id/playermainTextViewNome"
			android:textColor="#FEFEFE"
			android:singleLine="true"
			android:ellipsize="end"
			android:marqueeRepeatLimit="marquee_forever"
			android:layout_toLeftOf="@id/playermainImageMore"
			android:layout_toRightOf="@id/playermainImageViewAdd"
			android:gravity="center"
			android:paddingLeft="10dp"
			android:paddingRight="10dp"/>

		<TextView
			android:layout_height="wrap_content"
			android:text="Small Text"
			android:textAppearance="?android:attr/textAppearanceSmall"
			android:layout_width="wrap_content"
			android:layout_below="@id/playermainTextViewNome"
			android:layout_centerHorizontal="true"
			android:textColor="#DFDFDF"
			android:id="@+id/playermainTextViewArtista"
			android:layout_toLeftOf="@id/playermainImageMore"
			android:layout_toRightOf="@id/playermainImageViewAdd"
			android:gravity="center"
			android:paddingLeft="10dp"
			android:paddingRight="10dp"
			android:singleLine="true"
			android:ellipsize="marquee"
			android:marqueeRepeatLimit="marquee_forever"
			android:textSize="17sp"/>

		<RelativeLayout
			android:layout_height="30dp"
			android:layout_width="match_parent"
			android:layout_below="@id/playermainTextViewArtista"
			android:id="@+id/playermainRelativeLayout1">

			<TextView
				android:layout_height="match_parent"
				android:text="0:00"
				android:textAppearance="?android:attr/textAppearanceSmall"
				android:layout_width="wrap_content"
				android:id="@+id/playermainTextViewPassed"
				android:layout_marginLeft="5dp"
				android:textColor="#FFFFFF"
				android:gravity="center"/>

			<TextView
				android:layout_height="match_parent"
				android:text="5:35"
				android:textAppearance="?android:attr/textAppearanceSmall"
				android:layout_width="wrap_content"
				android:layout_alignParentRight="true"
				android:layout_marginRight="5dp"
				android:id="@+id/playermainTextView1"
				android:textColor="#FFFFFF"
				android:gravity="center"/>

			<SeekBar
				android:layout_height="30dp"
				android:layout_toRightOf="@id/playermainTextViewPassed"
				android:layout_toLeftOf="@id/playermainTextView1"
				android:layout_marginRight="10dp"
				android:layout_marginLeft="10dp"
				android:id="@+id/playermainSeekBarCompat"
				android:layout_width="wrap_content"/>

		</RelativeLayout>

		<RelativeLayout
			android:layout_height="wrap_content"
			android:layout_width="match_parent"
			android:layout_below="@id/playermainRelativeLayout1"
			android:id="@+id/playermainRelativeLayout3">

			<ImageView
				android:layout_height="35dp"
				android:layout_width="35dp"
				android:src="@drawable/ic_shuffle"
				android:layout_centerVertical="true"
				android:layout_margin="5dp"
				android:id="@+id/playermainImageViewShuffle"
				android:padding="5dp"
				android:scaleType="centerInside"/>

			<ImageView
				android:layout_height="35dp"
				android:layout_width="35dp"
				android:src="@drawable/ic_repeat_off"
				android:id="@+id/playermainImageViewRepeat"
				android:layout_alignParentRight="true"
				android:layout_centerVertical="true"
				android:layout_margin="5dp"
				android:padding="5dp"/>

			<ImageView
				android:layout_height="85dp"
				android:layout_width="80dp"
				android:layout_centerInParent="true"
				android:id="@+id/playermainImageViewPlayPause"
				android:src="@drawable/ic_pause_circle_outline"/>

			<ImageView
				android:layout_height="50dp"
				android:layout_width="50dp"
				android:layout_centerVertical="true"
				android:id="@+id/playermainImageViewPrev"
				android:src="@drawable/ic_skip_previous"
				android:padding="5dp"
				android:layout_toLeftOf="@id/playermainImageViewPlayPause"
				android:layout_marginRight="10dp"/>

			<ImageView
				android:layout_height="50dp"
				android:layout_width="50dp"
				android:layout_centerVertical="true"
				android:id="@+id/playermainImageViewNext"
				android:src="@drawable/ic_skip_next"
				android:layout_toRightOf="@id/playermainImageViewPlayPause"
				android:padding="5dp"
				android:layout_marginLeft="10dp"/>

		</RelativeLayout>

	</RelativeLayout>

	<android.support.v4.view.ViewPager
		android:layout_height="match_parent"
		android:layout_width="match_parent"
		android:layout_above="@id/playermainRelativeLayout2"
		android:id="@+id/playermainViewPager"
		android:layout_below="@id/toolbar"
		android:background="#90000000"/>

</RelativeLayout>


text:
/**
 * Calculates the number of cells to overscan before and after a specified range.
 * This function ensures that overscanning doesn't exceed the available cells.
 * @param cellCount Number of rows or columns in the current axis
 * @param overscanCellsCount Maximum number of cells to over-render in either direction
 * @param startIndex Begin of range of visible cells
 * @param stopIndex End of range of visible cells
 */
export default function getOverscanIndices ({ cellCount, overscanCellsCount, startIndex, stopIndex }) {
  return {
    overscanStartIndex: Math.max(0, startIndex - overscanCellsCount),
    overscanStopIndex: Math.min(cellCount - 1, stopIndex + overscanCellsCount)
  }
}


text:
var $ = require('jquery');

window.jQuery = $;
var bootstrap = require('bootstrap'); //eslint-disable-line no-unused-vars
var bootbox = require('bootbox');

var Pubsub = require('../lib/pubsub');
var AppState = require('../app_state');

var BaseView = require('./base');

var ChannelView = BaseView.extend({
    className: 'channel container-fluid',

    template: require('./spinner.hbs'),

    events: {
        'click .channel-actions button': 'channelAction'
    },

    initialize: function() {
        BaseView.prototype.initialize.apply(this, arguments);
        this.listenTo(AppState, 'change:graph_interval', this.render);
        var isAdmin = this.model.get('isAdmin');
        this.model.fetch()
            .done(function(data) {
                this.template = require('./channel.hbs');
                this.render({'message': data['message'], 'isAdmin': isAdmin});
            }.bind(this))
            .fail(this.handleViewError.bind(this))
            .always(Pubsub.trigger.bind(Pubsub, 'view:ready'));
    },

    channelAction: function(e) {
        e.preventDefault();
        e.stopPropagation();
        var action = $(e.currentTarget).data('action');
        var txt = 'Are you sure you want to ' +
            action + ' ' + this.model.get('topic') +
            '/' + this.model.get('name') + '?';
        bootbox.confirm(txt, function(result) {
            if (result !== true) {
                return;
            }
            if (action === 'delete') {
                var topic = this.model.get('topic');
                $.ajax(this.model.url(), {'method': 'DELETE'})
                    .done(function() {
                        window.location = AppState.basePath('/topics/' +
                            encodeURIComponent(topic));
                    })
                    .fail(this.handleAJAXError.bind(this));
            } else {
                $.post(this.model.url(), JSON.stringify({'action': action}))
                    .done(function() { window.location.reload(true); })
                    .fail(this.handleAJAXError.bind(this));
            }
        }.bind(this));
    }
});

module.exports = ChannelView;


text:
"""
    This contains a class to start an analysis using the specified modules and
    the specified machine.

    (c) 2015 Massachusetts Institute of Technology
"""
import logging
logger = logging.getLogger(__name__)

# LO-PHI
import lophi.globals as G
from lophi_automation.analysis_scripts import LophiAnalysis

class ScreenshotAnalysis(LophiAnalysis):
    """
        Simple screenshot example
    """

    # These are required to automatically find an appropriate machine for the
    # analysis
    NAME = "screenshot"
    DESCRIPTION = "Simple screenshot test"
    MACHINE_TYPE = G.MACHINE_TYPES.PHYSICAL
    VOLATILITY_PROFILE = "WinXPSP3x86"

    def analysis_start(self):
        """
            Simply take a screenshot
        """

        # Analysis is done after this function returns
        self.CONTINUE_EXECUTION = False

        # Extract some important variables
        machine = self.machine

        memory_file = "memory_dump.mfd"
        # Take another memory dump
        print "* %s: Dumping memory..."%self.machine.config.name
        if not machine.memory_dump(memory_file):
            raise "Bad memory read."

        vol_uri = "file://"+memory_file
        # Let's take a screenshot
        try:
            print "* Taking a screenshot."
            screenshot_file = "sut_screenshot"
            self.machine.screenshot(screenshot_file,vol_uri=vol_uri)
        except:
            logger.error("Could not take a screenshot.")
            pass


text:
package com.vaadin.tests.components.table;

import java.util.Set;

import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
import com.vaadin.ui.Notification;
import com.vaadin.ui.Notification.Type;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.v7.ui.Table;

/**
 * Test to see if selecting and deselecting a table row after select range has
 * been removed.
 *
 * @since 7.1.13
 * @author Vaadin Ltd
 */
@SuppressWarnings("serial")
public class AddSelectionToRemovedRange extends AbstractReindeerTestUI {

    @Override
    @SuppressWarnings("unchecked")
    protected void setup(VaadinRequest request) {
        VerticalLayout layout = new VerticalLayout();
        layout.setMargin(true);
        layout.setSpacing(true);
        setContent(layout);

        final Table table = new Table();
        table.setMultiSelect(true);
        table.setSelectable(true);
        table.addContainerProperty("value", String.class, "");

        for (int i = 0; i < 100; i++) {
            table.addItem(i);
            table.getContainerProperty(i, "value").setValue("value " + i);
        }

        layout.addComponent(table);

        Button button = new Button("Remove");
        button.addClickListener(event -> {
            Set<Integer> selected = (Set<Integer>) table.getValue();

            for (Integer item : selected) {
                if (null == item) {
                    new Notification("ERROR",
                            "Table value has null in Set of selected items!",
                            Type.ERROR_MESSAGE).show(getPage());
                }
                table.removeItem(item);
            }
        });

        layout.addComponent(button);

    }

    @Override
    protected String getTestDescription() {
        return "Verify that VScrollTable does not return bad ranges when ";
    }

    @Override
    protected Integer getTicketNumber() {
        return 13353;
    }

}


text:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Myre.Extensions;

namespace Myre.Entities.Services
{
    class ServiceContainer
        : IEnumerable<IService>
    {
        private readonly Dictionary<Type, IService> _dictionary = new();
        private readonly List<IService> _update = new();
        private readonly List<IService> _draw = new();

        private readonly List<IService> _buffer = new();
        private bool _dirty;

        private readonly Comparison<IService> _updateOrder;
        private readonly Comparison<IService> _drawOrder;

        private readonly Stopwatch _timer = new();
        private readonly List<KeyValuePair<IService, TimeSpan>> _executionTimes = new();
        public IReadOnlyList<KeyValuePair<IService, TimeSpan>> ExecutionTimes => _executionTimes;

        private readonly List<KeyValuePair<IService, TimeSpan>> _renderTimes = new();
        public IReadOnlyList<KeyValuePair<IService, TimeSpan>> RenderTimes => _renderTimes;

        public IService this[Type type] => _dictionary[type];

        public ServiceContainer()
        {
            _updateOrder = (a, b) => a.UpdateOrder.CompareTo(b.UpdateOrder);
            _drawOrder = (a, b) => a.DrawOrder.CompareTo(b.DrawOrder);
        }

        public void Add(IService service)
        {
            _buffer.Add(service);
            _dictionary[service.GetType()] = service;
            _dirty = true;
        }

        public bool Remove(IService service)
        {
            var removed = _buffer.Remove(service);

            if (removed)
            {
                _dictionary.Remove(service.GetType());
                _dirty = true;
            }

            return removed;
        }

        public bool TryGet(Type serviceType, out IService service)
        {
            if (_dictionary.TryGetValue(serviceType, out service))
                return true;

            foreach (var item in _buffer)
            {
                if (serviceType.IsInstanceOfType(item))
                {
                    service = item;
                    return true;
                }
            }

            return false;
        }

        public void Clear()
        {
            _buffer.Clear();
            _dirty = true;
        }

        public void Update(float elapsedTime)
        {
            UpdateLists();
            _update.InsertionSort(_updateOrder);

            _executionTimes.Clear();

            foreach (var service in _update)
            {
                _timer.Restart();
                service.Update(elapsedTime);
                _timer.Stop();
                _executionTimes.Add(new KeyValuePair<IService, TimeSpan>(service, _timer.Elapsed));
            }
        }

        public void Draw()
        {
            UpdateLists();
            _draw.InsertionSort(_drawOrder);

            _renderTimes.Clear();

            foreach (var service in _draw)
            {
                _timer.Restart();
                service.Draw();
                _timer.Stop();
                _renderTimes.Add(new KeyValuePair<IService, TimeSpan>(service, _timer.Elapsed));
            }
        }

        private void UpdateLists()
        {
            RemoveDisposed();

            if (!_dirty)
                return;

            _update.Clear();
            _update.AddRange(_buffer);

            _draw.Clear();
            _draw.AddRange(_buffer);

            _dirty = false;
        }

        private void RemoveDisposed()
        {
            for (var i = _buffer.Count - 1; i >= 0; i--)
            {
                var item = _buffer[i];
                if (item.IsDisposed)
                {
                    _buffer.RemoveAt(i);
                    _dirty = true;
                }
            }
        }

        public IEnumerator<IService> GetEnumerator()
        {
            return _buffer.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}


text:
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#include "mpi.h"
#include <stdio.h>
#include <string.h>

#define BUFLEN 512

int main(int argc, char *argv[])
{
    int myid, numprocs, next, namelen;
    char buffer[BUFLEN], processor_name[MPI_MAX_PROCESSOR_NAME];
    MPI_Status status;

    MPI_Init(&argc,&argv);
    MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
    MPI_Comm_rank(MPI_COMM_WORLD,&myid);
    MPI_Get_processor_name(processor_name,&namelen);

    fprintf(stderr,"Process %d on %s\n", myid, processor_name);
    fprintf(stderr,"Process %d of %d\n", myid, numprocs);
    strcpy(buffer,"hello there");
    if (myid == numprocs-1)
	next = 0;
    else
	next = myid+1;

    if (myid == 0)
    {
        printf("%d sending '%s' \n",myid,buffer);fflush(stdout);
	MPI_Send(buffer, strlen(buffer)+1, MPI_CHAR, next, 99, MPI_COMM_WORLD);
	printf("%d receiving \n",myid);fflush(stdout);
	MPI_Recv(buffer, BUFLEN, MPI_CHAR, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD,
		 &status);
	printf("%d received '%s' \n",myid,buffer);fflush(stdout);
	/* mpdprintf(001,"%d receiving \n",myid); */
    }
    else
    {
        printf("%d receiving  \n",myid);fflush(stdout);
	MPI_Recv(buffer, BUFLEN, MPI_CHAR, MPI_ANY_SOURCE, 99, MPI_COMM_WORLD,
		 &status);
	printf("%d received '%s' \n",myid,buffer);fflush(stdout);
	/* mpdprintf(001,"%d receiving \n",myid); */
	MPI_Send(buffer, strlen(buffer)+1, MPI_CHAR, next, 99, MPI_COMM_WORLD);
	printf("%d sent '%s' \n",myid,buffer);fflush(stdout);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Finalize();
    return (0);
}


text:
<?php

if (!defined('BASEPATH'))
    exit('No direct script access allowed');

class Actividades_controller extends CI_Controller {

    public $datos = array();

    public function __construct() {
        parent::__construct();
        $this->load->library(array('session', 'ion_auth'));
        $this->load->model(array('actividades_model'));
        $this->load->helper(array('url', 'form', 'language'));
        $this->form_validation->set_error_delimiters($this->config->item('error_start_delimiter', 'ion_auth'), $this->config->item('error_end_delimiter', 'ion_auth'));
        $this->lang->load('auth');
        // if (!$this->ion_auth->logged_in()) {
        //    redirect('auth/', 'refresh');
        // }
    }

    public function index() {
        if (!$this->ion_auth->logged_in()) {
            redirect('auth/', 'refresh');
        } else {
            $this->muestra_pantalla_actividades();
        }
    }

    public function obtiene_cursos() {
        $cursos = $this->curso_model->obtiene_cursos();
    }

    public function muestra_pantalla_actividades() {
        if (!$this->ion_auth->logged_in()) {
            redirect('auth/', 'refresh');
        } else {
            $data['message'] = (validation_errors()) ? validation_errors() : $this->session->flashdata('message');
            $data['operacion_terminada'] = $this->session->flashdata('operacion_terminada');
            $title['title'] = 'maestro: registrar actividad';
            $data['encabezado_html'] = $this->load->view('pagina/encabezado_html', $title, true);
            $menu['menu'] = $this->load->view('pagina/menu_maestro', '', true);
            $data['encabezado_pagina'] = $this->load->view('pagina/encabezado_pagina', $menu, true);
            $data['pie_pagina'] = $this->load->view('pagina/pie_pagina', '', true);
            $this->load->view('actividades', $data);
        }
    }

    public function selecciona_introduce_entradas() {
        //$entradas['subtema_id'] = $this->input->post('stemas_act');
        if (empty($this->input->post('stemas_act'))) {
            $entradas['subtema_id'] = NULL;
        } else {
            $entradas['subtema_id'] = $this->input->post('stemas_act');
        }
        if (empty($this->input->post('sstemas_act'))) {
            $entradas['subsubtema_id'] = NULL;
        } else {
            $entradas['subsubtema_id'] = $this->input->post('sstemas_act');
        }
        $entradas['tema_id'] = $this->input->post('temas_act');
        $entradas['url'] = $this->input->post('url_actividad');
        $entradas['nombre_actividad'] = $this->input->post('nombre_actividad');
        return $entradas;
    }

    public function valida_entradas_actividad() {
        $datos = $this->selecciona_introduce_entradas();
        $this->form_validation->set_rules('temas_act', 'Tema', 'required');
        //$this->form_validation->set_rules('sstemas_act', 'Subsubtema', '');
        $this->form_validation->set_rules('url_actividad', 'URL de actividad', 'required|valid_url_format|url_exists');
        $this->form_validation->set_rules('nombre_actividad', 'Nombre de actividad', 'required');
        $this->form_validation->set_message('required', '%s es un campo requerido.');
        $this->form_validation->set_message('min_length', '%s debe tener minimo %s carácteres.');
        $this->form_validation->set_message('max_length', '%s debe tener maximo %s carácteres.');
        $this->form_validation->set_message('is_unique', '%s ya existe.');
        if ($this->form_validation->run()) {
            if (!$this->actividades_model->verifica_existencia($datos)) {
                $this->actividades_model->crea_actividad($datos);
                $this->session->set_flashdata('message', '
'
                        . 'X'
                        . '   '
                        . 'La actividad "' . $this->input->post('nombre_actividad') . '" ha sido creada.
');
                redirect('actividades_controller/muestra_pantalla_actividades', 'refresh');
            } else {
                $this->session->set_flashdata('message', '
'
                        . 'X'
                        . '   '
                        . 'La actividad "' . $this->input->post('nombre_actividad') . '"  ya existe.
');
                $this->muestra_pantalla_actividades();
            }
        } else {
            $this->session->set_flashdata('message', validation_errors());
            redirect('actividades_controller/muestra_pantalla_actividades', 'refresh');
        }
    }

    public function obtiene_actividades_tema() {
        $tema = $this->session->userdata('tema');
        $actividades_t = $this->actividades_model->obtiene_actividades_tema($tema);
        echo json_encode($actividades_t);
    }

    public function obtiene_actividades_subsubtema($subsubtema) {
        $subsubtema = $this->session->userdata('subsubtema');
        $actividades_ss = $this->actividades_model->obtiene_actividades_subsubtema($subsubtema);
        echo json_encode($actividades_ss);
    }

    public function registra_inicio_actividad($id) {
        $datos['users_id'] = $this->session->userdata('user_id');
        $datos['actividad_id'] = $id;
        $datos['inicio'] = date('Y-m-d H:i:s');
        $datos['comenzada'] = '1';
        $this->session->set_userdata('actividad', $id);
        $inicio_actividad = $this->actividades_model->registra_inicio_actividad($datos);
        echo json_encode($inicio_actividad);
    }

    public function registra_fin_actividad() {
        $datos['users_id'] = $this->session->userdata('user_id');
        $datos['actividad_id'] = $this->session->userdata('actividad');
        $datos['fin'] = date('Y-m-d H:i:s');
        $datos['terminada'] = '1';
        $inicio_actividad = $this->actividades_model->registra_fin_actividad($datos);
        echo json_encode($inicio_actividad);
    }

    public function verifica_si_actividad_terminada($id) {
        echo json_encode($this->actividades_model->verifica_si_actividad_termino($id));
    }

}


text:
==============
MPI for Python
==============

.. image::  https://anaconda.org/mpi4py/mpi4py/badges/build.svg?
   :target: https://anaconda.org/mpi4py/mpi4py/builds
.. image::  https://travis-ci.org/mpi4py/mpi4py.svg?branch=master
   :target: https://travis-ci.org/mpi4py/mpi4py
.. image::  https://ci.appveyor.com/api/projects/status/whh5xovp217h0f7n?svg=true
   :target: https://ci.appveyor.com/project/mpi4py/mpi4py
.. image::  https://readthedocs.org/projects/mpi4py/badge/?version=latest
   :target: https://mpi4py.readthedocs.org/latest/

Overview
--------

Welcome to MPI for Python. This package provides Python bindings for
the *Message Passing Interface* (`MPI <http://www.mpi-forum.org/>`_)
standard. It is implemented on top of the MPI-1/2/3 specification and
exposes an API which grounds on the standard MPI-2 C++ bindings.

Dependencies
------------

* `Python <http://www.python.org/>`_ 2.6, 2.7, 3.2 or above,
  or `PyPy <http://pypy.org/>`_ 2.0 or above.

* A functional MPI 1.x/2.x/3.x implementation like `MPICH
  <http://www.mpich.org/>`_ or `Open MPI <http://www.open-mpi.org/>`_
  built with shared/dynamic libraries.

* To work with the in-development version, you need to install `Cython
  <http://www.cython.org/>`_.

Testsuite
---------

The testsuite is run periodically on

* `Anaconda <https://anaconda.org/mpi4py/mpi4py/builds>`_

* `Travis CI <https://travis-ci.org/mpi4py/mpi4py>`_

* `AppVeyor <https://ci.appveyor.com/project/mpi4py/mpi4py>`_

* `Fedora Jenkins <http://jenkins.cloud.fedoraproject.org/job/mpi4py/>`_


text:
require 'spec_helper'

RSpec.describe Sunspot::NullResult::Group do

  let(:collection) { [1, 2].map { |id| klass.new('foo', id) } }

  subject { described_class.new(42, collection) }

  describe '#solr_docs' do
    it 'build solr document list as expected' do
      expect(subject.solr_docs).to eql ['Struct::Monkey 1', 'Struct::Monkey 2']
    end
  end

  describe '#hits' do
    RSpec::Matchers.define :be_sunspot_hit_compliant do
      match do |actual|
        @missing_methods = []
        [:primary_key].each do |meth|
          @missing_methods << meth unless actual.respond_to? meth
        end
        @missing_methods.empty?
      end

      failure_message do |actual|
        "#{actual} does not respond to these methods: #{@missing_methods.inspect}"
      end
    end

    it 'implements sunspot hit interface' do
      subject.hits.each do |item|
        expect(item).to be_sunspot_hit_compliant
      end
    end
  end

  def klass
    @klass ||= Struct.new('Monkey', :foobar, :id)
  end

end


text:
<!DOCTYPE HTML>

	<meta charset="utf-8">
	<title>Demo: Simple Horizontal and Vertical Sliders</title>
	<link rel="stylesheet" href="../../_common/demo.css" media="screen">
	<link rel="stylesheet" href="//ajax.googleapis.com/ajax/libs/dojo/1.10.4/dijit/themes/claro/claro.css" media="screen">

Demo: Simple Horizontal and Vertical Sliders

Horizontal Slider

This horizontal slider ranges in value from 0-10, incrementing by 1.

	<input id="hslider" value="3" type="range"
		   data-dojo-type="dijit/form/HorizontalSlider"
		   data-dojo-props="
					minimum: 0,
					maximum: 10,
					discreteValues: 11">

Value:

		<button id="disableButton" data-dojo-type="dijit/form/Button"
				data-dojo-props="onClick: updateHorizontalState">Disable Slider</button>

Vertical Slider

This vertical slider ranges in value from 0-100 with no discrete values,
	so the widget is freely draggable.

Value:


text:
#include <aws/groundstation/model/SatelliteListItem.h>
#include <aws/core/utils/json/JsonSerializer.h>

#include <utility>

using namespace Aws::Utils::Json;
using namespace Aws::Utils;

namespace Aws
{
namespace GroundStation
{
namespace Model
{

SatelliteListItem::SatelliteListItem() :
    m_currentEphemerisHasBeenSet(false),
    m_groundStationsHasBeenSet(false),
    m_noradSatelliteID(0),
    m_noradSatelliteIDHasBeenSet(false),
    m_satelliteArnHasBeenSet(false),
    m_satelliteIdHasBeenSet(false)
{
}

SatelliteListItem::SatelliteListItem(JsonView jsonValue) :
    m_currentEphemerisHasBeenSet(false),
    m_groundStationsHasBeenSet(false),
    m_noradSatelliteID(0),
    m_noradSatelliteIDHasBeenSet(false),
    m_satelliteArnHasBeenSet(false),
    m_satelliteIdHasBeenSet(false)
{
  *this = jsonValue;
}

SatelliteListItem& SatelliteListItem::operator =(JsonView jsonValue)
{
  if(jsonValue.ValueExists("currentEphemeris"))
  {
    m_currentEphemeris = jsonValue.GetObject("currentEphemeris");

    m_currentEphemerisHasBeenSet = true;
  }

  if(jsonValue.ValueExists("groundStations"))
  {
    Aws::Utils::Array<JsonView> groundStationsJsonList = jsonValue.GetArray("groundStations");
    for(unsigned groundStationsIndex = 0; groundStationsIndex < groundStationsJsonList.GetLength(); ++groundStationsIndex)
    {
      m_groundStations.push_back(groundStationsJsonList[groundStationsIndex].AsString());
    }
    m_groundStationsHasBeenSet = true;
  }

  if(jsonValue.ValueExists("noradSatelliteID"))
  {
    m_noradSatelliteID = jsonValue.GetInteger("noradSatelliteID");

    m_noradSatelliteIDHasBeenSet = true;
  }

  if(jsonValue.ValueExists("satelliteArn"))
  {
    m_satelliteArn = jsonValue.GetString("satelliteArn");

    m_satelliteArnHasBeenSet = true;
  }

  if(jsonValue.ValueExists("satelliteId"))
  {
    m_satelliteId = jsonValue.GetString("satelliteId");

    m_satelliteIdHasBeenSet = true;
  }

  return *this;
}

JsonValue SatelliteListItem::Jsonize() const
{
  JsonValue payload;

  if(m_currentEphemerisHasBeenSet)
  {
   payload.WithObject("currentEphemeris", m_currentEphemeris.Jsonize());

  }

  if(m_groundStationsHasBeenSet)
  {
   Aws::Utils::Array<JsonValue> groundStationsJsonList(m_groundStations.size());
   for(unsigned groundStationsIndex = 0; groundStationsIndex < groundStationsJsonList.GetLength(); ++groundStationsIndex)
   {
     groundStationsJsonList[groundStationsIndex].AsString(m_groundStations[groundStationsIndex]);
   }
   payload.WithArray("groundStations", std::move(groundStationsJsonList));

  }

  if(m_noradSatelliteIDHasBeenSet)
  {
   payload.WithInteger("noradSatelliteID", m_noradSatelliteID);

  }

  if(m_satelliteArnHasBeenSet)
  {
   payload.WithString("satelliteArn", m_satelliteArn);

  }

  if(m_satelliteIdHasBeenSet)
  {
   payload.WithString("satelliteId", m_satelliteId);

  }

  return payload;
}

} // namespace Model
} // namespace GroundStation
} // namespace Aws


text:
layout: post
status: publish
published: true
title: Controladores
author: Oscar González
author_login: oscar
author_email: gonzalezgreco@gmail.com
author_url: http://www.oscarvgg.com
wordpress_id: 1097
wordpress_url: http://codehero.co/?p=1097
date: 2013-06-24 04:35:15.000000000 -04:30
serie: iOS desde Cero
dificultad: Novato
duracion: 20
categories:
- Cursos
- iOS
tags:
- iOS
- desde cero
- controladores
---

Bienvenidos una vez más a iOS desde Cero. En este capítulo de la serie vamos a empezar a desarrollar aplicaciones, ¡Yei!. Aprenderemos las habilidades básicas mínimas que necesitas saber para poder construir cualquier aplicación de iOS utilizando Xcode.

Modelo-Vista-Controlador (MVC)

El patrón de diseño de arquitectura o modelo de arquitectura de software MVC, es un patrón fundamental en el desarrollo de aplicaciones para iOS. Éste ha estado presente desde los años 70. Su filosofía parte principalmente de la idea de separar dependencias en tres módulos básicos para hacer el código más legible.

Modelos: Los modelos representan la lógica de la aplicación, generalmente son las clases de acceden a datos (persistencia).

Vistas: Las vistas son las interfaces gráficas que los usuarios ven.

Controladores: Son los encargados recibir los eventos disparados por las vistas y ejecutar las acciones correspondientes a dichos eventos en los modelos.

Lo bueno de esto es que es muy flexible. Dependiendo del nivel de complejidad de nuestra aplicación, éste patrón puede reducirse a solo vistas y controladores, como extenderse a usar más capas más allá de los modelos.

Básicamente el patrón MVC se representa de la siguiente manera:

Conectando la vista con el controlador

En Xcode las vistas vienen siendo los archivos .xib y los .storyboard, y los modelos y controladores son simplemente clases de Objective-C. Podrías no utilizar archivos para las vistas y generarlas por código desde los controladores, pero requiere mucho más trabajo, es preferible utilizar vistas siempre que se pueda.

Los objetos en los controladores que deben ser conectados con la interfaz se llaman outlets. Lo que debemos hacer en Xcode es conectar los outlets de los controladores con su representación gráfica:

Vamos a poner esto en práctica creando un nuevo proyecto en Xcode, haremos una app sencilla que permita a los usuarios introducir su nombre y les retorne un mensaje de saludo.

Esta vez no vamos a seleccionar Use Storyboards, vamos a usar solo xibs, pero si seguiremos usando ARC (automatic reference counting), este es el standard que Apple quiere que todos usemos de ahora en adelante.

Una vez que tengamos la ventana principal de Xcode frente a nosotros, seleccionamos ViewController.xib del navegador de archivos y veremos entonces como el editor despliega el Interface Builder.

Vamos a agregar tres objetos a nuestra interfaz:

En la parte inferior del inspector escribimos text. En la lista que está inmediatamente arriba, seleccionamos Text Field y lo arrastramos hasta la interfaz. Yo lo voy a colocar en la parte superior y lo voy a estirar un poco para tener mejor visibilidad. Tomate la libertad de modificarlo como quieras (o puedas).

En el inspector podemos editar algunas propiedades de los objetos que seleccionamos, juega con estos como quieras, es bueno que te familiarices con lo que puedes hacer a través Interface Builder porque así puedes sacar el máximo de él, ya verás en el futuro que hay algunas otras que solo pueden hacerse por código.

Ahora agregamos un botón, este será el que el usuario debe presionar para recibir el mensaje de saludo. Igualmente puedes hacerle los cambios que quieras, yo voy a agrandarlo un poco para que sea más fácil de seleccionar.

Ahora solo hace falta agregar un Label para mostrarle el mensaje de saludo al usuario.

Yo le coloqué un mensaje desde el inspector solo para saber donde está. Sin texto el label es completamente invisible. Luego por código reemplazaremos este mensaje.

Bien, ya tenemos nuestra interfaz lista, solo falta crear nuestros outlets en el código y conectarlos con la vista. La manera más fácil de hacerlo es la siguiente:

Seleccionamos el editor asistente para que Xcode coloque lado a lado, la vista y la clase controladora.

Si su pantalla es pequeña como la que estoy usando en este momento (Macbook Pro 13') y el panel izquierdo de Interface Builder (Document Outline) les molesta, pueden colapsarlo haciendo click en el botón de la esquina inferior izquierda.

Si en el editor que aparece del lado derecho no muestra el header file: ViewController.h, puedes navegar hasta él haciendo click en el navegador superior del editor.

Manteniendo la tecla control presionada, hacemos click sobre el text field y arrastramos hasta el editor del lado derecho.

Entonces aparecerá una pequeña ventana preguntándonos:

[][11]

El tipo de conexión: Seleccionamos Outlet

El nombre del atributo que vamos a crear: Yo lo llamé nameField, tu puedes llamarlo como quieras.

En el tipo dejamos: UITextField, este es un objeto de UIKit, el framework de apple que contiene todos los elementos de interfaz gráfica de iOS. UITextField representa un campo de texto en código.

Y por último, Storage, lo dejamos en weak, todos los elementos de interfaz gráfica deberían ser weak. ¿Por qué?. Esto lo estaré explicando en el tutorial de manejo de memoria del curso Objective-C desde Cero.

Repetimos el mismo proceso para el label. yo llamaré el outlet messageLabel.

Para el botón, el proceso es similar, solo que con una ligera diferencia. En lugar de seleccionar outlet para el tipo de conexión, seleccionamos Action. Esto es porque no queremos al botón en nuestro código, no vamos a modificar ninguna de sus propiedades. Lo que queremos es recibir el evento de cuando sea presionado por el usuario.

Seleccionamos Action entonces como dijimos anteriormente.

Le colocamos un nombre al metodo que será llamado cuando se dispare este evento. Yo lo llamé buttonSelected

En Type seleccionamos UIButton, podría ser id, pero yo prefiero tener el botón. Cuando el evento se dispare podemos recibir al botón como argumento del método, por eso prefiero recibirlo como UIButton en lugar de id, así evito tener que hacer un casting (casteo, convertirlo, etc). "id" es el tipo de objeto general de Objective-C, un "id" puede ser cualquier objeto, es como el "var" de C#

El evento será TouchUpInside, esto significa que el método será llamado cuando el usuario levante el dedo luego de presionar el botón.

En Arguments, seleccionamos none, en este caso no vamos a hacer nada con el botón, solo recibir el evento. En algunos casos podrías necesitar recibir el botón, por ejemplo: para cambiarle el titulo, cambiarle el color, cuando es presionado. Este no es el caso, así que lo dejamos en none.

Ahora, si todo salió bien, tu código debería lucir así:

```obj-c
#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UITextField *nameField;
@property (weak, nonatomic) IBOutlet UILabel *messageLabel;

- (IBAction)buttonSelected;

@end
```

Y del lado izquierdo del editor del código, deberías ver unos pequeños círculos rellenos, al lado de tus outlets. Esto significa que han sido conectados correctamente.

Programando el controlador

Bien, ahora vamos a la implementación del controlador, seleccionamos ViewController.m del navegador de archivos.

En este momento debes estar preguntándote, ¿Qué demonios es esto?. Ok, en Objective-C las clases se separan en archivos .h y .m.

Los archivos .h son los Header File. Estos son los que revelan los atributos y métodos que serán públicos al resto de la aplicación.

Los archivos .m resguardan la implementación de los métodos que anunciamos en el Header. Todos los métodos o propiedades que estén en este archivo y no estén anunciados en el Header, serán privados.

    ¡Alerta!

 Más sobre orientación a objetos será explicado con mayor detalle en el curso

  Objective-C desde Cero.

Entonces si abres el .m deberías ver el siguiente código:

```obj-c
#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

- (IBAction)buttonSelected {
}

@end
```

Nos encontramos con 3 métodos que Xcode ha generado para nosotros.

viewDidLoad: Este método lo tienen todos los controladores en iOS. Este método es llamado cada vez que la aplicación termina de cargar la vista. Esto significa que ya ha leído el archivo .xib y esta lista para mostrarla en la pantalla. Más sobre el ciclo de vida de una vista puede verse en la documentación.

didReceiveMemoryWarning: este método también lo tienen todos los UIViewControllers, es llamado cuando se recibe una alerta de memoria. En su implementación deberías liberar toda la memoria que tu aplicación este consumiendo y pueda ser liberada para evitar que se caiga.

buttonSelected, este es el metodo que generamos para ser llamado cuando se dispare el evento TouchUpInside del botón.

Entonces en este último método deberíamos captar el nombre que el usuario introdujo en el text field y desplegarlo en el mensaje que va en el label. Esto lo hacemos de la siguiente manera:

Primero creamos un string con el mensaje y el nombre que aparece en el text field:

```obj-c
NSString *message = [NSString stringWithFormat:@"Hola, %@", self.nameField.text];
```

NSString es la clase de apple para manejar strings, stringWithFormat es un metodo estático de la clase que retorna un objeto del mismo tipo. En Objective-C, los strings se representan con el carácter "@" como prefijo. "%@" es el formato para representar un objeto dentro de un string (%f representa float, %i un int, %c un char, etc), en este caso el objeto es otro string (esta es una manera de concatenar).

Luego, asignamos el mensaje al label:

```obj-c
[self.messageLabel setText:message];
```

Todo el código junto del método debería verse así:

```obj-c
- (IBAction)buttonSelected {

    NSString *message = [NSString stringWithFormat:@"Hola, %@", self.nameField.text];

    [self.messageLabel setText:message];
}
```

Tal vez te preguntes. Si hablo español, ¿Por qué programo en inglés?. Bueno, esto es una cuestión de estilo, yo prefiero programar en ingles porque la mayoría de las palabras son más cortas y requieren menos conectivos.

Bueno, volviendo al tema...

Ahora corremos la app. Seleccionamos el Text field, escribimos nuestro nombre (podemos usar el teclado de la máquina, no tenemos que usar el del simulador, duh) y hacemos click en el botón. Debería verse así:

Conclusión

¡Felicidades, has escrito tu primera aplicación!. Muy simple, pero es un comienzo. En el próximo tutorial hablaremos del elemento de interfaz más importante (a mi juicio) de iOS, el UITableView.

¡Nos vemos!


text:
@interface PodsDummy_Pods_FitSync : NSObject
@end
@implementation PodsDummy_Pods_FitSync
@end


text:
import unittest
import imp
import glob
import os, sys

# Skip individual modules based on module name.  For example,
# pyupm_ozw will skip pyupm_ozw.py.
blacklist = [
             # OpenZwave-dependent modules
             'pyupm_ozw', 'aeotecdw2e', 'tzemt400', 'aeotecdsb09104',
             'aeotecss6', 'aeotecsdg2', 'ozwdump',
             # Requires mraa python module
             'curieimu',
             # Requires modbus
             'h803x', 'hwxpxx', 't3311',
             # Requires bacnet
             'e50hx', 'tb7300', 't8100',
             # Requires PIL
             'make_oled_pic'
             ]

class loadModule(unittest.TestCase):
    ''' The loadModule class loads all module which match a search string
    provided via argv.  If any of the target modules fails loading, this
    class will assert and provide a list of failing modules.'''
    def test_load_module(self):
        # Python version provided on the command line
        py_search_str = '../build/src/*/python2.7/*.py'
        if len(self.argv) > 0:
           py_search_str = self.argv[0]

        # Make sure the search string has a full path
        full_py_search_str = os.path.realpath(py_search_str)

        # Get all python modules matching full_py_search_str
        pyfiles = glob.glob(full_py_search_str)

        # Fail if no modules to test
        self.assertNotEqual(len(pyfiles), 0,
                'Failed to find any %s modules in %s' % \
                (py_search_str, full_py_search_str));

        # Test load each module
        failures = {}
        for pyfile in pyfiles:
            module = os.path.splitext(os.path.basename(pyfile))[0]

            # Don't load blacklisted modules
            if module in blacklist:
                print('Skipping blacklisted %s ...' % pyfile)
                continue

            # Append the path of this python module
            sys.path.append(os.path.dirname(pyfile))

            try:
                pyfile = imp.load_source(module, pyfile)
            except Exception as x:
                failures[pyfile] = x

        skeys = list(failures.keys())
        skeys.sort()
        self.assertEqual(len(failures), 0,
                '\n\n%s' % '\n'.join((['%s=%s' % (k, os.environ[k]) for k in list(os.environ.keys())])) +
                '\npython %s\n' % ' '.join(sys.version.strip().split()) +
                '\nFailed to load %d modules:\n' % len(failures) +
                '\n'.join(['%s: %s' % (k, failures[k]) for k in skeys]))

if __name__ == '__main__':
    # Allow passing from argv
    loadModule.argv = []
    for arg in sys.argv[1:]:
        loadModule.argv.append(sys.argv.pop())
    unittest.main()


text:
import sys

def get_queens_line_of_sight(Q, maxR, maxC):
    line_of_sight_list = [] # contains all the tuples that are in the line of sight
    # first we get the straight line of sights, both horizontal and vertical.
    for r in xrange(0,maxR):
	line_of_sight_list.append((r, Q[1]))
    for c in xrange(0,maxC):
	line_of_sight_list.append((Q[0], c))
    # diagonals \ and /
    #
    # first \ diagonal
    if Q[0] == Q[1]:
	r,c = 0,0	# row column
    elif Q[0] < Q[1]:	# upper triangle w.r.t middle (n,n) diagonal
	r = 0		# here the r value in tuple is < c value
	c = Q[1] - Q[0]
    else:
	r = Q[0] - Q[1]
	c = 0
    while (r < maxR and c < maxC):
	line_of_sight_list.append((r,c))
	r =  r + 1
	c =  c + 1
    # Now / diagonal, board must be square
    if (Q[0] + Q [1]) <= maxR - 1:
	r = Q[0] + Q[1]
	c = 0
    else:
	rcSum = Q[0] + Q[1]
	r = maxR - 1
	c = rcSum - r
    while (r >= 0 and c < maxC):
	line_of_sight_list.append((r,c))
	r =  r - 1
	c =  c + 1
    # converting to set and back to list removes the
    # duplicates. But it also reshuffels the tupples
    # which makes it difficult to understand the sequence
    # of the tupples in the line of sight.
    #print "Q:", Q, "LoS:", line_of_sight_list
    return list(set(line_of_sight_list))

#c is column number starting with 0. Incidently, the Queen number too.
#board : We use a list of tuples to represent the current state
#of the board with nth tupple specifying the coordinate
#of nth queen.
#We start with placing the 0th queen on 0th column, successively
#increasing n column wise. Obviously, each column
#must have  one and only one queen and no column must have
#0 queens.
# Now we add another list los i.e Line of sight. Instead of
# every time calculating the los for any change in queens position
# we calculate it at the time of queen's placement and add it to
# the field of sight(fos). This fos is next passed to the subsequent
# recusrsions as at n column all the queens < n are going to stay the
# same only the n+1th and subsequent queens change their locations.
# This yields in significant increase in the speed
# Following are the results:
# #Board Squares    #sol    bt		    dp
#  --------------------------------------------------
#   10		     724    0m26.981s	    0m1.545s
#   11		    2680    2m48.230s	    0m6.468s
#   12		   14200   18m31.642s	   0m37.687s
#   13		   73712   Not Executed	   4m05.344s
#   14		  365596   Not Executed	  30m15.249s
def move_next_queen(c, b, R, C, los):
    # We will not change the state of board passed to us but
    # will take a copy of it and change that instead. Thus the
    # state of the board propagates under recursion keeping the
    # actual board intact. This will come in handy to start next
    # round of moves (backtracking) when forward path sees a dead end.
    # b_next = list(b)
    if c < C:
	for r in xrange(0, R):
	    if  not((r,c) in los) :
		#print "Q", c,  "put on Board Position: (", r, ",", c,")"
		b_next = list(b)
		b_next = b_next + list(((r,c),))
		if len(b_next) == R:
		    print "Solution:  ", b_next
		los_next = los + get_queens_line_of_sight((r,c), R,C)
	        move_next_queen (c+1, b_next , R, C, los_next)
	#print "Backtrack to Queen:", c - 1

if len(sys.argv) == 2:
    #print "Board Size:", sys.argv[1]
    move_next_queen(0,[],int(sys.argv[1]), int(sys.argv[1]), [])
else:
    print "Requires board size as a number"