text:
package org.codehaus.mojo.versions;

import javax.inject.Inject;
import javax.xml.stream.XMLStreamException;

import java.io.IOException;
import java.util.Collection;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.manager.WagonManager;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.DependencyManagement;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectBuilder;
import org.apache.maven.repository.RepositorySystem;
import org.codehaus.mojo.versions.api.PomHelper;
import org.codehaus.mojo.versions.api.VersionRetrievalException;
import org.codehaus.mojo.versions.api.recording.ChangeRecorder;
import org.codehaus.mojo.versions.rewriting.ModifiedPomXMLEventReader;

/**
 * Replaces any versions with the corresponding version from the reactor.
 *
 * @author Stephen Connolly
 * @since 2.2
 */
@Mojo( name = "use-reactor", threadSafe = true )
public class UseReactorMojo
    extends AbstractVersionsDependencyUpdaterMojo
{

    // ------------------------------ METHODS --------------------------

    @Inject
    public UseReactorMojo( RepositorySystem repositorySystem,
                           org.eclipse.aether.RepositorySystem aetherRepositorySystem,
                           MavenProjectBuilder projectBuilder,
                           WagonManager wagonManager,
                           ArtifactResolver artifactResolver,
                           Map<String, ChangeRecorder> changeRecorders )
    {
        super( repositorySystem, aetherRepositorySystem, projectBuilder, wagonManager, artifactResolver,
                changeRecorders );
    }

    /**
     * @param pom the pom to update.
     * @throws org.apache.maven.plugin.MojoExecutionException when things go wrong
     * @throws org.apache.maven.plugin.MojoFailureException   when things go wrong in a very bad way
     * @throws javax.xml.stream.XMLStreamException            when things go wrong with XML streaming
     * @see AbstractVersionsUpdaterMojo#update(org.codehaus.mojo.versions.rewriting.ModifiedPomXMLEventReader)
     */
    protected void update( ModifiedPomXMLEventReader pom )
            throws MojoExecutionException, MojoFailureException, XMLStreamException, VersionRetrievalException
    {
        try
        {
            if ( isProcessingParent() && getProject().hasParent() )
            {
                useReactor( pom, getProject().getParent() );
            }
            if ( isProcessingDependencyManagement() )
            {
                DependencyManagement dependencyManagement =
                        PomHelper.getRawModel( getProject() ).getDependencyManagement();
                if ( dependencyManagement != null )
                {
                    useReactor( pom, dependencyManagement.getDependencies() );
                }
            }
            if ( getProject().getDependencies() != null && isProcessingDependencies() )
            {
                useReactor( pom, getProject().getDependencies() );
            }
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( e.getMessage(), e );
        }
    }

    private void useReactor( ModifiedPomXMLEventReader pom, Collection<Dependency> dependencies )
        throws XMLStreamException, MojoExecutionException, VersionRetrievalException
    {

        for ( Dependency dep : dependencies )
        {
            Artifact artifact = this.toArtifact( dep );
            if ( !isIncluded( artifact ) )
            {
                continue;
            }

            for ( MavenProject reactorProject : reactorProjects )
            {
                MavenProject project = reactorProject;
                if ( StringUtils.equals( project.getGroupId(), dep.getGroupId() )
                    && StringUtils.equals( project.getArtifactId(), dep.getArtifactId() )
                    && !StringUtils.equals( project.getVersion(), dep.getVersion() ) )
                {
                    if ( PomHelper.setDependencyVersion( pom, dep.getGroupId(), dep.getArtifactId(), dep.getVersion(),
                                                         project.getVersion(), getProject().getModel() ) )
                    {
                        getLog().info( "Updated " + toString( dep ) + " to version " + project.getVersion() );
                    }
                    break;
                }
            }
        }
    }

    private void useReactor( ModifiedPomXMLEventReader pom, MavenProject parent )
        throws XMLStreamException, VersionRetrievalException
    {
        for ( MavenProject project : reactorProjects )
        {
            if ( StringUtils.equals( project.getGroupId(), parent.getGroupId() )
                && StringUtils.equals( project.getArtifactId(), parent.getArtifactId() )
                && !StringUtils.equals( project.getVersion(), parent.getVersion() ) )
            {
                if ( PomHelper.setProjectParentVersion( pom, project.getVersion() ) )
                {
                    getLog().info( "Updated parent " + toString( parent ) + " to version " + project.getVersion() );
                }
            }

        }
    }

}


text:
<?php
Layout::extend('layouts/text');
$title = 'Index';
?>

<?php echo Html::anchor(Url::action('textController::newForm'), 'Create New text') ?>

<?php if(isset($flash)): ?>

	<?php echo $flash; ?>

<?php endif; ?>

<?php foreach($textSet as $text): ?>
	<?php Part::draw('text/details', $text) ?>

<?php endforeach; ?>

redpajama_set_name: RedPajamaGithub


text:
package org.finra.herd.rest;

import io.swagger.annotations.Api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.annotation.Secured;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import org.finra.herd.model.api.xml.BusinessObjectDataNotificationRegistration;
import org.finra.herd.model.api.xml.BusinessObjectDataNotificationRegistrationCreateRequest;
import org.finra.herd.model.api.xml.NotificationRegistrationKey;
import org.finra.herd.model.api.xml.BusinessObjectDataNotificationRegistrationKeys;
import org.finra.herd.model.api.xml.BusinessObjectDataNotificationRegistrationUpdateRequest;
import org.finra.herd.model.dto.SecurityFunctions;
import org.finra.herd.service.BusinessObjectDataNotificationRegistrationService;
import org.finra.herd.ui.constants.UiConstants;

/**
 * The REST controller that handles business object data notification REST requests.
 */
@RestController
@RequestMapping(value = UiConstants.REST_URL_BASE, produces = {"application/xml", "application/json"})
@Api(tags = "Business Object Data Notification Registration")
public class BusinessObjectDataNotificationRegistrationRestController extends HerdBaseController
{
    public static final String BUSINESS_OBJECT_DATA_NOTIFICATIONS_URI_PREFIX = "/notificationRegistrations/businessObjectDataNotificationRegistrations";

    @Autowired
    private BusinessObjectDataNotificationRegistrationService businessObjectDataNotificationRegistrationService;

    /**
     * Creates a new business object data notification.
     *
     * @param request the information needed to create the business object data notification
     *
     * @return the created business object data notification
     */
    @RequestMapping(value = BUSINESS_OBJECT_DATA_NOTIFICATIONS_URI_PREFIX, method = RequestMethod.POST, consumes = {"application/xml", "application/json"})
    @Secured(SecurityFunctions.FN_BUSINESS_OBJECT_DATA_NOTIFICATION_REGISTRATIONS_POST)
    public BusinessObjectDataNotificationRegistration createBusinessObjectDataNotificationRegistration(
        @RequestBody BusinessObjectDataNotificationRegistrationCreateRequest request)
    {
        return businessObjectDataNotificationRegistrationService.createBusinessObjectDataNotificationRegistration(request);
    }

    /**
     * Updates an existing business object data notification by key.
     *
     * @param namespace the namespace
     * @param notificationName the business object data notification name
     * @param request the information needed to update the business object data notification
     *
     * @return the updated business object data notification
     */
    @RequestMapping(value = BUSINESS_OBJECT_DATA_NOTIFICATIONS_URI_PREFIX + "/namespaces/{namespace}/notificationNames/{notificationName}",
        method = RequestMethod.PUT)
    @Secured(SecurityFunctions.FN_BUSINESS_OBJECT_DATA_NOTIFICATION_REGISTRATIONS_PUT)
    public BusinessObjectDataNotificationRegistration updateBusinessObjectDataNotificationRegistration(@PathVariable("namespace") String namespace,
        @PathVariable("notificationName") String notificationName, @RequestBody BusinessObjectDataNotificationRegistrationUpdateRequest request)
    {
        return businessObjectDataNotificationRegistrationService.updateBusinessObjectDataNotificationRegistration(new NotificationRegistrationKey(namespace,
            notificationName), request);
    }

    /**
     * Gets an existing business object data notification by key.
     *
     * @param namespace the namespace
     * @param notificationName the business object data notification name
     *
     * @return the retrieved business object data notification
     */
    @RequestMapping(value = BUSINESS_OBJECT_DATA_NOTIFICATIONS_URI_PREFIX + "/namespaces/{namespace}/notificationNames/{notificationName}",
        method = RequestMethod.GET)
    @Secured(SecurityFunctions.FN_BUSINESS_OBJECT_DATA_NOTIFICATION_REGISTRATIONS_GET)
    public BusinessObjectDataNotificationRegistration getBusinessObjectDataNotificationRegistration(@PathVariable("namespace") String namespace,
        @PathVariable("notificationName") String notificationName)
    {
        return businessObjectDataNotificationRegistrationService
            .getBusinessObjectDataNotificationRegistration(new NotificationRegistrationKey(namespace, notificationName));
    }

    /**
     * Deletes an existing business object data notification by key.
     *
     * @param namespace the namespace
     * @param notificationName the business object data notification name
     *
     * @return the business object data notification that got deleted
     */
    @RequestMapping(value = BUSINESS_OBJECT_DATA_NOTIFICATIONS_URI_PREFIX + "/namespaces/{namespace}/notificationNames/{notificationName}",
        method = RequestMethod.DELETE)
    @Secured(SecurityFunctions.FN_BUSINESS_OBJECT_DATA_NOTIFICATION_REGISTRATIONS_DELETE)
    public BusinessObjectDataNotificationRegistration deleteBusinessObjectDataNotification(@PathVariable("namespace") String namespace,
        @PathVariable("notificationName") String notificationName)
    {
        return businessObjectDataNotificationRegistrationService
            .deleteBusinessObjectDataNotificationRegistration(new NotificationRegistrationKey(namespace, notificationName));
    }

    /**
     * Gets the list of business object data notifications that are defined in the system.
     *
     * @return the retrieved business object data notification list
     */
    @RequestMapping(value = BUSINESS_OBJECT_DATA_NOTIFICATIONS_URI_PREFIX + "/namespaces/{namespace}", method = RequestMethod.GET)
    @Secured(SecurityFunctions.FN_BUSINESS_OBJECT_DATA_NOTIFICATION_REGISTRATIONS_ALL_GET)
    public BusinessObjectDataNotificationRegistrationKeys getBusinessObjectDataNotificationRegistrations(@PathVariable("namespace") String namespace)
    {
        return businessObjectDataNotificationRegistrationService.getBusinessObjectDataNotificationRegistrations(namespace);
    }
}


text:
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>Browser Example</title>
  <script src="dist/datadog-tracer.min.js"></script>
</head>
<body>
  <button id="trace" type="button">Send Trace</button>
  <script>
    var tracer = new DatadogTracer({
      service: 'example',
      hostname: window.location.hostname,
      port: 8080
    })

    document.getElementById('trace').addEventListener('click', function () {
      var span = tracer.startSpan('browser.request')

      span.addTags({
        'resource': window.location.pathname,
        'type': 'web',
        'span.kind': 'client'
      })

      span.finish()
    })
  </script>
</body>
</html>


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>{{ page.title }}</title>
    <meta name="viewport" content="width=device-width">

    <link rel="stylesheet" href="/css/syntax.css">

    <link rel="stylesheet" href="/css/main.css">

{{ site.name }}

            home
            cv

        {{ content }}

                    Nasrin Mohammadi

                    nasrin.mohammadi@gmail.com

                    github.com/to change

                    twitter.com/to change

                    viadeo.com/to change

                    linkedin.com/to change


text:
package com.tle.core.item.event;

import com.tle.beans.item.ItemIdKey;
import com.tle.core.events.ApplicationEvent;
import com.tle.core.item.event.listener.WaitForItemIndexListener;

/** @author Nicholas Read */
public class WaitForItemIndexEvent extends ApplicationEvent<WaitForItemIndexListener> {
  private static final long serialVersionUID = 1L;
  private ItemIdKey itemIdKey;

  public WaitForItemIndexEvent(ItemIdKey itemIdKey) {
    super(PostTo.POST_TO_SELF_SYNCHRONOUSLY);
    this.itemIdKey = itemIdKey;
  }

  public ItemIdKey getItemIdKey() {
    return itemIdKey;
  }

  @Override
  public Class<WaitForItemIndexListener> getListener() {
    return WaitForItemIndexListener.class;
  }

  @Override
  public void postEvent(WaitForItemIndexListener listener) {
    listener.waitForItem(this);
  }
}


text:
namespace net {
class URLFetcher;
class URLRequestContextGetter;
}  // namespace net

namespace content {

namespace {

// Allow up to 10MB for trace upload
const int kMaxUploadBytes = 10000000;

}  // namespace

// TraceUploader uploads traces.
class TraceUploader : public net::URLFetcherDelegate {
 public:
  typedef base::Callback<void(bool, const std::string&, const std::string&)>
      UploadDoneCallback;
  typedef base::Callback<void(int64, int64)> UploadProgressCallback;

  TraceUploader(const std::string& product,
                const std::string& version,
                const std::string& upload_url,
                net::URLRequestContextGetter* request_context);
  ~TraceUploader() override;

  // net::URLFetcherDelegate implementation.
  void OnURLFetchComplete(const net::URLFetcher* source) override;
  void OnURLFetchUploadProgress(const net::URLFetcher* source,
                                int64 current,
                                int64 total) override;

  // Compresses and uploads the given file contents.
  void DoUpload(const std::string& file_contents,
                UploadProgressCallback progress_callback,
                UploadDoneCallback done_callback);

 private:
  // Sets up a multipart body to be uploaded. The body is produced according
  // to RFC 2046.
  void SetupMultipart(const std::string& trace_filename,
                      const std::string& trace_contents,
                      std::string* post_data);
  void AddTraceFile(const std::string& trace_filename,
                    const std::string& trace_contents,
                    std::string* post_data);
  // Compresses the input and returns whether compression was successful.
  bool Compress(std::string input,
                int max_compressed_bytes,
                char* compressed_contents,
                int* compressed_bytes);
  void CreateAndStartURLFetcher(const std::string& post_data);
  void OnUploadError(std::string error_message);

  std::string product_;
  std::string version_;

  std::string upload_url_;

  scoped_ptr<net::URLFetcher> url_fetcher_;
  UploadProgressCallback progress_callback_;
  UploadDoneCallback done_callback_;

  net::URLRequestContextGetter* request_context_;

  DISALLOW_COPY_AND_ASSIGN(TraceUploader);
};

}  // namespace content

#endif  // CONTENT_BROWSER_TRACING_TRACE_UPLOADER_H_


text:
/**********************************************************************/
/* Copyright 2013 KRV                                                 */
/*                                                                    */
/* Licensed under the Apache License, Version 2.0 (the "License");    */
/* you may not use this file except in compliance with the License.   */
/* You may obtain a copy of the License at                            */
/*                                                                    */
/*  http://www.apache.org/licenses/LICENSE-2.0                        */
/*                                                                    */
/* Unless required by applicable law or agreed to in writing,         */
/* software distributed under the License is distributed on an        */
/* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,       */
/* either express or implied.                                         */
/* See the License for the specific language governing permissions    */
/* and limitations under the License.                                 */
/**********************************************************************/
package ui.graphical;

// Default Libraries
import java.io.IOException;
import java.util.ArrayList;
import java.util.WeakHashMap;

// Graphical Libraries (AWT)
import java.awt.*;
import java.awt.event.*;
import java.awt.TexturePaint;
import java.awt.image.BufferedImage;

// Graphical Libraries (Swing)
import javax.swing.*;
import javax.swing.border.*;
import javax.imageio.ImageIO;
import javax.swing.SwingUtilities;

// Libraries
import arena.Map;
import parameters.*;
import arena.Robot;
import players.Player;
import scenario.Scenario;
import stackable.Direction;
import stackable.item.Item;

// Import links
import static parameters.Game.*;

/**
 * Graphical - Panel

 * Creates the main panel to exhibit
 * the map.
 * @see Graphical
 * @see arena.Map
 * @see arena.World
 *
 * @author Renato Cordeiro Ferreira
 * @author Vinicius Silva
 */
class Panel extends JLayeredPane
{
    // Map made with cells
    private Cell[][] cell = new Cell[MAP_SIZE][MAP_SIZE];

    // Local variables
    private Map       map;
    private Player    player;
    private Graphical gui;

    // Paint utils
    private int[] update  = new int[2];
    private Direction dir;
    private WeakHashMap<Robot,JRobot> robots
        = new WeakHashMap<Robot,JRobot>();

    // Paint auxiliars
    private Phase phase;
    private int   nTS;
    private int   nPlayers;
    private int   nRobots;

    // Show or not scenarios/items
    boolean hide = false;

    /**
     * Create a Panel with dimensions width x height,
     * containing MAP_SIZE² hexagons (built from a map).
     * @see Cell
     * @see Graphical
     *
     * @param gui    Graphical set in which the
     *               Panel is set
     * @param map    Map over which the panel will
     *               create the GUI hexagons
     * @param player Player who is visualizing the
     *               panel (for his specific view)
     * @param R      Hexagon radius
     * @param y0     Desired vertical shift
     * @param width  Desired width of the screen
     * @param height Desired height of the screen
     */
    Panel(Graphical gui, Map map, Player player,
          int R, int x0, int y0, int width, int height, boolean hide)
    {
        // Store game attributes
        this.gui      = gui;
        this.map      = map;
        this.player   = player;

        // Initializes auxiliar variable
        try { this.dir = new Direction(""); }
        catch(Exception e)
        {
            System.err.println("[PANEL] This sould never happen...");
            e.printStackTrace();
        }

        // Preferences
        this.setOpaque        (true);
        this.setLayout        (null);
        this.setBackground    (Color.black);
        this.setPreferredSize (new Dimension(width, height));

        // Initial phase: active
        this.phase = Phase.ACTIVE;

        // Put images in the screen
        int Dx = (int) ( 2*R * Math.sin(Math.PI/3) );
        int Dy = 3 * R/2 +1;

        // Build a grid of cells
        int Δ  = 0;
        for (int i = 0; i < MAP_SIZE; i++)
            for (int j = 0; j < MAP_SIZE; j++)
            {
                cell[i][j] = new Cell(
                    this.player,       // Player
                    x0 + Δ + R + i*Dx, // Horizontal position
                    y0 + R + j*Dy,     // Vertical position
                    R,                 // Hexagon radius
                    map.map[j][i]      // Terrain in map[j,i]
                );
                Δ = (Δ == 0) ? Dx/2 : 0;

                // Add statical events
                if(!hide) this.add(cell[i][j].invs, Level.FOG.get());
                if(!hide) this.add(cell[i][j].hit,  Level.BATTLE.get());
            }

        // Visibility around player's bases
        int X = this.player.getBase().getPosX(this.player);
        int Y = this.player.getBase().getPosY(this.player);
        this.setVisible(X,Y,3);
    }

    /**
     * Paint hexagons on the screen.

     * At each step, repaint the cells
     * as they need changes.
     * @param g Graphic object with all context
     *          needed to render the image
     */
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);

        // First, update player's visibility
        this.blinkVisibility();

        // Then, draw all the background without Fog War
        this.paintMap(g);

        // Remove all GUI elements, mainly the robots power/HP bars
        for(java.util.Map.Entry<Robot, JRobot> entry : robots.entrySet())
            entry.getValue().remove();

        // Finally, print accordingly the state
        switch(this.phase)
        {
            case LOOSER: if(!hide) looser(g);    break;
            case WINNER: if(!hide) winner(g);    break;
            case ACTIVE: if(!hide) paintLife(g); break;
        }
    }

    /**
     * Set if the scenarios and items
     * should or not be showed.
     * @param show True if show invisible mask and
     *             scenarios, false otherwise
     */
    void hide(boolean show)
    {
        hide = show;
    }

    /**
     * Load info about the game phase.

     * @param phase    Game phase
     * @param nTS      Number of time steps since
     *                 the beggining of the game
     * @param nPlayers Number of players
     * @param nRobots  Number of robots created by
     *                 all players along the game
     */
    void setGamePhase(
        Phase phase, int nTS, int nPlayers, int nRobots)
    {
        this.nTS      = nTS;
        this.phase    = phase;
        this.nRobots  = nRobots;
        this.nPlayers = nPlayers;
    }

    /**
     * Auxiliar function for painting the
     * hexagonal grid arena of the game.
     * @param g Game graphical context
     */
    private void paintMap(Graphics g)
    {
        for (int i = 0; i < MAP_SIZE; i++)
            for (int j = 0; j < MAP_SIZE; j++)
                cell[i][j].draw(g);
    }

    /**
     * Auxiliar function for painting all
     * the elements over the arena.
     * @param g Game graphical context
     */
    private void paintLife(Graphics g)
    {
        for (int i = 0; i < MAP_SIZE; i++)
            for (int j = 0; j < MAP_SIZE; j++)
            {
                // Get fog war (and print properly)
                boolean fog = cell[i][j].terrain.getFogWar(this.player);
                cell[i][j].hit.setVisible(false);

                // Print items and scenarios if there is no fog
                if(fog) continue;

                item(i, j); // Items (crystals, stones...)
                scen(i, j); // Scenarios (robots, trees, rocks...)

                // Invisibility
                boolean vis = cell[i][j].terrain.getVisibility(this.player);
                if(!vis) cell[i][j].invs.setVisible(true);
                else cell[i][j].invs.setVisible(false);
            }
    }

    /**
     * Make all terrains invisible and, then, set the visibility
     * for this new step (around player's stuff).
     */
    private void blinkVisibility()
    {
        // Hide all the map
        for(int i = 0; i < MAP_SIZE; i++)
            for(int j = 0; j < MAP_SIZE; j++)
                cell[i][j].terrain.setInvisible(this.player);

        // But let the base's around be visible
        int X = this.player.getBase().getPosX(this.player);
        int Y = this.player.getBase().getPosY(this.player);
        this.setVisible(X,Y,7);

        // And the player's robots
        for(Robot r: this.player.armies)
            this.setVisible(r.getPosX(), r.getPosY(), r.getSight() * 2);
    }

    /**
     * Auxiliar method for making an area visible
     * (which takes out Fog War and shows all scenarios).
     * @param X Horizontal position
     * @param Y Vertical position
     * @param S Sight (radius) of the area to be set visible
     */
    private void setVisible(int X, int Y, int S)
    {
        if(X < 0 || X >= MAP_SIZE) return;
        if(Y < 0 || Y >= MAP_SIZE) return;

        cell[X][Y].terrain.setVisible(this.player);

        if(S == 0) return;

        try {
            for(int k = 1; k <= 6; k++)
            {
                dir.set(k); update = dir.get(Y);
                if(X + update[1] < 0 || X + update[1] >= MAP_SIZE) continue;
                if(Y + update[0] < 0 || Y + update[0] >= MAP_SIZE) continue;
                setVisible(X + update[1], Y + update[0], S-1);
            }

        } catch(Exception e) {
            System.err.println("[PANEL] (setVisible) This sould never happen...");
            e.printStackTrace();
        }
    }

    /**
     * Auxiliar function for painting a
     * scenario over a terrain in the game.
     * @param i Vertical position of the scenario
     * @param j Horizontal position of the scenario
     */
    private void scen(int i, int j)
    {
        Cell hex = cell[i][j];
        int x = hex.x, y = hex.y;
        boolean vis = hex.terrain.getVisibility(this.player);

        if(!vis) return;

        Scenario s = hex.terrain.getScenario();
        if(s != null)
        {
            // Special treatment for robots
            if(s instanceof Robot)
            {
                // Get the robot and its animation phase
                Robot r = (Robot) s;

                // Add new JRobots for new Robots
                if(!this.robots.containsKey(r))
                    this.robots.put(r, new JRobot(r));

                // Add JRobot in the Panel
                robots.get(r).add(x, y);
            }
            else if(hex.scen == null) // && s is not robot
            {
                hex.insertScenario();
                this.add(hex.scen, Level.NATURE.get());
                this.moveToFront(hex.scen);
            }

            // When something is being hit, show it!
            if(s.sufferedDamage()) hex.hit.setVisible(true);

        } // s != null
        else if(hex.scen != null) // && s == null
        {
            this.remove(hex.scen);
            hex.scen = null;
        }
    }

    /**
     * Auxiliar function for painting an
     * item over a terrain in the game.
     * @param g Game graphical context
     * @param i Vertical position of the item
     * @param j Horizontal position of the item
     */
    private void item(int i, int j)
    {
        Cell hex = cell[i][j];

        // Print items
        if(hex.item != null && hex.terrain.getItem() == null)
        {
            this.remove(hex.item);
            hex.item = null;
        }
        if(hex.terrain.getItem() != null && hex.item == null)
        {
            hex.insertItem();
            this.add(hex.item, Level.ITEM.get());
        }
    }

    /**
     * Paints message to the looser user.
     * @param g Game graphical context
     */
    private void looser(Graphics g)
    {
        // Useful variables
        int H = this.getHeight(), W = this.getWidth();
        int hH = H/2, hW = W/2; // Half Height/Width

        // Paint background
        this.paintMap(g);

        // Painting strip
        g.setColor(Color.WHITE);
        g.fillRect(65, hH-60, W-130, 190);

        // Painting label
        g.setColor(Color.RED);
        g.setFont(new Font("Arial Black", Font.BOLD, 50));
        g.drawString(this.player + ", YOU LOOSE!", hW-300, hH + 35);

        // Paint all the label
        paintEdge(g);
    }

    /**
     * Paints message to the winner user.
     * @param g Game graphical context
     */
    private void winner(Graphics g)
    {
        // Useful variables
        int H = this.getHeight(), W = this.getWidth();
        int hH = H/2, hW = W/2; // Half Height/Width

        // Paint background
        this.paintMap(g);

        // Painting the strip
        g.setColor(Color.WHITE);
        g.fillRect(65, hH-60, W-130, 190);

        // Painting the label
        g.setColor(Color.BLUE);
        g.setFont(new Font("Arial Black", Font.BOLD, 50));
        g.drawString(this.player + ", YOU WIN!", hW-280, hH-15);

        // Painting game's info
        g.setColor(Color.GREEN);
        g.setFont(new Font("Arial Black", Font.BOLD, 30));
        g.drawString("Number of Steps: "   + this.nTS,      hW-280, hH+35);
        g.drawString("Number of Players: " + this.nPlayers, hW-280, hH+66);
        g.drawString("Number of Robots: "  + this.nRobots,  hW-280, hH+97);

        // Paint all the label
        paintEdge(g);
    }

    /**
     * Auxiliar method for printing a border around
     * both winner and looser player messages.
     * @param g Game graphical context
     */
    private void paintEdge(Graphics g)
    {
        // Useful variables
        int H = this.getHeight(), W = this.getWidth();
        int hH = H/2, hW = W/2; // Half Height/Width

        // Painting the border
        Graphics2D g2d = (Graphics2D) g;

        // Draw red robots
        Image red = Images.RED_ROBOT.img().getSubimage(0, 32, 32, 32);

        g2d.drawImage(red,   28,     hH - 65,  null);
        g2d.drawImage(red,   28,     hH + 5 ,  null);
        g2d.drawImage(red,   28,     hH + 75,  null);

        g2d.drawImage(red,   W - 60, hH - 65,  null);
        g2d.drawImage(red,   W - 60, hH + 5 ,  null);
        g2d.drawImage(red,   W - 60, hH + 75,  null);
        g2d.drawImage(red,   W - 60, hH + 145, null);

        // Draw black robots
        Image black = Images.BLACK_ROBOT.img().getSubimage(0, 64, 32, 32);

        g2d.drawImage(black, 28,     hH - 30,  null);
        g2d.drawImage(black, 28,     hH + 40,  null);
        g2d.drawImage(black, 28,     hH + 110, null);

        g2d.drawImage(black, W - 60, hH - 100, null);
        g2d.drawImage(black, W - 60, hH - 30,  null);
        g2d.drawImage(black, W - 60, hH + 40,  null);
        g2d.drawImage(black, W - 60, hH + 110, null);

        // Draw both robots
        for(int i = 28; i < (W-93); i += 35)
        {
            g2d.drawImage(black, i, hH - 100, null);
            g2d.drawImage(red  , i, hH + 145, null);
        }
    }

    /**
     * Panel - Level
     * Auxiliar enum for the levels
     * in which the elements will be
     * displayed inside the Panel.
     */
    enum Level
    {
        FOG    (7),
        LABEL  (6),
        BATTLE (5),
        NATURE (4),
        TECH   (3),
        ITEM   (2),
        BAR    (1);

        // Integer representing the level
        private Integer level;

        /**
         * Default contructor.

         * @param l Level
         */
        private Level(int l) { this.level = new Integer(l); }

        /**
         * Getter for the level.
         * @return Integer with the level of the element
         */
        Integer get() { return this.level; }
    }

    /**
     * Panel - JRobot

     * Print a robot exhibiting a
     * status bar and other useful
     * info for the player.
     */
    private class JRobot
    {
        // Configurations
        private Dimension size = new Dimension(30,5); // Bar size

        // Parameters
        private Robot robot;

        // Graphical context
        private Images scen;

        // Position info
        private int x, y, x0, y0;

        // Additional info for settings
        private int maxHP;
        private int maxPower;

        // Graphical Components
        private JLabel name;
        private JLabel jrobot;
        private JProgressBar hp;
        private JProgressBar power;

        private boolean exhibitName = false;

        /**
         * Default Constructor.
         * @param robot Robot to be stored
         */
        JRobot(Robot robot)
        {
            // Stores parameters in attributes
            this.robot = robot;
            this.scen  = Images.valueOf(
                this.robot.name(), this.robot.getTeam()
            );

            // Creates and sets its image
            this.jrobot = new JLabel();

            // Creates label to the name
            this.name = new JLabel(this.robot.toString());
            this.name.setOpaque(true);
            this.name.setForeground(Color.WHITE);
            this.name.setBackground(Color.BLACK);

            this.jrobot.addMouseListener(new MouseAdapter()
            {
                @Override
                public void mouseEntered(MouseEvent e) {
                    JRobot.this.exhibitName = true;
                }
                @Override
                public void mouseExited(MouseEvent e) {
                    JRobot.this.exhibitName = false;
                }
                @Override
                public void mouseClicked(MouseEvent e){
                    if(e.getClickCount() >= 2)
                    {
                        String path = JRobot.this.robot.getPathToProg();
                        Panel.this.gui.editorFrame.loadFile   (JRobot.this.robot, path);
                        Panel.this.gui.editorFrame.setVisible (true);
                    }
                }
            });

            // Creates and sets HP bar
            this.maxHP = robot.getMaxHP       ();
            this.hp = new JProgressBar        ();
            this.hp.setMaximum                (this.maxHP    );
            this.hp.setPreferredSize          (this.size     );
            this.hp.setForeground             (Color.BLUE    );

            // Creates and sets Power bar
            this.maxPower = robot.getMaxPower ();
            this.power = new JProgressBar     ();
            this.power.setMaximum             (this.maxPower );
            this.power.setPreferredSize       (this.size     );
            this.hp.setForeground             (Color.GREEN   );
        }

        /**
         * Add bars in the Panel.

         */
        protected void add(int x, int y)
        {
            // Original positions
            this.x = x; this.y = y;

            // Updated positions
            this.x0 = x-this.scen.dx();
            this.y0 = y-this.scen.dy();

            // Painting
            this.paintRobot();
            this.paintBars();
            this.paintName();
        }

        /**
         * Remove bars from the Panel.

         */
        protected void remove()
        {
            Panel.this.remove(this.hp);
            Panel.this.remove(this.name);
            Panel.this.remove(this.power);
            Panel.this.remove(this.jrobot);
        }

        /**
         * Paint label with robot name
         * in its new position.
         */
        private void paintName()
        {
            if(!this.exhibitName) return;
            Dimension d = this.name.getPreferredSize();
            int W = (int) d.getWidth(), H = (int) d.getHeight();
            // TODO: Take out hardcoded constants
            this.name.setBounds   (x-W/2, y+20, W, H);
            this.name.setLabelFor (this.jrobot);
            Panel.this.add        (this.name, Level.LABEL.get());
        }

        /**
         * Paint robot in its new position.
         */
        private void paintRobot()
        {
            // Set new JRobot info
            int[] phase = this.robot.getPhase();

            BufferedImage img = this.scen.img().getSubimage(phase[0], phase[1], 32, 32);
            ImageIcon ico = new ImageIcon(img);
            this.jrobot.setIcon   (ico);
            this.jrobot.setBounds (x0, y0, 32, 32);
            Panel.this.add        (jrobot, Level.TECH.get());
            Panel.this.moveToFront(jrobot);

            // Update robot's position
            this.robot.setPhase(32, phase[1]);
        }

        /**
         * Update bars with infos exhibited by a robot.
         */
        private void paintBars()
        {
            int hp    = this.robot.getHP    ();
            int power = this.robot.getPower ();

            // Update Color Scheme
            this.updateColorScheme(this.hp, this.maxHP);

            try  {
                // Configure and paint hp bar
                this.hp.setBounds    (x0, y0-15, size.width, size.height);
                this.hp.setValue     (hp);

                // Configure and paint power bar
                this.power.setBounds (x0, y0-10, size.width, size.height);
                this.power.setValue  (power);

            } catch(java.lang.IllegalArgumentException e) {
                // TODO: Nothing to do - the program still works
            }

            // Add HP and Power bars
            Panel.this.add(this.hp,    Level.BAR.get());
            Panel.this.add(this.power, Level.BAR.get());
        }

        /**
         * Updates the color of a given bar.

         * If greater than 2/3, paint in GREEN. If lower
         * than 1/3, paint RED. Otherwise, use YELLOW.
         * @param pb  JProgressBar
         * @param max Maximum value to be used as parameter
         *            to the tresholds of each color region
         */
        private void updateColorScheme(JProgressBar pb, int max)
        {
            double per = max * pb.getPercentComplete();
            Color c = Color.YELLOW;
            if(per > 2.0/3 * max) c = Color.GREEN;
            if(per < 1.0/3 * max) c = Color.RED;
            pb.setForeground(c);
        }
    }
}


text:
<?php

class LocationsSeeder extends Seeder {

	/**
	 * Run the database seeds.
	 *
	 * @return void
	 */
	public function run()
	{
		foreach (Config::get('buildings') as $building)
		{
			Building::create($building);
		}
	}

}


text:
package antlr.debug;

public interface ParserListener extends SemanticPredicateListener,
										ParserMatchListener,
										MessageListener,
										ParserTokenListener,
										TraceListener,
										SyntacticPredicateListener {
}


text:
webpackJsonp([4],{

/***/ "./app/components/Print/index.js":
/***/ function(module, exports, __webpack_require__) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__("./node_modules/react/react.js");
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_styled_components__ = __webpack_require__("./node_modules/styled-components/dist/styled-components.es.js");
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__styles_css__ = __webpack_require__("./app/components/Print/styles.css");
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__styles_css___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2__styles_css__);
var _jsx = function () { var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7; return function createRawReactElement(type, props, key, children) { var defaultProps = type && type.defaultProps; var childrenLength = arguments.length - 3; if (!props && childrenLength !== 0) { props = {}; } if (props && defaultProps) { for (var propName in defaultProps) { if (props[propName] === void 0) { props[propName] = defaultProps[propName]; } } } else if (!props) { props = defaultProps || {}; } if (childrenLength === 1) { props.children = children; } else if (childrenLength > 1) { var childArray = Array(childrenLength); for (var i = 0; i < childrenLength; i++) { childArray[i] = arguments[i + 3]; } props.children = childArray; } return { $$typeof: REACT_ELEMENT_TYPE, type: type, key: key === undefined ? null : '' + key, ref: null, props: props, _owner: null }; }; }();

var _templateObject = _taggedTemplateLiteral(['\n  text-align:center;\n'], ['\n  text-align:center;\n']),
    _templateObject2 = _taggedTemplateLiteral(['\n  display:block;\n  text-align:center;\n  background:#5cbfdc;\n  color:#fff;\n  text-decoration:none;\n  border-radius:5px;\n  margin:1em;\n  padding:1em;\n  &:hover {\n    cursor:pointer;\n    background:#085FFF;\n  }\n'], ['\n  display:block;\n  text-align:center;\n  background:#5cbfdc;\n  color:#fff;\n  text-decoration:none;\n  border-radius:5px;\n  margin:1em;\n  padding:1em;\n  &:hover {\n    cursor:pointer;\n    background:#085FFF;\n  }\n']);

function _taggedTemplateLiteral(strings, raw) { return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }

/**
*
* Print
*
*/

var ImageContainer = __WEBPACK_IMPORTED_MODULE_1_styled_components__["a" /* default */].div(_templateObject);
var PrintLink = __WEBPACK_IMPORTED_MODULE_1_styled_components__["a" /* default */].a(_templateObject2);

var print = function print() {
  window.print();
  setTimeout(function () {
    window.location.href = '/';
  }, 100);
};

var _ref = _jsx('div', {}, void 0, _jsx('div', {
  className: 'no-print'
}, void 0, _jsx(ImageContainer, {}, void 0, _jsx('img', {
  src: '/images/cookie-dough-detail.png',
  alt: 'Free Icecream'
}), _jsx('br', {}), _jsx('h1', {}, void 0, 'One free ice cream topping')), _jsx(ImageContainer, {}, void 0, _jsx('img', {
  src: '/images/barcode.png',
  alt: 'barcode'
})), _jsx(PrintLink, {
  onClick: print
}, void 0, 'Print')), _jsx('div', {
  className: 'token'
}, void 0, _jsx('div', {
  className: 'logo'
}, void 0, _jsx('img', {
  src: '/images/logo.svg',
  alt: 'logo'
})), _jsx('p', {}, void 0, 'Congratulations!! You have beaten our Tomato Trader Challenge. Head over to the Ben & Jerry\u2019s stall for a small peaceful reward with your ice cream and hopefully now you\u2019ll find it easier to negotiate the next challenge you face, like the strong women in the Democratic Republic of Congo'), _jsx(ImageContainer, {}, void 0, _jsx('img', {
  src: '/images/barcode.png',
  alt: 'barcode'
}))));

function Print() {

  return _ref;
}

/* harmony default export */ exports["default"] = Print;

/***/ },

/***/ "./app/components/Print/styles.css":
/***/ function(module, exports, __webpack_require__) {

// style-loader: Adds some css to the DOM by adding a <style> tag

// load the styles
var content = __webpack_require__("./node_modules/css-loader/index.js!./app/components/Print/styles.css");
if(typeof content === 'string') content = [[module.i, content, '']];
// add the styles to the DOM
var update = __webpack_require__("./node_modules/style-loader/addStyles.js")(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(false) {
	// When the styles change, update the <style> tags
	if(!content.locals) {
		module.hot.accept("!!../../../node_modules/css-loader/index.js!./styles.css", function() {
			var newContent = require("!!../../../node_modules/css-loader/index.js!./styles.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
	}
	// When the module is disposed, remove the <style> tags
	module.hot.dispose(function() { update(); });
}

/***/ },

/***/ "./node_modules/css-loader/index.js!./app/components/Print/styles.css":
/***/ function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__("./node_modules/css-loader/lib/css-base.js")();
// imports

// module
exports.push([module.i, "\n.token {\n\ttext-align: center;\t\n\tpadding:8px;\n\tdisplay: none;\n}\n\nimg {\n\tmax-width: 90%;\n}\n\n\n@media print {\n  .no-print {\n    display: none;\n\t}\n\t.token {\n\t\tdisplay: block;\n\t}\n}", ""]);

// exports

/***/ }

});


text:
package com.intellij.refactoring.actions;

import javax.annotation.Nonnull;

import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiLocalVariable;
import com.intellij.refactoring.RefactoringActionHandler;
import com.intellij.refactoring.tempWithQuery.TempWithQueryHandler;

public class TempWithQueryAction extends BaseRefactoringAction{
  public boolean isAvailableInEditorOnly() {
    return true;
  }

  public boolean isEnabledOnElements(@Nonnull PsiElement[] elements) {
    return false;
  }

  public RefactoringActionHandler getHandler(@Nonnull DataContext dataContext) {
    return new TempWithQueryHandler();
  }

  protected boolean isAvailableOnElementInEditorAndFile(@Nonnull final PsiElement element, @Nonnull final Editor editor, @Nonnull PsiFile file, @Nonnull DataContext context) {
    return element instanceof PsiLocalVariable && ((PsiLocalVariable) element).getInitializer() != null;
  }
}


text:
<!DOCTYPE html>

    <meta charset="UTF-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="language" content="en" />
        <link href="./assets/70006557/css/bootstrap.css" rel="stylesheet">
<link href="./assets/6c377d3b/style.css" rel="stylesheet">

    <title>Friend, app\modules\v1\models\Friend - Yii Framework 2.0 API Documentation</title>

<button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#w46-collapse">Toggle navigation

</button>Yii Framework 2.0 API Documentation

Class reference

    <input id="searchbox" type="text" class="form-control" placeholder="Search">

app\modules\v1\controllers
AppController
CollectController
FriendController
IndexController
MessageController
MsgController
MyappController
UsersController

app\modules\v1\models
Appl
Appofkind
CollectInteract
CollectPerson
Friend
Message
Msgtoapp
Reply
Reqfriend
User
UserForm
Usertoapp

Class app\modules\v1\models\Friend

    All Classes
                | Methods

    <colgroup>
        <col class="col-name" />
        <col class="col-value" />
    </colgroup>

Inheritance	app\modules\v1\models\Friend »
yii\db\ActiveRecord

This is the model class for table "friends".

Public Methods

Hide inherited methods

<colgroup>
    <col class="col-method" />
    <col class="col-description" />
    <col class="col-defined" />
</colgroup>

  Method	Description	Defined By

        tableName()

        app\modules\v1\models\Friend

Method Details

        tableName()

            public            method

void tableName( )

Page generated on Sun, 19 Jul 2015 05:44:36 +0200

    Powered by Yii Framework


text:
<?php

echo "Migrating project members to edges...\n";
$table = new PhabricatorProject();
$table->establishConnection('w');

foreach (new LiskMigrationIterator($table) as $proj) {
  $id = $proj->getID();
  echo "Project {$id}: ";

  $members = queryfx_all(
    $proj->establishConnection('w'),
    'SELECT userPHID FROM %T WHERE projectPHID = %s',
    'project_affiliation',
    $proj->getPHID());

  if (!$members) {
    echo "-\n";
    continue;
  }

  $members = ipull($members, 'userPHID');

  $editor = new PhabricatorEdgeEditor();
  $editor->setSuppressEvents(true);
  foreach ($members as $user_phid) {
    $editor->addEdge(
      $proj->getPHID(),
      PhabricatorEdgeConfig::TYPE_PROJ_MEMBER,
      $user_phid);
  }
  $editor->save();
  echo "OKAY\n";
}

echo "Done.\n";


text:
<?php

namespace Kirby;

use Obj;

class Roots extends Obj {

  public $index;

  public function __construct($index) {
    $this->index = $index;
  }

  public function content() {
    return isset($this->content) ? $this->content : $this->index . DS . 'content';
  }

  public function site() {
    return isset($this->site) ? $this->site : $this->index . DS . 'site';
  }

  public function kirby() {
    return isset($this->kirby) ? $this->kirby : $this->index . DS . 'kirby';
  }

  public function thumbs() {
    return isset($this->thumbs) ? $this->thumbs : $this->index . DS . 'thumbs';
  }

  public function assets() {
    return isset($this->assets) ? $this->assets : $this->index . DS . 'assets';
  }

  public function autocss() {
    return isset($this->autocss) ? $this->autocss : $this->assets() . DS . 'css' . DS . 'templates';
  }

  public function autojs() {
    return isset($this->autojs) ? $this->autojs : $this->assets() . DS . 'js' . DS . 'templates';
  }

  public function avatars() {
    return isset($this->avatars) ? $this->avatars : $this->assets() . DS . 'avatars';
  }

  public function config() {
    return $this->site() . DS . 'config';
  }

  public function accounts() {
    return isset($this->accounts) ? $this->accounts : $this->site() . DS . 'accounts';
  }

  public function blueprints() {
    return $this->site() . DS . 'blueprints';
  }

  public function plugins() {
    return $this->site() . DS . 'plugins';
  }

  public function cache() {
    return isset($this->cache) ? $this->cache : $this->site() . DS . 'cache';
  }

  public function tags() {
    return $this->site() . DS . 'tags';
  }

  public function fields() {
    return $this->site() . DS . 'fields';
  }

  public function widgets() {
    return $this->site() . DS . 'widgets';
  }

  public function controllers() {
    return $this->site() . DS . 'controllers';
  }

  public function models() {
    return $this->site() . DS . 'models';
  }

  public function templates() {
    return $this->site() . DS . 'templates';
  }

  public function snippets() {
    return $this->site() . DS . 'snippets';
  }

  public function languages() {
    return $this->site() . DS . 'languages';
  }

}


text:
using System;
using TouchScript.Events;
using TouchScript.Gestures;
using UnityEngine;

public class Advanced_Cubes : MonoBehaviour
{
    private enum CubesState
    {
        Idle,
        Rotating
    }

    public float AutoRotationSpeed = 10f;
    public float RotationSpeed = 20f;

    private CubesState State;
    private Quaternion targetRotation;

    public void Rotate(Vector3 axis)
    {
        if (State != CubesState.Idle) return;

        State = CubesState.Rotating;
        targetRotation = Quaternion.AngleAxis(90, axis)*transform.localRotation;
    }

    private void Start()
    {
        targetRotation = transform.localRotation;

        GetComponent<RotateGesture>().StateChanged += onRotateStateChanged;
    }

    private void Update()
    {
        if (State == CubesState.Rotating)
        {
            var fraction = AutoRotationSpeed*Time.deltaTime;
            transform.localRotation = Quaternion.Slerp(transform.localRotation, targetRotation, fraction);
            if (Quaternion.Angle(transform.localRotation, targetRotation) < .1)
            {
                transform.localRotation = targetRotation;
                State = CubesState.Idle;
            }
        } else
        {
            var fraction = RotationSpeed*Time.deltaTime;
            transform.localRotation = Quaternion.Slerp(transform.localRotation, targetRotation, fraction);
        }
    }

    private void onRotateStateChanged(object sender, GestureStateChangeEventArgs e)
    {
        if (State != CubesState.Idle) return;
        switch (e.State)
        {
            case Gesture.GestureState.Began:
            case Gesture.GestureState.Changed:
                var gesture = (RotateGesture)sender;

                if (Math.Abs(gesture.LocalDeltaRotation) > 0.01)
                {
                    targetRotation = Quaternion.AngleAxis(gesture.LocalDeltaRotation, gesture.WorldTransformPlane.normal)*targetRotation;
                }
                break;
        }
    }
}


text:
package com.axemblr.service.cm.models.clusters;

/**
 * Represents of the high-level health status of a subject in the cluster.
 */
public enum HealthSummary {
  DISABLED,
  HISTORY_NOT_AVAILABLE,
  NOT_AVAILABLE,
  GOOD,
  CONCERNING,
  BAD;
}


text:
DROP TABLE IF EXISTS distpol;
create table distpol as select random(), 1 as a, 2 as b;

DROP TABLE IF EXISTS hobbies_r;
CREATE TABLE hobbies_r (
	name		text,
	person 		text
);

DROP TABLE IF EXISTS bar;
CREATE TABLE bar AS SELECT * FROM hobbies_r;


text:
<?php session_start(); ?>
<?php if(isset($_SESSION['user_name'])) { ?>
<!DOCTYPE html>

           <title>Tecnicas</title>
           <link type="text/css" rel ="stylesheet"  href = "../decoradores/Bootstrap_libs/css/bootstrap.min.css"/>
	   <link type="text/css" rel ="stylesheet"  href = "../decoradores/estiloGestionCatalogo.css"/>
           <link type="text/css" rel ="stylesheet" href="../decoradores/dataTable/css/dataTables.bootstrap.min.css">
           <link type="text/css" rel ="stylesheet" href="../decoradores/dataTable/css/select.bootstrap.css">

           <link rel="stylesheet" href="//code.jquery.com/ui/1.11.4/themes/smoothness/jquery-ui.css">

           <meta charset="UTF-8">

       <?php include './Template/HeaderGC.php' ?>

Estilos de obra

                <button class="btn btn-default dropdown-toggle" type="button" data-toggle="dropdown">Accion
                </button>

Añadir

Modificar

Eliminar

                  Codigo
                  Nombre
                  Descripcion

Modificacion de tecnica

Por favor modifique los campos que crea pertinentes

                    <form role="form">

                                    Codigo:*
                                    <input type="text" class="form-control" id="txtCodigo" readonly>

                              Nombre:*
                              <input type="text" class="form-control" id="txtNombre">

                               Descripcion:
		               <textarea id="txaDescripcion" rows = "2" class="form-control"></textarea>

                  </form>

                    <button type="button" id="btnAceptarAct" onclick="validarActulizarTecnica()" class="btn btn-primary">Actualizar</button>
                    <button type="button" class="btn btn-alert" data-dismiss="modal">Salir</button>

Añadir tecnica

Por favor ingrese datos como minimo en los campos obligatorios

                    <form role="form">

                              Nombre:*
                              <input type="text" class="form-control" id="txtNombreAdd">

                               Descripcion:
		               <textarea id="txaDescripcionAdd" rows = "2" class="form-control"></textarea>

                  </form>

                    <button type="button" id="btnAceptarAdd" onclick="validarAdicionTecnica()" class="btn btn-primary">Guardar</button>
                    <button type="button" class="btn btn-alert" data-dismiss="modal">Salir</button>

Borrado de tecnica

                    <form role="form">

                              Nombre:*
                              <input type="text" class="form-control" id="txtNombreElim" readonly>

                  </form>

                    <button type="button" id="btnAceptarElim" onclick="eliminarTecnica()" class="btn btn-danger">Aceptar</button>
                    <button type="button" class="btn btn-alert" data-dismiss="modal">Cancelar</button>

<?php                                   } ?>


text:
module DataMapper
  module Resource
    class PersistenceState

      # a persisted/unmodified resource
      class Clean < Persisted
        def set(subject, value)
          if not_modified?(subject, value)
            self
          else
            # assign to persistence_state so that if Dirty#set calls
            # a Relationship#set, which modifies a Property, the same
            # Dirty state instance will be reused.
            state = resource.persistence_state = Dirty.new(resource)
            state.set(subject, value)
          end
        end

        def delete
          Deleted.new(resource)
        end

        def commit
          self
        end

        def rollback
          self
        end

      private

        def not_modified?(subject, value)
          subject.loaded?(resource) && subject.get!(resource).eql?(value)
        end

      end # class Clean
    end # class PersistenceState
  end # module Resource
end # module DataMapper


text:
@interface TestTableViewController () <UITableViewDelegate, UITableViewDataSource>

@property (nonatomic, strong) UITableView *tableView;

@end

@implementation TestTableViewController

- (void)viewDidLoad {
    self.tableView = [[UITableView alloc] initWithFrame:CGRectMake(0, -64, self.view.width, self.view.height + 64) style:UITableViewStylePlain];
    [self.view addSubview:self.tableView];

    [self.tableView addObserver: self forKeyPath: @"contentOffset" options: NSKeyValueObservingOptionNew context: nil];

    self.tableView.delegate = self;
    self.tableView.dataSource = self;

    UIImageView *imageView = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, self.view.width, 256)];

    imageView.image = [UIImage imageNamed:@"001.jpg"];

    self.tableView.tableHeaderView = imageView;

    [self.tableView registerClass:[UITableViewCell class] forCellReuseIdentifier:@"123"];

    [self.navigationController.navigationBar setShadowImage:[UIImage new]];
}

- (void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];
    [self.navigationController.navigationBar lt_reset];
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return 20;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"123"];

    cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"123"];
    cell.textLabel.text = [NSString stringWithFormat:@"%d",indexPath.row];

    return cell;
}
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
    UIColor * color = [UIColor colorWithRed:0/255.0 green:175/255.0 blue:240/255.0 alpha:1];
    CGFloat offsetY = self.tableView.contentOffset.y;
    if (offsetY > NAVBAR_CHANGE_POINT) {
        CGFloat alpha = MIN(1, 1 - ((NAVBAR_CHANGE_POINT + 64 - offsetY) / 64));
        [self.navigationController.navigationBar lt_setBackgroundColor:[color colorWithAlphaComponent:alpha]];
    } else {
        [self.navigationController.navigationBar lt_setBackgroundColor:[color colorWithAlphaComponent:0]];
    }
}

@end


text:
package ch.iec._61400.ews._1;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for anonymous complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType>
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <choice>
 *         <sequence>
 *           <element name="OldEntrTm" type="{http://iec.ch/61400/ews/1.0/}tTimeStamp"/>
 *           <element name="NewEntrTm" type="{http://iec.ch/61400/ews/1.0/}tTimeStamp"/>
 *           <element name="OldEntr" type="{http://www.w3.org/2001/XMLSchema}unsignedInt"/>
 *           <element name="NewEntr" type="{http://www.w3.org/2001/XMLSchema}unsignedInt"/>
 *         </sequence>
 *         <element name="ServiceError" type="{http://iec.ch/61400/ews/1.0/}tServiceError" minOccurs="0"/>
 *       </choice>
 *       <attribute name="UUID" type="{http://iec.ch/61400/ews/1.0/}tstring36" />
 *       <attribute name="AssocID" use="required" type="{http://iec.ch/61400/ews/1.0/}tAssocID" />
 *     </restriction>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "oldEntrTm",
    "newEntrTm",
    "oldEntr",
    "newEntr",
    "serviceError"
})
@XmlRootElement(name = "GetLogStatusValuesResponse")
public class GetLogStatusValuesResponse {

    @XmlElement(name = "OldEntrTm")
    protected TTimeStamp oldEntrTm;
    @XmlElement(name = "NewEntrTm")
    protected TTimeStamp newEntrTm;
    @XmlElement(name = "OldEntr")
    @XmlSchemaType(name = "unsignedInt")
    protected Long oldEntr;
    @XmlElement(name = "NewEntr")
    @XmlSchemaType(name = "unsignedInt")
    protected Long newEntr;
    @XmlElement(name = "ServiceError")
    protected TServiceError serviceError;
    @XmlAttribute(name = "UUID")
    protected String uuid;
    @XmlAttribute(name = "AssocID", required = true)
    protected String assocID;

    /**
     * Gets the value of the oldEntrTm property.
     *
     * @return
     *     possible object is
     *     {@link TTimeStamp }
     *
     */
    public TTimeStamp getOldEntrTm() {
        return oldEntrTm;
    }

    /**
     * Sets the value of the oldEntrTm property.
     *
     * @param value
     *     allowed object is
     *     {@link TTimeStamp }
     *
     */
    public void setOldEntrTm(TTimeStamp value) {
        this.oldEntrTm = value;
    }

    /**
     * Gets the value of the newEntrTm property.
     *
     * @return
     *     possible object is
     *     {@link TTimeStamp }
     *
     */
    public TTimeStamp getNewEntrTm() {
        return newEntrTm;
    }

    /**
     * Sets the value of the newEntrTm property.
     *
     * @param value
     *     allowed object is
     *     {@link TTimeStamp }
     *
     */
    public void setNewEntrTm(TTimeStamp value) {
        this.newEntrTm = value;
    }

    /**
     * Gets the value of the oldEntr property.
     *
     * @return
     *     possible object is
     *     {@link Long }
     *
     */
    public Long getOldEntr() {
        return oldEntr;
    }

    /**
     * Sets the value of the oldEntr property.
     *
     * @param value
     *     allowed object is
     *     {@link Long }
     *
     */
    public void setOldEntr(Long value) {
        this.oldEntr = value;
    }

    /**
     * Gets the value of the newEntr property.
     *
     * @return
     *     possible object is
     *     {@link Long }
     *
     */
    public Long getNewEntr() {
        return newEntr;
    }

    /**
     * Sets the value of the newEntr property.
     *
     * @param value
     *     allowed object is
     *     {@link Long }
     *
     */
    public void setNewEntr(Long value) {
        this.newEntr = value;
    }

    /**
     * Gets the value of the serviceError property.
     *
     * @return
     *     possible object is
     *     {@link TServiceError }
     *
     */
    public TServiceError getServiceError() {
        return serviceError;
    }

    /**
     * Sets the value of the serviceError property.
     *
     * @param value
     *     allowed object is
     *     {@link TServiceError }
     *
     */
    public void setServiceError(TServiceError value) {
        this.serviceError = value;
    }

    /**
     * Gets the value of the uuid property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getUUID() {
        return uuid;
    }

    /**
     * Sets the value of the uuid property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setUUID(String value) {
        this.uuid = value;
    }

    /**
     * Gets the value of the assocID property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getAssocID() {
        return assocID;
    }

    /**
     * Sets the value of the assocID property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setAssocID(String value) {
        this.assocID = value;
    }

}


text:
@interface IFFlickrPhoto : NSObject

@property (nonatomic, strong) NSString *name;
@property (nonatomic, strong) NSString *url;
@property (nonatomic, strong) NSString *largeUrl;

- (void)loadFlickrPhotos:(NSString *) searchString;

@end


text:
package com.unifonic.sdk.resources.url.impl;

public class HttpOTSUrl extends DefaultOTSUrl {
	public static final String DEFAULT_URLBASE = "http://api.otsdc.com/rest/";

	private HttpOTSUrl(String urlBase) {
		super(urlBase);
	}

	public HttpOTSUrl() {
		this(DEFAULT_URLBASE);
	}

}


text:
# Periodically call a Function

***In this quick example we will see how to use a [`Timer`](/en/latest/reference/mono_Timer.html) to repetitively call a function***

A big part of developing apps is do tasks at regular intervals. Mono employs a timer architecture that allows you to schedule single or recurring function calls, ahead of time. The semantics are "*call this function 3 minutes from now*", or "*call this method every 45 second*".

## Timers

The timer system on Mono is very powerful, you can schedule as many timers as of like! (Okay, you are limited by the amount of RAM). The timers are instances of the class `Timer` and they are built upon the [`bed::Ticker`](https://developer.mbed.org/handbook/Ticker) class. This architecture leverages the versatility of the *mbed* timers and adds thread safety from Mono's own `Timer` class.

You can schedule a method to be called 5 minutes from now, by a single line of code:

```cpp
mono::Timer::callOnce<MyClass>(5*60*1000, this, &MyClass::MyCallbackMethod);
```

This will create a timer instance on the heap, and it will deallocate itself after it has fired. Because we use C++ methods, and not C functions as callbacks, you must provide the `this` pointer and the type definition of the context. (`MyClass` in the example above.) The last parameter is the pointer to the actual method on the class. This makes the call a bit more verbose, compared to C function pointers, but being able define callback methods in C++ is extremely powerful.

```eval_rst
.. note:: In recent versions of C++ (C++11 and C++14), lambda functions has been added. These achieve the same goal with a cleaner syntax. However, we cannot use C++11 or 14 on Mono, the runtime is simply too large!
```

## Call a function every second

Now, let us see how to repeatedly call a function every second. First, we create a new project from the console / terminal:

```
$ monomake project timerExample
```

Open the *app_controller.h* file and add a `Timer` as a member on the `AppController` class, and define the method we want to be called:

```cpp
class AppController : public mono::IApplication {

    // This is the text label object that will displayed
    TextLabelView helloLabel;

    // this is our timer object
    Timer timer;

public:

	//this is our method we want the timer to call
	void timerFire();
```

Because we want to repetitively call a function, we need the timer to stick around and not get deallocated. Therefore, it is declared as a member variable on `AppController`. In the implementation file (*app_controller.cpp*) we need to initialize it, in the constructors initialization list:

```cpp
AppController::AppController() :

    // Call the TextLabel's constructor, with a Rect and a static text
    helloLabel(Rect(0,100,176,20), "Hi, I'm Mono!"),
    // set our timers interval to 1000 ms
    timer(1000)
{
```

Let us add the body of the `timerFire` method to the implementation  file, also:

```cpp
void AppController::timerFire()
{
    printf("Timer did fire!\t\n");
}
```

Lastly, we tie the timer callback handler to out method. This is done from inside the `monoWakeFromReset` method:

```cpp
void AppController::monoWakeFromReset()
{
    // tell the label to show itself on the screen
    helloLabel.show();

    // set the timers callback handler
    timer.setCallback<AppController>(this, &AppController::timerFire);
    // start the timer
    timer.start();
}
```

All right, go to the console and run `make install` and our app should compile and upload to mono. Open a serial terminal and you should see:

```
Timer did fire!
Timer did fire!
Timer did fire!
Timer did fire!
```

Arriving with 1 second intervals.

## Timing the UI

Now, let us step it up a bit. We want to toggle a UI element with our timer function. The SDK includes a class called [`StatusIndicatorView`](/en/latest/reference/mono_ui_StatusIndicatorView.html), it mimics a LED that just is *on* or *off*. Lets add it as a member on our `AppController`:

```cpp
class AppController : public mono::IApplication {

    // This is the text label object that will displayed
    TextLabelView helloLabel;

    Timer timer;

    StatusIndicatorView stView;
```

We also need to initialize with position and dimension in the initializer list:

```cpp
AppController::AppController() :

    // Call the TextLabel's constructor, with a Rect and a static text
    helloLabel(Rect(0,100,176,20), "Hi, I'm Mono!"),
    // set our timers interval to 1000 ms
    timer(1000),

    stView(Rect(75,55,25,25))
{
```

Then, in the `monoWakeFromReset` method we must set its *visibility state *to *shown*:

```cpp
// tell the label to show itself on the screen
helloLabel.show();

// set the timers callback handler
timer.setCallback<AppController>(this, &AppController::timerFire);
// start the timer
timer.start();

stView.show();
```

Last we insert code to toggle its state in the `timerFire` method:

```cpp
void AppController::timerFire()
{
    printf("Timer did fire!\t\n");

    stView.setState(!stView.State());
}
```

Go compile and run the modified code. You should see this on your mono:

![Timer controlling UI state example](timer_example.png "Timer controlling UI state example")

## Sample code

Here is the full source code for reference:

**app_controller.h**:

```cpp
#ifndef app_controller_h
#define app_controller_h

// Include the Mono Framework
#include <mono.h>

// Import the mono and mono::ui namespaces into the context
// to avoid writing long type names, like mono::ui::TextLabel
using namespace mono;
using namespace mono::ui;

// The App main controller object.
// This template app will show a "hello" text in the screen
class AppController : public mono::IApplication {

    // This is the text label object that will displayed
    TextLabelView helloLabel;

    Timer timer;

    StatusIndicatorView stView;

public:

    //this is our method we want the timer to call
	void timerFire();

    // The default constructor
    AppController();

    // Called automaticlly by Mono on device reset
    void monoWakeFromReset();

    // Called automatically by Mono just before it enters sleep mode
    void monoWillGotoSleep();

    // Called automatically by Mono right after after it wakes from sleep
    void monoWakeFromSleep();

};

#endif /* app_controller_h */
```

**app_controller.cpp**:

```cpp
#include "app_controller.h"

using namespace mono::geo;

// Contructor
// initializes the label object with position and text content
// You should init data here, since I/O is not setup yet.
AppController::AppController() :

    // Call the TextLabel's constructor, with a Rect and a static text
    helloLabel(Rect(0,100,176,20), "Hi, I'm Mono!"),
    // set our timers interval to 1000 ms
    timer(1000),

    stView(Rect(88,55,25,25))
{

    // the label is the full width of screen, set it to be center aligned
    helloLabel.setAlignment(TextLabelView::ALIGN_CENTER);

    // set another text color
    helloLabel.setTextColor(display::TurquoiseColor);
}

void AppController::timerFire()
{
    printf("Timer did fire!\t\n");

    stView.setState(!stView.State());
}

void AppController::monoWakeFromReset()
{
    // At this point after reset we can safely expect all peripherals and
    // I/O to be setup & ready.

    // tell the label to show itself on the screen
    helloLabel.show();

    // set the timers callback handler
    timer.setCallback<AppController>(this, &AppController::timerFire);
    // start the timer
    timer.start();

    stView.show();
}

void AppController::monoWillGotoSleep()
{
    // Do any clean up here, before system goes to sleep and power
    // off peripherals.

}

void AppController::monoWakeFromSleep()
{
    // Due to a software bug in the wake-up routines, we need to reset here!
    // If not, Mono will go into an infinite loop!
    mono::IApplicationContext::SoftwareResetToApplication();
    // We never reach this point in the code, CPU has reset!

    // (Normally) after sleep, the screen memory has been cleared - tell the label to
    // draw itself again
    helloLabel.scheduleRepaint();
}
```


text:
<TITLE>Review for Eraser (1996)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Eraser (1996)

reviewed by
Scott Renshaw

                                    ERASER
                       A film review by Scott Renshaw
                        Copyright 1996 Scott Renshaw

Starring: Arnold Schwarzenegger, James Caan, Vanessa Williams, Robert
Pastorelli.
Screenplay:  Tony Puryear, Walon Green.
Director:  Charles Russell.
Reviewed by Scott Renshaw.

     ERASER is a strange case this summer.  Here is an Arnold
Schwarzenegger action film, carrying an estimated $80 million price tag,
recently in entertainment headlines for last-minute digital work required
to change the name of the company in the film due to a legal
challenge...and hardly anyone seems to be talking about it.  In a movie
season where marketing has attempted to turn every subsequent blockbuster
into a pop culture happening, ERASER seems to be just another supporting
player; it is even sharing its release date with Disney's latest animated
fiscal printing press THE HUNCHBACK OF NOTRE DAME.  Arnold seems to have
managed the heretofore unthinkable feat of becoming unobtrusive.  The
result might be an absence of overly high expectations, which can only
work in ERASER's favor.  It's generic Schwarzeneggerian action fare which
almost manages to seem quaint in its cartoonish basic-ness.

     Schwarzenegger plays John Kruger, a U. S. Marshal working for the
Federal Witness Protection Program whose specialty is staging the deaths
of his charges to keep them safe -- hence his code name "Eraser."  His
latest case is Lee Cullen (Vanessa Williams), an employee at defense
contractor Cyrez who has agreed to obtain proof that the company is
involved in the sale of experimental weaponry on the black market.  What
Kruger is soon to realize is that even government officials are involved
in the operation, perhaps including his own mentor Robert Deguerin (James
Caan).  But it is Kruger himself who is set up as a traitor, and forced to
keep both himself and Lee alive.  With no one he can trust except his
other re-located witnesses, including mob stool pigeon Johnny Casteleone
(Robert Pastorelli), Kruger must find proof of his own innocence as he
tries to stop the gun-runners.

     ERASER is pretty much everything you've come to expect from a
Schwarzenegger action vehicle:  impossible odds, explosions, predictable
and groan-inducing one-liners (if you can't tell me what precedes the line
"They had to catch a train," please sign up for Remedial Arnie-isms), big
cool guns, and big cool Arnie firing them with abandon.  Director Charles
Russell (THE MASK) leaps right into the action with scarcely a breath, and
for the next 100 minutes seems blissfully concerned with little else.  It
is as though he were saying to the audience, "I've given you a good guy
and some bad guys -- you know how it's going to end, now enjoy the ride."

     And in spurts, it's actually possible to do so.  During one
marvelously sill twenty minute stretch, Schwarzenegger leaps from a plane
to catch up with a parachute he has already thrown out of it, faces down
the same plane while still floating through the air, crash lands in a
junkyard, appropriates a truck, races to a zoo and ends up battling with
villainous Feds _and_ digitally-created alligators.  In those scenes,
ERASER is pure mindless fun in the best sense of the term, but those
scenes are also somewhat isolated.  There is a surprising grimness to much
of ERASER, including two separate incidents where Kruger takes an
excruciatingly long time to remove a piece of shrapnel from his flesh, and
Schwarzenegger himself is overly somber in much of his performance,
brooding over a Dark Past to which we are not made privy.  These token
attempts by Russell and his screenplay-by-committee team to make
Schwarzenegger more vulnerable and human demonstrate a real
misunderstanding of his appeal.  Audiences come to see Schwarzenegger the
super-hero, and to laugh along with his awareness of the absurd situations
in his action films; he is the master of the catch phrase because they are
winking distillations of those absurdities.  There are far too few
opportunities to laugh in ERASER, except those provided by Robert
Pastorelli as the motor-mouthed wiseguy who becomes Kruger's assistant.

     The irony of ERASER is that it turns its greatest asset into a
weakness.  In a season filled with films which seem to be playing hyped-up
games of "Can You Top This?" with their visual effects and decibel levels,
ERASER provides an odd familiarity -- it's just li'l ol' Arnie, playing
hero and making the world safe for democracy.  Unfortunately, ERASER just
rests on its familiarity, providing a bland villain (Caan playing Sonny
Corleone as a turn-coat G-Man), a bland heroine (Vanessa Williams running
and serving up the occasional "I-am-woman-watch-me-kick-a-little-ass" bit
of crowd-pleasing) and a finale which is truly anti-climactic.  ERASER
manages a few solidly entertaining moments, and serves up the kind of
meat-and-potatoes action Schwarzenegger's fans have come to expect.  It
also is a film which spends a lot of time shuffling its feet, and it will
be interesting to see how audiences respond to a blockbuster which seems
to be saying, "Don't mind me."

     On the Renshaw scale of 0 to 10 ERASER's edges:  5.

--
Scott Renshaw
Stanford University
http://www-leland.stanford.edu

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
<!DOCTYPE html>

  <meta charset="UTF-8">
  <title>Code Coverage for C:\wamp\www\skeleton-application/vendor/zendframework/zendframework/library/Zend/View</title>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link href="../../../../../../css/bootstrap.min.css" rel="stylesheet">
  <link href="../../../../../../css/style.css" rel="stylesheet">

C:\wamp\www\skeleton-application

vendor

zendframework

zendframework

library

Zend

View

(Dashboard)

Code Coverage

Lines

Functions and Methods

Classes and Traits

      Total

           0.00% covered (danger)

0.00%

0 / 3

           0.00% covered (danger)

0.00%

0 / 2

           0.00% covered (danger)

0.00%

0 / 1

       Helper

           0.00% covered (danger)

0.00%

0 / 3

           0.00% covered (danger)

0.00%

0 / 2

           0.00% covered (danger)

0.00%

0 / 1

Legend

     Low: 0% to 50%
     Medium: 50% to 90%
     High: 90% to 100%

     Generated by PHP_CodeCoverage 2.0.11 using PHP 5.5.12 and PHPUnit 4.2.6 at Tue Sep 30 13:51:31 CEST 2014.


text:
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <Console name="ConsoleNormal" target="SYSTEM_OUT">
      <PatternLayout pattern="%highlight{%d{HH:mm:ss.SSS} %msg%n}{INFO=yellow}"/>
      <MarkerFilter marker="AUDIT" onMatch="ACCEPT" onMismatch="DENY"/>
    </Console>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%highlight{%d{HH:mm:ss.SSS} %-5level %logger{1}#%M:%L - %msg%n}{FATAL=red blink, ERROR=red, WARN=yellow bold, INFO=blue, DEBUG=green bold, TRACE=black}"/>
      <MarkerFilter marker="AUDIT" onMatch="DENY" onMismatch="ACCEPT"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="info">
      <AppenderRef ref="Console"/>
      <AppenderRef ref="ConsoleNormal"/>
    </Root>
  </Loggers>
</Configuration>